move to github

Neoforce/ArchiveManager.cs

@@ -0,0 +1,286 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ArchiveManager.cs                            //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Microsoft.Xna.Framework.Content;
+using TomShane.Neoforce.External.Zip;
+using System.Globalization;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Classes ///////////
+  
+  ////////////////////////////////////////////////////////////////////////////  
+  /// <include file='Documents/ArchiveManager.xml' path='ArchiveManager/Class[@name="ArchiveManager"]/*' />          
+  public class ArchiveManager : ContentManager
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private string archivePath = null;
+    private ZipFile archive = null;
+    private bool useArchive = false;   
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    /// <include file='Documents/ArchiveManager.xml' path='ArchiveManager/Member[@name="ArchivePath"]/*' />          
+    public virtual string ArchivePath
+    {
+      get { return archivePath; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public bool UseArchive
+    {
+      get { return useArchive; }
+      set { useArchive = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    /// <include file='Documents/ArchiveManager.xml' path='ArchiveManager/Member[@name="ArchiveManager"]/*' />              
+    public ArchiveManager(IServiceProvider serviceProvider) : this(serviceProvider, null) { }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    /// <include file='Documents/ArchiveManager.xml' path='ArchiveManager/Member[@name="ArchiveManager1"]/*' />                  
+    public ArchiveManager(IServiceProvider serviceProvider, string archive): base(serviceProvider)
+    {
+      if (archive != null)
+      {
+        this.archive = ZipFile.Read(archive);
+        archivePath = archive;
+        useArchive = true;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////        
+    /// <include file='Documents/ArchiveManager.xml' path='ArchiveManager/Member[@name="OpenStream"]/*' />
+    protected override Stream OpenStream(string assetName)
+    {
+      if (useArchive && archive != null)
+      {
+        assetName = assetName.Replace("\\", "/");
+        if (assetName.StartsWith("/")) assetName = assetName.Remove(0, 1);
+
+        string fullAssetName = (assetName + ".xnb").ToLower();
+
+        foreach (ZipEntry entry in archive)
+        {
+          ZipDirEntry ze = new ZipDirEntry(entry);
+          
+          string entryName = entry.FileName.ToLower();
+
+          if (entryName == fullAssetName)
+          {
+            return entry.GetStream();
+          }
+        }
+        throw new Exception("Cannot find asset \"" + assetName + "\" in the archive.");
+      }
+      else
+      {
+        return base.OpenStream(assetName);
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    /// <include file='Documents/ArchiveManager.xml' path='ArchiveManager/Member[@name="GetAssetNames"]/*' />
+    public string[] GetAssetNames()
+    {
+      if (useArchive && archive != null)
+      {
+        List<string> filenames = new List<string>();
+
+        foreach (ZipEntry entry in archive)
+        {
+          string name = entry.FileName;
+          if (name.EndsWith(".xnb"))
+          {
+            name = name.Remove(name.Length - 4, 4);
+            filenames.Add(name);
+          }
+        }
+        return filenames.ToArray();
+      }
+      else
+      {
+        return null;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    /// <include file='Documents/ArchiveManager.xml' path='ArchiveManager/Member[@name="GetAssetNames1"]/*' />        
+    public string[] GetAssetNames(string path)
+    {
+      if (useArchive && archive != null)
+      {
+        if (path != null && path != "" && path != "\\" && path != "/")
+        {
+          List<string> filenames = new List<string>();
+
+          foreach (ZipEntry entry in archive)
+          {            
+            string name = entry.FileName;
+            if (name.EndsWith(".xnb"))
+            {
+              name = name.Remove(name.Length - 4, 4);
+            }
+
+            string[] parts = name.Split('/');
+            string dir = "";
+            for (int i = 0; i < parts.Length - 1; i++)
+            {
+              dir += parts[i] + '/';
+            }
+
+            path = path.Replace("\\", "/");
+            if (path.StartsWith("/")) path = path.Remove(0, 1);
+            if (!path.EndsWith("/")) path += '/';
+
+            if (dir.ToLower() == path.ToLower() && !name.EndsWith("/"))
+            {
+              filenames.Add(name);
+            }
+          }
+          return filenames.ToArray();
+        }
+        else
+        {
+          return GetAssetNames();
+        }
+      }
+      else
+      {
+        return null;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    /// <include file='Documents/ArchiveManager.xml' path='ArchiveManager/Member[@name="GetFileStream"]/*' />
+    public Stream GetFileStream(string filename)
+    {
+      if (useArchive && archive != null)
+      {
+        filename = filename.Replace("\\", "/").ToLower();
+        if (filename.StartsWith("/")) filename = filename.Remove(0, 1);
+
+        foreach (ZipEntry entry in archive)
+        {
+          string entryName = entry.FileName.ToLower();
+
+          if (entryName.Equals(filename))
+            return entry.GetStream();
+        }
+
+        throw new Exception("Cannot find file \"" + filename + "\" in the archive.");
+      }
+      else
+      {
+        return null;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public string[] GetDirectories(string path)
+    {
+      if (useArchive && archive != null)
+      {
+        if (path != null && path != "" && path != "\\" && path != "/")
+        {
+          List<string> dirs = new List<string>();
+
+          path = path.Replace("\\", "/");
+          if (path.StartsWith("/")) path = path.Remove(0, 1);
+          if (!path.EndsWith("/")) path += '/';
+
+          foreach (ZipEntry entry in archive)
+          {
+            string name = entry.FileName;                     
+            if (name.ToLower().StartsWith(path.ToLower()))
+            {
+              int i = name.IndexOf("/", path.Length);
+              string item = name.Substring(path.Length, i - path.Length) + "\\";
+              if (!dirs.Contains(item))
+              {
+                dirs.Add(item);
+              }  
+            }            
+          }
+          return dirs.ToArray();
+        }
+        else
+        {
+          return GetAssetNames();
+        }
+      }
+      else if (Directory.Exists(path))
+      {
+        string[] dirs = Directory.GetDirectories(path);
+        
+        for (int i = 0; i < dirs.Length; i++)
+        {
+          string[] parts = dirs[i].Split('\\');
+          dirs[i] = parts[parts.Length - 1] + '\\';
+        }
+        
+        return dirs;
+      }
+      else return null;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion  
+  
+}

Neoforce/Bevel.cs

@@ -0,0 +1,306 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Bevel.cs                                     //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+  #region //// Enums /////////////
+
+  ////////////////////////////////////////////////////////////////////////////                 
+  public enum BevelStyle
+  {
+    None,
+    Flat,
+    Etched,
+    Bumped,
+    Lowered,
+    Raised
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////  
+  public enum BevelBorder
+  {
+    None,
+    Left,
+    Top,
+    Right,
+    Bottom,
+    All
+  }
+  ////////////////////////////////////////////////////////////////////////////  
+
+  #endregion
+
+  public class Bevel: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private BevelBorder border = BevelBorder.All;
+    private BevelStyle style = BevelStyle.Etched;   
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public BevelBorder Border
+    {
+      get { return border; }
+      set 
+      { 
+        if (border != value)
+        {
+          border = value;
+          if (!Suspended) OnBorderChanged(new EventArgs());
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public BevelStyle Style
+    {
+      get { return style; }
+      set
+      { 
+        if (style != value)
+        {
+          style = value;
+          if (!Suspended) OnStyleChanged(new EventArgs());
+        }          
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    public event EventHandler BorderChanged;
+    public event EventHandler StyleChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public Bevel(Manager manager): base(manager)
+    {            
+      CanFocus = false;
+      Passive = true;      
+      Width = 64;
+      Height = 64;
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////                                                        
+
+    ////////////////////////////////////////////////////////////////////////////                                                        
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();      
+    }
+    ////////////////////////////////////////////////////////////////////////////                                                        
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {   
+      if (Border != BevelBorder.None && Style != BevelStyle.None)
+      {           
+        if (Border != BevelBorder.All)
+        {
+          DrawPart(renderer, rect, Border, Style, false);  
+        }
+        else
+        {
+          DrawPart(renderer, rect, BevelBorder.Left, Style, true);
+          DrawPart(renderer, rect, BevelBorder.Top, Style, true);
+          DrawPart(renderer, rect, BevelBorder.Right, Style, true);
+          DrawPart(renderer, rect, BevelBorder.Bottom, Style, true);
+        }  
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    private void DrawPart(Renderer renderer, Rectangle rect, BevelBorder pos, BevelStyle style, bool all)
+    {                  
+      SkinLayer layer = Skin.Layers["Control"];   
+      Color c1 = Utilities.ParseColor(layer.Attributes["LightColor"].Value);
+      Color c2 = Utilities.ParseColor(layer.Attributes["DarkColor"].Value);
+      Color c3 = Utilities.ParseColor(layer.Attributes["FlatColor"].Value); 
+      
+      if (Color != UndefinedColor) c3 = Color;
+      
+      Texture2D img = Skin.Layers["Control"].Image.Resource;
+
+      int x1 = 0; int y1 = 0; int w1 = 0; int h1 = 0;
+      int x2 = 0; int y2 = 0; int w2 = 0; int h2 = 0;
+            
+      if (style == BevelStyle.Bumped || style == BevelStyle.Etched)     
+      {        
+        if (all && (pos == BevelBorder.Top || pos == BevelBorder.Bottom))
+        {
+          rect = new Rectangle(rect.Left + 1, rect.Top, rect.Width - 2, rect.Height);
+        }
+        else if (all && (pos == BevelBorder.Left))
+        {
+          rect = new Rectangle(rect.Left, rect.Top, rect.Width, rect.Height - 1);
+        }
+        switch (pos)
+        {
+          case BevelBorder.Left:
+          {
+            x1 = rect.Left; y1 = rect.Top; w1 = 1; h1 = rect.Height;
+            x2 = x1 + 1; y2 = y1; w2 = w1; h2 = h1;
+            break;
+          }
+          case BevelBorder.Top:
+          {
+            x1 = rect.Left; y1 = rect.Top; w1 = rect.Width; h1 = 1;
+            x2 = x1; y2 = y1 + 1; w2 = w1; h2 = h1;
+            break;
+          }
+          case BevelBorder.Right:
+          {
+            x1 = rect.Left + rect.Width - 2; y1 = rect.Top; w1 = 1; h1 = rect.Height;
+            x2 = x1 + 1; y2 = y1; w2 = w1; h2 = h1;
+            break;
+          }
+          case BevelBorder.Bottom:
+          {
+            x1 = rect.Left; y1 = rect.Top + rect.Height - 2; w1 = rect.Width; h1 = 1;
+            x2 = x1; y2 = y1 + 1; w2 = w1; h2 = h1;
+            break;
+          }
+        }                                             
+      }
+      else
+      {
+        switch (pos)
+        {
+          case BevelBorder.Left:
+          {
+            x1 = rect.Left; y1 = rect.Top; w1 = 1; h1 = rect.Height;            
+            break;
+          }
+          case BevelBorder.Top:
+          {
+            x1 = rect.Left; y1 = rect.Top; w1 = rect.Width; h1 = 1;            
+            break;
+          }
+          case BevelBorder.Right:
+          {
+            x1 = rect.Left + rect.Width - 1; y1 = rect.Top; w1 = 1; h1 = rect.Height;            
+            break;
+          }
+          case BevelBorder.Bottom:
+          {
+            x1 = rect.Left; y1 = rect.Top + rect.Height - 1; w1 = rect.Width; h1 = 1;            
+            break;
+          }
+        }
+      } 
+                            
+      switch (Style)
+      {
+        case BevelStyle.Bumped:
+        {
+          renderer.Draw(img, new Rectangle(x1, y1, w1, h1), c1);
+          renderer.Draw(img, new Rectangle(x2, y2, w2, h2), c2);          
+          break;
+        }
+        case BevelStyle.Etched:
+        {
+          renderer.Draw(img, new Rectangle(x1, y1, w1, h1), c2);
+          renderer.Draw(img, new Rectangle(x2, y2, w2, h2), c1);          
+          break;
+        }
+        case BevelStyle.Raised:
+        {
+          Color c = c1;
+          if (pos == BevelBorder.Left || pos == BevelBorder.Top) c = c1;
+          else c = c2;          
+          
+          renderer.Draw(img, new Rectangle(x1, y1, w1, h1), c);     
+          break;
+        }
+        case BevelStyle.Lowered:
+        {
+          Color c = c1;
+          if (pos == BevelBorder.Left || pos == BevelBorder.Top) c = c2;
+          else c = c1; 
+          
+          renderer.Draw(img, new Rectangle(x1, y1, w1, h1), c);     
+          break;
+        }
+        default:
+        {
+          renderer.Draw(img, new Rectangle(x1, y1, w1, h1), c3);     
+          break;
+        }
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////          
+    protected virtual void OnBorderChanged(EventArgs e)
+    {
+      if (BorderChanged != null) BorderChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////          
+
+    ////////////////////////////////////////////////////////////////////////////          
+    protected virtual void OnStyleChanged(EventArgs e)
+    {
+      if (StyleChanged != null) StyleChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////          
+
+
+    #endregion  
+
+  }
+
+}

Neoforce/Button.cs

@@ -0,0 +1,294 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Button.cs                                    //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+
+#region //// Using /////////////
+
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+  
+  #region //// Enums /////////////
+  
+  ////////////////////////////////////////////////////////////////////////////              
+  ///  <include file='Documents/Button.xml' path='Button/Class[@name="SizeMode"]/*' />
+  public enum SizeMode
+  {
+    Normal, 
+    Auto,
+    Centered,
+    Stretched,
+      /// <summary>
+      /// Only Supported by ImageBox
+      /// </summary>
+    Tiled
+  }  
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////              
+  ///  <include file='Documents/Button.xml' path='Button/Class[@name="SizeMode"]/*' />
+  public enum ButtonMode
+  {
+    Normal,
+    PushButton
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+
+  #endregion
+
+  #region //// Classes ///////////
+  
+  ////////////////////////////////////////////////////////////////////////////              
+  ///  <include file='Documents/Button.xml' path='Button/Class[@name="Glyph"]/*' />          
+  public class Glyph
+  {
+    ////////////////////////////////////////////////////////////////////////////  
+    public Texture2D Image = null;
+    public SizeMode SizeMode = SizeMode.Stretched;
+    public Color Color = Color.White;
+    public Point Offset = Point.Zero;  
+    public Rectangle SourceRect = Rectangle.Empty;
+    ////////////////////////////////////////////////////////////////////////////  
+    
+    ////////////////////////////////////////////////////////////////////////////  
+    public Glyph(Texture2D image)
+    {
+      Image = image;
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+    
+    ////////////////////////////////////////////////////////////////////////////  
+    public Glyph(Texture2D image, Rectangle sourceRect): this(image)
+    {      
+      SourceRect = sourceRect;
+    }
+  }
+  ////////////////////////////////////////////////////////////////////////////  
+    
+  ////////////////////////////////////////////////////////////////////////////  
+  ///  <include file='Documents/Button.xml' path='Button/Class[@name="Button"]/*' />          
+  public class Button: ButtonBase
+  {
+
+    #region //// Consts ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private const string skButton = "Button";
+    private const string lrButton = "Control";
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////              
+    private Glyph glyph = null;
+    private ModalResult modalResult = ModalResult.None;
+    private ButtonMode mode = ButtonMode.Normal;
+    private bool pushed = false;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////        
+    public Glyph Glyph
+    {
+      get { return glyph; }
+      set 
+      { 
+        glyph = value;
+        if (!Suspended) OnGlyphChanged(new EventArgs());        
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public ModalResult ModalResult
+    {
+      get { return modalResult; }
+      set { modalResult = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public ButtonMode Mode
+    {
+      get { return mode; }
+      set { mode = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public bool Pushed
+    {
+      get { return pushed; }
+      set 
+      { 
+        pushed = value; 
+        Invalidate();
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    public event EventHandler GlyphChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public Button(Manager manager): base(manager)
+    {            
+      SetDefaultSize(72, 24);      
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Destructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void Dispose(bool disposing)
+    {
+      if (disposing)
+      {
+      }
+      base.Dispose(disposing);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();        
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls[skButton]);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {                    
+
+      if (mode == ButtonMode.PushButton && pushed)
+      {
+        SkinLayer l = Skin.Layers[lrButton];
+        renderer.DrawLayer(l, rect, l.States.Pressed.Color, l.States.Pressed.Index);
+        if (l.States.Pressed.Overlay)
+        {
+          renderer.DrawLayer(l, rect, l.Overlays.Pressed.Color, l.Overlays.Pressed.Index);          
+        }                
+      }
+      else
+      {
+        base.DrawControl(renderer, rect, gameTime);
+      }
+    
+      SkinLayer layer = Skin.Layers[lrButton];                                  
+      SpriteFont font = (layer.Text != null && layer.Text.Font != null) ? layer.Text.Font.Resource : null;
+      Color col = Color.White;              
+      int ox = 0; int oy = 0;
+    
+      if (ControlState == ControlState.Pressed)
+      {       
+        if (layer.Text != null) col = layer.Text.Colors.Pressed;
+        ox = 1; oy = 1;
+      }                               
+      if (glyph != null)
+      {
+        Margins cont = layer.ContentMargins;
+        Rectangle r = new Rectangle(rect.Left + cont.Left, 
+                                    rect.Top + cont.Top, 
+                                    rect.Width - cont.Horizontal, 
+                                    rect.Height - cont.Vertical);
+        renderer.DrawGlyph(glyph, r);
+      }
+      else 
+      {
+        renderer.DrawString(this, layer, Text, rect, true, ox, oy);
+      }       
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    private void OnGlyphChanged(EventArgs e)
+    {
+      if (GlyphChanged != null) GlyphChanged.Invoke(this, e);
+    }
+    //////////////////////////////////////////////////////////////////////////// 
+
+    //////////////////////////////////////////////////////////////////////////// 
+    protected override void OnClick(EventArgs e)
+    {
+      MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs)e : new MouseEventArgs();      
+      
+      if (ex.Button == MouseButton.Left || ex.Button == MouseButton.None)
+      {
+        pushed = !pushed;
+      }  
+      
+      base.OnClick(e);           
+      
+      if ((ex.Button == MouseButton.Left || ex.Button == MouseButton.None) && Root != null)
+      {
+        if (Root is Window)
+        {
+          Window wnd = (Window)Root;
+          if (ModalResult != ModalResult.None)
+          {            
+            wnd.Close(ModalResult);
+          }
+        }        
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+  
+    #endregion  
+     
+  }
+  
+  #endregion
+  
+}

Neoforce/ButtonBase.cs

@@ -0,0 +1,117 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ButtonBase.cs                                //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Classes ///////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  ///  <include file='Documents/ButtonBase.xml' path='ButtonBase/Class[@name="ButtonBase"]/*' />          
+  public abstract class ButtonBase: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                  
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public override ControlState ControlState
+    {
+      get
+      {
+        if (DesignMode) return ControlState.Enabled;
+        else if (Suspended) return ControlState.Disabled;
+        else
+        {
+          if (!Enabled) return ControlState.Disabled;
+
+          if ((Pressed[(int)MouseButton.Left] && Inside) || (Focused && (Pressed[(int)GamePadActions.Press] || Pressed[(int)MouseButton.None]))) return ControlState.Pressed;
+          else if (Hovered && Inside) return ControlState.Hovered;
+          else if ((Focused && !Inside) || (Hovered && !Inside) || (Focused && !Hovered && Inside)) return ControlState.Focused;
+          else return ControlState.Enabled;
+        }
+      }
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////   
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    protected ButtonBase(Manager manager)
+      : base(manager)
+    {
+      SetDefaultSize(72, 24);
+      DoubleClicks = false;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////                                 
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnClick(EventArgs e)
+    {
+      MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs)e : new MouseEventArgs();      
+      if (ex.Button == MouseButton.Left || ex.Button == MouseButton.None)
+      {
+        base.OnClick(e);
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion
+  
+}

Neoforce/CheckBox.cs

@@ -0,0 +1,158 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: CheckBox.cs                                  //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+  public class CheckBox: ButtonBase
+  {
+
+    #region //// Consts ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private const string skCheckBox = "CheckBox";
+    private const string lrCheckBox = "Control";
+    private const string lrChecked  = "Checked";   
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////               
+    private bool state = false;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual bool Checked 
+    { 
+      get 
+      { 
+        return state; 
+      } 
+      set 
+      { 
+        state = value; 
+        Invalidate();
+        if (!Suspended) OnCheckedChanged(new EventArgs());
+      } 
+    }   
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                     
+    public event EventHandler CheckedChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public CheckBox(Manager manager): base(manager)
+    {
+      CheckLayer(Skin, lrChecked);      
+
+      Width = 64;
+      Height = 16;           
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls[skCheckBox]);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {      
+      SkinLayer layer = Skin.Layers[lrChecked];
+      SkinText font = Skin.Layers[lrChecked].Text;      
+      
+      if (!state)
+      {
+        layer = Skin.Layers[lrCheckBox];
+        font = Skin.Layers[lrCheckBox].Text;      
+      }
+            
+      rect.Width = layer.Width;
+      rect.Height = layer.Height;      
+      Rectangle rc = new Rectangle(rect.Left + rect.Width + 4, rect.Y,  Width - (layer.Width + 4), rect.Height);
+      
+      renderer.DrawLayer(this, layer, rect);            
+      renderer.DrawString(this, layer, Text, rc, false, 0, 0);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnClick(EventArgs e)    
+    {
+      MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs)e : new MouseEventArgs();      
+      
+      if (ex.Button == MouseButton.Left || ex.Button == MouseButton.None)      
+      {        
+        Checked = !Checked;
+      }  
+      base.OnClick(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnCheckedChanged(EventArgs e)
+    {
+      if (CheckedChanged != null) CheckedChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+
+    #endregion  
+
+  }
+
+}

Neoforce/ClipBox.cs

@@ -0,0 +1,65 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ClipBox.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+  
+  public class ClipBox: Control
+  {    
+  
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public ClipBox(Manager manager): base(manager)
+    {            
+      Color =  Color.Transparent;
+      BackColor = Color.Transparent;
+      CanFocus = false;
+      Passive = true;      
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+		#region //// Methods ///////////
+			
+		////////////////////////////////////////////////////////////////////////////
+		protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {            
+      base.DrawControl(renderer, rect, gameTime);
+    }
+		////////////////////////////////////////////////////////////////////////////   		
+    
+		#endregion  
+		
+  }
+  
+}

Neoforce/ClipControl.cs

@@ -0,0 +1,181 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Control.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{     
+      
+  public class ClipControl: Control
+  {
+   
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    private ClipBox clientArea;  
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion   
+
+    #region //// Properties ////////
+   
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual ClipBox ClientArea
+    {
+      get { return clientArea; }
+      set { clientArea = value; }
+    }   
+    ////////////////////////////////////////////////////////////////////////////          
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override Margins ClientMargins
+    {
+      get
+      {
+        return base.ClientMargins;
+      }
+      set
+      {
+        base.ClientMargins = value;
+        if (clientArea != null)
+        {
+          clientArea.Left = ClientLeft;
+          clientArea.Top = ClientTop;
+          clientArea.Width = ClientWidth;
+          clientArea.Height = ClientHeight;        
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+        
+    #endregion
+    
+ 	  #region //// Constructors //////
+	 		
+	  ////////////////////////////////////////////////////////////////////////////
+		public ClipControl(Manager manager): base(manager)
+    {                              
+      clientArea = new ClipBox(manager);      
+      
+      clientArea.Init();
+      clientArea.MinimumWidth = 0;
+      clientArea.MinimumHeight = 0;
+      clientArea.Left = ClientLeft;
+      clientArea.Top = ClientTop;
+      clientArea.Width = ClientWidth;
+      clientArea.Height = ClientHeight;
+                
+      base.Add(clientArea);
+    }
+    ////////////////////////////////////////////////////////////////////////////       
+       
+  	#endregion   
+
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();           
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void Add(Control control, bool client)
+    {
+      if (client)
+      {
+        clientArea.Add(control);        
+      }
+      else
+      {
+        base.Add(control);
+      }                  
+    }
+    ////////////////////////////////////////////////////////////////////////////           
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Add(Control control)
+    {
+      Add(control, true);
+    }
+    ////////////////////////////////////////////////////////////////////////////       
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public override void Remove(Control control)
+    {
+      base.Remove(control);
+      clientArea.Remove(control);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void Update(GameTime gameTime)
+    {      
+      base.Update(gameTime);               
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {      
+      base.DrawControl(renderer, rect, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+    
+    ////////////////////////////////////////////////////////////////////////////  
+    protected override void OnResize(ResizeEventArgs e)
+    {
+      base.OnResize(e);
+      
+      if (clientArea != null)
+      {      
+        clientArea.Left = ClientLeft;
+        clientArea.Top = ClientTop;
+        clientArea.Width = ClientWidth;
+        clientArea.Height = ClientHeight;
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////             
+
+    ////////////////////////////////////////////////////////////////////////////  
+    protected virtual void AdjustMargins()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+                         
+    #endregion
+  }
+
+}

Neoforce/ComboBox.cs

@@ -0,0 +1,418 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ComboBox.cs                                  //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+using System.Collections.Generic;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+using System;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public class ComboBox: TextBox
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                     
+    private Button btnDown = null;    
+    private List<object> items = new List<object>();
+    private ListBox lstCombo = null;    
+    private int maxItems = 5;
+    private bool drawSelection = true;  
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override bool ReadOnly
+    {
+      get { return base.ReadOnly; }
+      set
+      {
+        base.ReadOnly = value;
+        CaretVisible = !value;
+        if (value)
+        {
+          #if (!XBOX && !XBOX_FAKE)
+            Cursor = Manager.Skin.Cursors["Default"].Resource;
+          #endif 
+        }
+        else
+        {
+          #if (!XBOX && !XBOX_FAKE)
+            Cursor = Manager.Skin.Cursors["Text"].Resource;
+          #endif         
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public bool DrawSelection
+    {
+      get { return drawSelection; }
+      set { drawSelection = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override string Text
+    {
+        get
+        {
+            return base.Text;
+        }
+        set
+        {
+            base.Text = value;
+            //if (!items.Contains(value))  --- bug
+            if (!items.ConvertAll(item => item.ToString()).Contains(value))
+            {
+                ItemIndex = -1;
+            }
+        }
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual List<object> Items
+    {
+      get { return items; }      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public int MaxItems
+    {
+      get { return maxItems; }
+      set 
+      { 
+        if (maxItems != value)
+        {
+          maxItems = value; 
+          if (!Suspended) OnMaxItemsChanged(new EventArgs());
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public int ItemIndex
+    {
+      get { return lstCombo.ItemIndex; }
+      set 
+      { 
+        if (lstCombo != null)
+        {
+          if (value >= 0 && value < items.Count)
+          {
+            lstCombo.ItemIndex = value; 
+            Text = lstCombo.Items[value].ToString();
+          }
+          else
+          {
+            lstCombo.ItemIndex = -1;          
+          }
+        }  
+        if (!Suspended) OnItemIndexChanged(new EventArgs());
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    public event EventHandler MaxItemsChanged;    
+    public event EventHandler ItemIndexChanged;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ComboBox(Manager manager): base(manager)
+    {
+      Height = 20;
+      Width = 64;
+      ReadOnly = true;      
+            
+      btnDown = new Button(Manager);
+      btnDown.Init();
+      btnDown.Skin = new SkinControl(Manager.Skin.Controls["ComboBox.Button"]);
+      btnDown.CanFocus = false;      
+      btnDown.Click += new EventHandler(btnDown_Click);      
+      Add(btnDown, false);            
+
+      lstCombo = new ListBox(Manager);
+      lstCombo.Init();
+      lstCombo.HotTrack = true;      
+      lstCombo.Detached = true;
+      lstCombo.Visible = false;      
+      lstCombo.Click += new EventHandler(lstCombo_Click);
+      lstCombo.FocusLost += new EventHandler(lstCombo_FocusLost);
+      lstCombo.Items = items;      
+      manager.Input.MouseDown += new MouseEventHandler(Input_MouseDown);      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion            
+       
+    #region //// Destructors ///////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void Dispose(bool disposing)
+    {
+      if (disposing)
+      {
+        // We added the listbox to another parent than this control, so we dispose it manually
+        if (lstCombo != null)
+        {
+          lstCombo.Dispose();
+          lstCombo = null;
+        }
+        Manager.Input.MouseDown -= Input_MouseDown;
+      }
+      base.Dispose(disposing);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion   
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();      
+
+      lstCombo.Skin = new SkinControl(Manager.Skin.Controls["ComboBox.ListBox"]);      
+
+      btnDown.Glyph = new Glyph(Manager.Skin.Images["Shared.ArrowDown"].Resource);
+      btnDown.Glyph.Color = Manager.Skin.Controls["ComboBox.Button"].Layers["Control"].Text.Colors.Enabled;
+      btnDown.Glyph.SizeMode = SizeMode.Centered;            
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+    
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["ComboBox"]);
+      AdjustMargins();
+      ReadOnly = ReadOnly; // To init the right cursor
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      base.DrawControl(renderer, rect, gameTime);      
+      
+      if (ReadOnly && (Focused || lstCombo.Focused) && drawSelection)
+      {
+        SkinLayer lr = Skin.Layers[0];
+        Rectangle rc = new Rectangle(rect.Left + lr.ContentMargins.Left, 
+                                     rect.Top + lr.ContentMargins.Top, 
+                                     Width - lr.ContentMargins.Horizontal - btnDown.Width,
+                                     Height - lr.ContentMargins.Vertical);
+        renderer.Draw(Manager.Skin.Images["ListBox.Selection"].Resource, rc , Color.FromNonPremultiplied(255, 255, 255, 128));
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnResize(ResizeEventArgs e)
+    {
+      base.OnResize(e);
+      
+      if (btnDown != null)
+      {
+        btnDown.Width = 16;
+        btnDown.Height = Height - Skin.Layers[0].ContentMargins.Vertical;
+        btnDown.Top = Skin.Layers[0].ContentMargins.Top;
+        btnDown.Left = Width - btnDown.Width - 2;                                
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    void btnDown_Click(object sender, EventArgs e)
+    {          
+      if (items != null && items.Count > 0)
+      {        
+        if (this.Root != null && this.Root is Container)
+        {          
+          (this.Root as Container).Add(lstCombo, false);
+          lstCombo.Alpha = Root.Alpha;
+          lstCombo.Left = AbsoluteLeft - Root.Left;
+          lstCombo.Top = AbsoluteTop - Root.Top + Height + 1;
+        }  
+        else
+        {
+          Manager.Add(lstCombo);          
+          lstCombo.Alpha = Alpha;
+          lstCombo.Left = AbsoluteLeft;
+          lstCombo.Top = AbsoluteTop + Height + 1;
+        }
+
+        lstCombo.AutoHeight(maxItems);
+        if (lstCombo.AbsoluteTop + lstCombo.Height > Manager.TargetHeight)
+        {          
+          lstCombo.Top = lstCombo.Top - Height - lstCombo.Height - 2;          
+        }    
+        
+        lstCombo.Visible = !lstCombo.Visible;
+        lstCombo.Focused = true;
+        lstCombo.Width = Width;
+        lstCombo.AutoHeight(maxItems);           
+      }        
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    void Input_MouseDown(object sender, MouseEventArgs e)
+    {    
+      if (ReadOnly && 
+          (e.Position.X >= AbsoluteLeft &&
+           e.Position.X <= AbsoluteLeft + Width &&
+           e.Position.Y >= AbsoluteTop &&
+           e.Position.Y <= AbsoluteTop + Height)) return;
+           
+      if (lstCombo.Visible &&      
+         (e.Position.X < lstCombo.AbsoluteLeft ||
+          e.Position.X > lstCombo.AbsoluteLeft + lstCombo.Width ||
+          e.Position.Y < lstCombo.AbsoluteTop ||
+          e.Position.Y > lstCombo.AbsoluteTop + lstCombo.Height) &&         
+         (e.Position.X < btnDown.AbsoluteLeft ||
+          e.Position.X > btnDown.AbsoluteLeft + btnDown.Width ||
+          e.Position.Y < btnDown.AbsoluteTop ||
+          e.Position.Y > btnDown.AbsoluteTop + btnDown.Height))
+      {
+        //lstCombo.Visible = false;      
+        btnDown_Click(sender, e);
+      }      
+    }   
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    void lstCombo_Click(object sender, EventArgs e)
+    {
+      MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs)e : new MouseEventArgs();      
+      
+      if (ex.Button == MouseButton.Left || ex.Button == MouseButton.None)
+      {
+        lstCombo.Visible = false;        
+        if (lstCombo.ItemIndex >= 0)
+        {        
+          Text = lstCombo.Items[lstCombo.ItemIndex].ToString();
+          Focused = true;
+          ItemIndex = lstCombo.ItemIndex;
+        }  
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnKeyDown(KeyEventArgs e)
+    {      
+      if (e.Key == Keys.Down)
+      {
+        e.Handled = true;
+        btnDown_Click(this, new MouseEventArgs());        
+      }
+      base.OnKeyDown(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnGamePadDown(GamePadEventArgs e)
+    {
+      if (!e.Handled)
+      {        
+        if (e.Button == GamePadActions.Click || e.Button == GamePadActions.Press || e.Button == GamePadActions.Down)
+        {
+          e.Handled = true;
+          btnDown_Click(this, new MouseEventArgs());
+        }
+      }
+      base.OnGamePadDown(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnMouseDown(MouseEventArgs e)
+    {
+      base.OnMouseDown(e);
+      
+      if (ReadOnly && e.Button == MouseButton.Left)
+      {
+        btnDown_Click(this, new MouseEventArgs());
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnMaxItemsChanged(EventArgs e)
+    {
+      if (MaxItemsChanged != null) MaxItemsChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnItemIndexChanged(EventArgs e)
+    {
+      if (ItemIndexChanged != null) ItemIndexChanged.Invoke(this, e);      
+    }    
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    void lstCombo_FocusLost(object sender, EventArgs e)
+    {
+      //lstCombo.Visible = false;
+      Invalidate();
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void AdjustMargins()
+    {
+      base.AdjustMargins();
+      ClientMargins = new Margins(ClientMargins.Left, ClientMargins.Top, ClientMargins.Right + 16, ClientMargins.Bottom);      
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    #endregion
+
+  }
+
+}

Neoforce/Component.cs

@@ -0,0 +1,105 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Component.cs                                 //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public class Component: Disposable
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private Manager manager = null;
+    private bool initialized = false;      
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual Manager Manager { get { return manager; } set { manager = value; } }
+    public virtual bool Initialized { get { return initialized; } }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public Component(Manager manager)
+    {      
+      if (manager != null)
+      {
+       this.manager = manager;                 
+      }
+      else
+      {
+        throw new Exception("Component cannot be created. Manager instance is needed.");
+      }                 
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Destructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void Dispose(bool disposing)
+    {      
+      if (disposing)
+      {      
+      }
+      base.Dispose(disposing);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////         
+    public virtual void Init()
+    {
+      initialized = true;
+    }
+    ////////////////////////////////////////////////////////////////////////////          
+
+    ////////////////////////////////////////////////////////////////////////////   
+    protected internal virtual void Update(GameTime gameTime)
+    {       
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    #endregion
+
+  }
+
+}

Neoforce/Console.cs

@@ -0,0 +1,595 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Console.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework.GamerServices;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+    public struct ConsoleMessage
+    {
+        public string Text;
+        public byte Channel;
+        public DateTime Time;
+        public string Sender;
+
+        public ConsoleMessage(string sender, string text, byte channel)
+        {
+            this.Text = text;
+            this.Channel = channel;
+            this.Time = DateTime.Now;
+            this.Sender = sender;
+        }
+    }
+
+    public class ChannelList : EventedList<ConsoleChannel>
+    {
+
+        #region //// Indexers //////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public ConsoleChannel this[string name]
+        {
+            get
+            {
+                for (int i = 0; i < this.Count; i++)
+                {
+                    ConsoleChannel s = (ConsoleChannel)this[i];
+                    if (s.Name.ToLower() == name.ToLower())
+                    {
+                        return s;
+                    }
+                }
+                return default(ConsoleChannel);
+            }
+
+            set
+            {
+                for (int i = 0; i < this.Count; i++)
+                {
+                    ConsoleChannel s = (ConsoleChannel)this[i];
+                    if (s.Name.ToLower() == name.ToLower())
+                    {
+                        this[i] = value;
+                    }
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public ConsoleChannel this[byte index]
+        {
+            get
+            {
+                for (int i = 0; i < this.Count; i++)
+                {
+                    ConsoleChannel s = (ConsoleChannel)this[i];
+                    if (s.Index == index)
+                    {
+                        return s;
+                    }
+                }
+                return default(ConsoleChannel);
+            }
+
+            set
+            {
+                for (int i = 0; i < this.Count; i++)
+                {
+                    ConsoleChannel s = (ConsoleChannel)this[i];
+                    if (s.Index == index)
+                    {
+                        this[i] = value;
+                    }
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+    }
+
+    public class ConsoleChannel
+    {
+        private string name;
+        private byte index;
+        private Color color;
+
+        public ConsoleChannel(byte index, string name, Color color)
+        {
+            this.name = name;
+            this.index = index;
+            this.color = color;
+        }
+
+        public virtual byte Index
+        {
+            get { return index; }
+            set { index = value; }
+        }
+
+        public virtual Color Color
+        {
+            get { return color; }
+            set { color = value; }
+        }
+
+        public virtual string Name
+        {
+            get { return name; }
+            set { name = value; }
+        }
+    }
+
+    [Flags]
+    public enum ConsoleMessageFormats
+    {
+        None = 0x00,
+        ChannelName = 0x01,
+        TimeStamp = 0x02,
+        Sender = 0x03,
+        All = Sender | ChannelName | TimeStamp
+    }
+
+    public class Console : Container
+    {
+
+        #region //// Fields ////////////
+
+        ////////////////////////////////////////////////////////////////////////////                 
+        private TextBox txtMain = null;
+        private ComboBox cmbMain;
+        private EventedList<ConsoleMessage> buffer = new EventedList<ConsoleMessage>();
+        private ChannelList channels = new ChannelList();
+        private List<byte> filter = new List<byte>();
+        private ConsoleMessageFormats messageFormat = ConsoleMessageFormats.None;
+        private bool channelsVisible = true;
+        private bool textBoxVisible = true;
+        private string sender;
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Properties ////////
+
+        public string Sender
+        {
+            get { return sender; }
+            set { sender = value; }
+        }
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual EventedList<ConsoleMessage> MessageBuffer
+        {
+            get { return buffer; }
+            set
+            {
+                buffer.ItemAdded -= new EventHandler(buffer_ItemAdded);
+                buffer = value;
+                buffer.ItemAdded += new EventHandler(buffer_ItemAdded);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual ChannelList Channels
+        {
+            get { return channels; }
+            set
+            {
+                channels.ItemAdded -= new EventHandler(channels_ItemAdded);
+                channels = value;
+                channels.ItemAdded += new EventHandler(channels_ItemAdded);
+                channels_ItemAdded(null, null);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual List<byte> ChannelFilter
+        {
+            get { return filter; }
+            set { filter = value; }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual byte SelectedChannel
+        {
+            set { cmbMain.Text = channels[value].Name; }
+            get { return channels[cmbMain.Text].Index; }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual ConsoleMessageFormats MessageFormat
+        {
+            get { return messageFormat; }
+            set { messageFormat = value; }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////       
+        public virtual bool ChannelsVisible
+        {
+            get { return channelsVisible; }
+            set
+            {
+                cmbMain.Visible = channelsVisible = value;
+                if (value && !textBoxVisible) TextBoxVisible = false;
+                PositionControls();
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////       
+
+        ////////////////////////////////////////////////////////////////////////////       
+        public virtual bool TextBoxVisible
+        {
+            get { return textBoxVisible; }
+            set
+            {
+                txtMain.Visible = textBoxVisible = value;
+                txtMain.Focused = true;
+                if (!value && channelsVisible) ChannelsVisible = false;
+                PositionControls();
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////       
+
+        #endregion
+
+        #region //// Events ////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public event ConsoleMessageEventHandler MessageSent;
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Construstors //////
+
+        ////////////////////////////////////////////////////////////////////////////       
+        public Console(Manager manager)
+            : base(manager)
+        {
+            Width = 320;
+            Height = 160;
+            MinimumHeight = 64;
+            MinimumWidth = 64;
+            CanFocus = false;
+            Resizable = false;
+            Movable = false;
+
+            cmbMain = new ComboBox(manager);
+            cmbMain.Init();
+            cmbMain.Top = Height - cmbMain.Height;
+            cmbMain.Left = 0;
+            cmbMain.Width = 128;
+            cmbMain.Anchor = Anchors.Left | Anchors.Bottom;
+            cmbMain.Detached = false;
+            cmbMain.DrawSelection = false;
+            cmbMain.Visible = channelsVisible;
+            Add(cmbMain, false);
+
+            txtMain = new TextBox(manager);
+            txtMain.Init();
+            txtMain.Top = Height - txtMain.Height;
+            txtMain.Left = cmbMain.Width + 1;
+            txtMain.Anchor = Anchors.Left | Anchors.Bottom | Anchors.Right;
+            txtMain.Detached = false;
+            txtMain.Visible = textBoxVisible;
+            txtMain.KeyDown += new KeyEventHandler(txtMain_KeyDown);
+            txtMain.GamePadDown += new GamePadEventHandler(txtMain_GamePadDown);
+            txtMain.FocusGained += new EventHandler(txtMain_FocusGained);
+            Add(txtMain, false);
+
+            VerticalScrollBar.Top = 2;
+            VerticalScrollBar.Left = Width - 18;
+            VerticalScrollBar.Range = 1;
+            VerticalScrollBar.PageSize = 1;
+            VerticalScrollBar.ValueChanged += new EventHandler(VerticalScrollBar_ValueChanged);
+            VerticalScrollBar.Visible = true;
+
+            ClientArea.Draw += new DrawEventHandler(ClientArea_Draw);
+
+            buffer.ItemAdded += new EventHandler(buffer_ItemAdded);
+            channels.ItemAdded += new EventHandler(channels_ItemAdded);
+            channels.ItemRemoved += new EventHandler(channels_ItemRemoved);
+
+            PositionControls();
+        }
+        ////////////////////////////////////////////////////////////////////////////       
+
+        #endregion
+
+        #region //// Methods ///////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        private void PositionControls()
+        {
+            if (txtMain != null)
+            {
+                txtMain.Left = channelsVisible ? cmbMain.Width + 1 : 0;
+                txtMain.Width = channelsVisible ? Width - cmbMain.Width - 1 : Width;
+
+                if (textBoxVisible)
+                {
+                    ClientMargins = new Margins(Skin.ClientMargins.Left, Skin.ClientMargins.Top + 4, VerticalScrollBar.Width + 6, txtMain.Height + 4);
+                    VerticalScrollBar.Height = Height - txtMain.Height - 5;
+                }
+                else
+                {
+                    ClientMargins = new Margins(Skin.ClientMargins.Left, Skin.ClientMargins.Top + 4, VerticalScrollBar.Width + 6, 2);
+                    VerticalScrollBar.Height = Height - 4;
+                }
+                Invalidate();
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public override void Init()
+        {
+            base.Init();
+        }
+        ////////////////////////////////////////////////////////////////////////////                          
+
+        ////////////////////////////////////////////////////////////////////////////                          
+        protected internal override void InitSkin()
+        {
+            base.InitSkin();
+            Skin = new SkinControl(Manager.Skin.Controls["Console"]);
+
+            PositionControls();
+        }
+        ////////////////////////////////////////////////////////////////////////////                          
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected internal override void Update(GameTime gameTime)
+        {
+            base.Update(gameTime);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        void ClientArea_Draw(object sender, DrawEventArgs e)
+        {
+            SpriteFont font = Skin.Layers[0].Text.Font.Resource;
+            Rectangle r = new Rectangle(e.Rectangle.Left, e.Rectangle.Top, e.Rectangle.Width, e.Rectangle.Height);
+            int pos = 0;
+
+            if (buffer.Count > 0)
+            {
+                EventedList<ConsoleMessage> b = GetFilteredBuffer(filter);
+                int c = b.Count;
+                int s = (VerticalScrollBar.Value + VerticalScrollBar.PageSize);
+                int f = s - VerticalScrollBar.PageSize;
+
+                if (b.Count > 0)
+                {
+                    for (int i = s - 1; i >= f; i--)
+                    {
+                        {
+                            int x = 4;
+                            int y = r.Bottom - (pos + 1) * ((int)font.LineSpacing + 0);
+
+                            string msg = ((ConsoleMessage)b[i]).Text;
+                            string pre = "";
+                            ConsoleChannel ch = (channels[((ConsoleMessage)b[i]).Channel] as ConsoleChannel);
+
+                            if ((messageFormat & ConsoleMessageFormats.ChannelName) == ConsoleMessageFormats.ChannelName)
+                            {
+                                pre += string.Format("[{0}]", channels[((ConsoleMessage)b[i]).Channel].Name);
+                            }
+                            if ((messageFormat & ConsoleMessageFormats.Sender) == ConsoleMessageFormats.Sender)
+                            {
+                                pre += string.Format("[{0}]", ((ConsoleMessage)b[i]).Sender);
+                            }
+                            if ((messageFormat & ConsoleMessageFormats.TimeStamp) == ConsoleMessageFormats.TimeStamp)
+                            {
+                                pre = string.Format("[{0}]", ((ConsoleMessage)b[i]).Time.ToLongTimeString()) + pre;
+                            }
+
+                            if (pre != "") msg = pre + ": " + msg;
+
+                            e.Renderer.DrawString(font,
+                                                msg,
+                                                x, y,
+                                                ch.Color);
+                            pos += 1;
+                        }
+                    }
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+        {
+            int h = txtMain.Visible ? (txtMain.Height + 1) : 0;
+            Rectangle r = new Rectangle(rect.Left, rect.Top, rect.Width, rect.Height - h);
+            base.DrawControl(renderer, r, gameTime);
+        }
+        ////////////////////////////////////////////////////////////////////////////              
+
+        ////////////////////////////////////////////////////////////////////////////     
+        void txtMain_FocusGained(object sender, EventArgs e)
+        {
+            ConsoleChannel ch = channels[cmbMain.Text];
+            if (ch != null) txtMain.TextColor = ch.Color;
+        }
+        ////////////////////////////////////////////////////////////////////////////     
+
+        ////////////////////////////////////////////////////////////////////////////     
+        void txtMain_KeyDown(object sender, KeyEventArgs e)
+        {
+            SendMessage(e);
+        }
+        ////////////////////////////////////////////////////////////////////////////    
+
+        ////////////////////////////////////////////////////////////////////////////        
+        void txtMain_GamePadDown(object sender, GamePadEventArgs e)
+        {
+            SendMessage(e);
+        }
+        ////////////////////////////////////////////////////////////////////////////        
+
+        ////////////////////////////////////////////////////////////////////////////        
+        private void SendMessage(EventArgs x)
+        {
+            if (Manager.UseGuide && Guide.IsVisible) return;
+
+            KeyEventArgs k = new KeyEventArgs();
+            GamePadEventArgs g = new GamePadEventArgs(PlayerIndex.One);
+
+            if (x is KeyEventArgs) k = x as KeyEventArgs;
+            else if (x is GamePadEventArgs) g = x as GamePadEventArgs;
+
+            ConsoleChannel ch = channels[cmbMain.Text];
+            if (ch != null)
+            {
+                txtMain.TextColor = ch.Color;
+
+                string message = txtMain.Text;
+                if ((k.Key == Microsoft.Xna.Framework.Input.Keys.Enter || g.Button == GamePadActions.Press) && message != null && message != "")
+                {
+                    x.Handled = true;
+
+                    ConsoleMessageEventArgs me = new ConsoleMessageEventArgs(new ConsoleMessage(sender, message, ch.Index));
+                    OnMessageSent(me);
+
+                    buffer.Add(new ConsoleMessage(sender, me.Message.Text, me.Message.Channel));
+
+                    txtMain.Text = "";
+                    ClientArea.Invalidate();
+
+                    CalcScrolling();
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////    
+
+        ////////////////////////////////////////////////////////////////////////////        
+        protected virtual void OnMessageSent(ConsoleMessageEventArgs e)
+        {
+            if (MessageSent != null) MessageSent.Invoke(this, e);
+        }
+        ////////////////////////////////////////////////////////////////////////////    
+
+        ////////////////////////////////////////////////////////////////////////////
+        void channels_ItemAdded(object sender, EventArgs e)
+        {
+            cmbMain.Items.Clear();
+            for (int i = 0; i < channels.Count; i++)
+            {
+                cmbMain.Items.Add((channels[i] as ConsoleChannel).Name);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        void channels_ItemRemoved(object sender, EventArgs e)
+        {
+            cmbMain.Items.Clear();
+            for (int i = 0; i < channels.Count; i++)
+            {
+                cmbMain.Items.Add((channels[i] as ConsoleChannel).Name);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        void buffer_ItemAdded(object sender, EventArgs e)
+        {
+            CalcScrolling();
+            ClientArea.Invalidate();
+        }
+        //////////////////////////////////////////////////////////////////////////// 
+
+        ////////////////////////////////////////////////////////////////////////////     
+        private void CalcScrolling()
+        {
+            if (VerticalScrollBar != null)
+            {
+                int line = Skin.Layers[0].Text.Font.Resource.LineSpacing;
+                int c = GetFilteredBuffer(filter).Count;
+                int p = (int)Math.Ceiling(ClientArea.ClientHeight / (float)line);
+
+                VerticalScrollBar.Range = c == 0 ? 1 : c;
+                VerticalScrollBar.PageSize = c == 0 ? 1 : p;
+                VerticalScrollBar.Value = VerticalScrollBar.Range;
+            }
+        }
+        //////////////////////////////////////////////////////////////////////////// 
+
+        //////////////////////////////////////////////////////////////////////////// 
+        void VerticalScrollBar_ValueChanged(object sender, EventArgs e)
+        {
+            ClientArea.Invalidate();
+        }
+        //////////////////////////////////////////////////////////////////////////// 
+
+        //////////////////////////////////////////////////////////////////////////// 
+        protected override void OnResize(ResizeEventArgs e)
+        {
+            CalcScrolling();
+            base.OnResize(e);
+        }
+        //////////////////////////////////////////////////////////////////////////// 
+
+        //////////////////////////////////////////////////////////////////////////// 
+        private EventedList<ConsoleMessage> GetFilteredBuffer(List<byte> filter)
+        {
+            EventedList<ConsoleMessage> ret = new EventedList<ConsoleMessage>();
+
+            if (filter.Count > 0)
+            {
+                for (int i = 0; i < buffer.Count; i++)
+                {
+                    if (filter.Contains(((ConsoleMessage)buffer[i]).Channel))
+                    {
+                        ret.Add(buffer[i]);
+                    }
+                }
+                return ret;
+            }
+            else return buffer;
+        }
+        //////////////////////////////////////////////////////////////////////////// 
+
+        #endregion
+
+    }
+
+}

Neoforce/Container.cs

@@ -0,0 +1,554 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Container.cs                                 //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public struct ScrollBarValue
+  {
+    public int Vertical;
+    public int Horizontal;
+  }
+     
+  public class Container: ClipControl
+  {   
+   
+    #region //// Fields ////////////
+    
+    ////////////////////////////////////////////////////////////////////////////        
+    private ScrollBar sbVert;
+    private ScrollBar sbHorz;
+    private MainMenu mainMenu;
+    private ToolBarPanel toolBarPanel;   
+    private StatusBar statusBar;
+    private bool autoScroll = false;
+    private Control defaultControl = null;   
+
+    /// <summary>
+    /// Scroll by PageSize (true) or StepSize (false)
+    /// </summary>
+    private bool scrollAlot = true;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion   
+
+    #region //// Properties ////////
+   
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual ScrollBarValue ScrollBarValue
+    {
+      get
+      {
+        ScrollBarValue scb = new ScrollBarValue();
+        scb.Vertical = (sbVert != null ? sbVert.Value : 0);
+        scb.Horizontal = (sbHorz != null ? sbHorz.Value : 0);
+        return scb;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override bool Visible
+    {
+      get
+      {
+        return base.Visible;        
+      }
+      set
+      {   
+        if (value)
+        {
+          if (DefaultControl != null)
+          {
+            DefaultControl.Focused = true;  
+          }        
+        }
+        base.Visible = value;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual Control DefaultControl
+    {
+      get { return defaultControl; }
+      set { defaultControl = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual bool AutoScroll
+    {
+      get { return autoScroll; }
+      set { autoScroll = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual MainMenu MainMenu
+    {
+      get { return mainMenu; }
+      set
+      {
+        if (mainMenu != null)
+        {
+          mainMenu.Resize -= Bars_Resize;
+          Remove(mainMenu);
+        }
+        mainMenu = value;
+        
+        if (mainMenu != null)
+        {
+          Add(mainMenu, false);
+          mainMenu.Resize += Bars_Resize;          
+        }
+        AdjustMargins();
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual ToolBarPanel ToolBarPanel
+    {
+      get 
+      { 
+        return toolBarPanel; 
+      }
+      set
+      {
+        if (toolBarPanel != null)
+        {
+          toolBarPanel.Resize -= Bars_Resize;
+          Remove(toolBarPanel);
+        }
+        toolBarPanel = value;
+        
+        if (toolBarPanel != null)
+        {
+          Add(toolBarPanel, false);
+          toolBarPanel.Resize += Bars_Resize;          
+        }
+        AdjustMargins();
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual StatusBar StatusBar
+    {
+      get
+      {
+        return statusBar;
+      }
+      set
+      {
+        if (statusBar != null)
+        {
+          statusBar.Resize -= Bars_Resize;
+          Remove(statusBar);        
+        }  
+        statusBar = value;
+        
+        if (statusBar != null)
+        {
+          Add(statusBar, false);
+          statusBar.Resize += Bars_Resize;
+        }
+        AdjustMargins();
+      }
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+    
+    /// <summary>
+    /// Scroll by PageSize (true) or StepSize (false)
+    /// </summary>
+    public virtual bool ScrollAlot
+    {
+        get { return this.scrollAlot; }
+        set { this.scrollAlot = value; }
+    }
+ 
+    /// <summary>
+    /// Gets the container's vertical scroll bar.
+    /// </summary>
+    protected virtual ScrollBar VerticalScrollBar
+    {
+        get { return this.sbVert; }
+    }
+ 
+    /// <summary>
+    /// Gets the container's horizontal scroll bar.
+    /// </summary>
+    protected virtual ScrollBar HorizontalScrollBar
+    {
+        get { return this.sbHorz; }
+    }
+
+    #endregion
+    
+ 	  #region //// Constructors //////
+	 		
+	  ////////////////////////////////////////////////////////////////////////////
+		public Container(Manager manager): base(manager)
+    {                                           
+      sbVert = new ScrollBar(manager, Orientation.Vertical);
+      sbVert.Init();      
+      sbVert.Detached = false;
+      sbVert.Anchor = Anchors.Top | Anchors.Right | Anchors.Bottom;
+      sbVert.ValueChanged += new EventHandler(ScrollBarValueChanged);                 
+      sbVert.Range = 0;
+      sbVert.PageSize = 0;
+      sbVert.Value = 0;
+      sbVert.Visible = false;
+
+      sbHorz = new ScrollBar(manager, Orientation.Horizontal);
+      sbHorz.Init();
+      sbHorz.Detached = false;
+      sbHorz.Anchor = Anchors.Right | Anchors.Left | Anchors.Bottom;
+      sbHorz.ValueChanged += new EventHandler(ScrollBarValueChanged);
+      sbHorz.Range = 0;
+      sbHorz.PageSize = 0;
+      sbHorz.Value = 0;
+      sbHorz.Visible = false;
+            
+      Add(sbVert, false);
+      Add(sbHorz, false);
+    }
+    ////////////////////////////////////////////////////////////////////////////         
+       
+  	#endregion   
+
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void Bars_Resize(object sender, ResizeEventArgs e)
+    {
+      AdjustMargins();      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////  
+    protected override void AdjustMargins()
+    {
+      Margins m = Skin.ClientMargins;
+      
+      if (this.GetType() != typeof(Container))
+      {
+        m = ClientMargins;
+      } 
+            
+      if (mainMenu != null && mainMenu.Visible)
+      {
+        if (!mainMenu.Initialized) mainMenu.Init();
+        mainMenu.Left = m.Left;
+        mainMenu.Top = m.Top;
+        mainMenu.Width = Width - m.Horizontal;
+        mainMenu.Anchor = Anchors.Left | Anchors.Top | Anchors.Right;                
+     
+        m.Top += mainMenu.Height;        
+      }
+      if (toolBarPanel != null && toolBarPanel.Visible)
+      {
+        if (!toolBarPanel.Initialized) toolBarPanel.Init();
+        toolBarPanel.Left = m.Left;
+        toolBarPanel.Top = m.Top;
+        toolBarPanel.Width = Width - m.Horizontal;
+        toolBarPanel.Anchor = Anchors.Left | Anchors.Top | Anchors.Right;        
+        
+        m.Top += toolBarPanel.Height;
+      }
+      if (statusBar != null && statusBar.Visible)
+      {                
+        if (!statusBar.Initialized) statusBar.Init();        
+        statusBar.Left = m.Left;
+        statusBar.Top = Height - m.Bottom - statusBar.Height;
+        statusBar.Width = Width - m.Horizontal;
+        statusBar.Anchor = Anchors.Left | Anchors.Bottom | Anchors.Right;        
+
+        m.Bottom += statusBar.Height;
+      }
+      if (sbVert != null && sbVert.Visible)
+      {
+        m.Right += (sbVert.Width + 2);
+      }
+      if (sbHorz != null && sbHorz.Visible)
+      {
+        m.Bottom += (sbHorz.Height + 2);
+      }            
+      
+      ClientMargins = m;            
+      
+      PositionScrollBars();
+      
+      base.AdjustMargins();
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Add(Control control, bool client)
+    {
+      base.Add(control, client);
+      CalcScrolling();
+    }
+    ////////////////////////////////////////////////////////////////////////////           
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void Update(GameTime gameTime)
+    {      
+      base.Update(gameTime);                     
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {      
+      base.DrawControl(renderer, rect, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+
+    ////////////////////////////////////////////////////////////////////////////  
+    protected internal override void OnSkinChanged(EventArgs e)
+    {
+      base.OnSkinChanged(e);
+      if (sbVert != null && sbHorz != null)
+      {
+        sbVert.Visible = false;
+        sbHorz.Visible = false;
+        CalcScrolling();
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void PositionScrollBars()
+    {
+      if (sbVert != null)
+      {
+        sbVert.Left = ClientLeft + ClientWidth + 1;
+        sbVert.Top = ClientTop + 1;
+        int m = (sbHorz != null && sbHorz.Visible) ? 0 : 2;
+        sbVert.Height = ClientArea.Height - m;  
+        sbVert.Range = ClientArea.VirtualHeight;
+        sbVert.PageSize = ClientArea.ClientHeight;
+      }
+      
+      if (sbHorz != null)
+      {
+        sbHorz.Left = ClientLeft + 1;
+        sbHorz.Top = ClientTop + ClientHeight + 1;
+        int m = (sbVert != null && sbVert.Visible) ? 0 : 2;              
+        sbHorz.Width = ClientArea.Width - m;
+        sbHorz.Range = ClientArea.VirtualWidth;
+        sbHorz.PageSize = ClientArea.ClientWidth;
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    private void CalcScrolling()
+    {                      
+      if (sbVert != null && autoScroll)
+      {                
+        bool vis = sbVert.Visible;        
+        sbVert.Visible = ClientArea.VirtualHeight > ClientArea.ClientHeight;                
+        if (ClientArea.VirtualHeight <= ClientArea.ClientHeight) sbVert.Value = 0;
+        
+        if (vis != sbVert.Visible)
+        {
+          if (!sbVert.Visible)
+          {
+            foreach (Control c in ClientArea.Controls)
+            {
+              c.TopModifier = 0;
+              c.Invalidate();
+            }
+          }
+          AdjustMargins(); 
+        }
+        
+        PositionScrollBars();                                           
+        foreach (Control c in ClientArea.Controls)
+        {
+          c.TopModifier = -sbVert.Value;
+          c.Invalidate();
+        }    
+      }
+
+      if (sbHorz != null && autoScroll)
+      {
+        bool vis = sbHorz.Visible;
+        sbHorz.Visible = ClientArea.VirtualWidth > ClientArea.ClientWidth;     
+        if (ClientArea.VirtualWidth <= ClientArea.ClientWidth) sbHorz.Value = 0;
+        
+        if (vis != sbHorz.Visible)
+        {
+          if (!sbHorz.Visible)
+          {   
+            foreach (Control c in ClientArea.Controls)
+            {
+              c.LeftModifier = 0;
+              sbVert.Refresh();
+              c.Invalidate();
+            }
+          }
+          AdjustMargins();
+        }
+        
+        PositionScrollBars();
+        foreach (Control c in ClientArea.Controls)
+        {
+          c.LeftModifier = -sbHorz.Value;
+          sbHorz.Refresh();
+          c.Invalidate();
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual void ScrollTo(int x, int y)
+    {
+      sbVert.Value = y;
+      sbHorz.Value = x;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void ScrollTo(Control control)
+    {
+      if (control != null && ClientArea != null && ClientArea.Contains(control, true))
+      {
+        if (control.AbsoluteTop + control.Height > ClientArea.AbsoluteTop + ClientArea.Height)
+        {
+          sbVert.Value = sbVert.Value + control.AbsoluteTop - ClientArea.AbsoluteTop - sbVert.PageSize + control.Height;
+        }
+        else if (control.AbsoluteTop < ClientArea.AbsoluteTop)
+        {
+          sbVert.Value = sbVert.Value + control.AbsoluteTop - ClientArea.AbsoluteTop;
+        }
+        if (control.AbsoluteLeft + control.Width > ClientArea.AbsoluteLeft + ClientArea.Width)
+        {
+          sbHorz.Value = sbHorz.Value + control.AbsoluteLeft - ClientArea.AbsoluteLeft - sbHorz.PageSize + control.Width;
+        }
+        else if (control.AbsoluteLeft < ClientArea.AbsoluteLeft)
+        {
+          sbHorz.Value = sbHorz.Value + control.AbsoluteLeft - ClientArea.AbsoluteLeft;
+        }
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+    
+    ////////////////////////////////////////////////////////////////////////////                  
+    void ScrollBarValueChanged(object sender, EventArgs e)
+    {
+      CalcScrolling();     
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////           
+    protected override void OnResize(ResizeEventArgs e)
+    {             
+      base.OnResize(e);
+      CalcScrolling();
+      
+      // Crappy fix to certain scrolling issue
+      //if (sbVert != null) sbVert.Value -= 1; 
+      //if (sbHorz != null) sbHorz.Value -= 1;      
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+    
+    ////////////////////////////////////////////////////////////////////////////   
+    public override void Invalidate()
+    {        
+      base.Invalidate();
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////   
+    protected override void OnClick(EventArgs e)
+    {
+      MouseEventArgs ex = e as MouseEventArgs;      
+      ex.Position = new Point(ex.Position.X + sbHorz.Value, ex.Position.Y + sbVert.Value);
+      
+      base.OnClick(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////       
+   
+    protected override void OnMouseScroll(MouseEventArgs e)
+    {
+        if (!ClientArea.Enabled)
+            return;
+ 
+        // If current control doesn't scroll, scroll the parent control
+        if (sbVert.Range - sbVert.PageSize < 1)
+        {
+            Control c = this;
+ 
+            while (c != null)
+            {
+                var p = c.Parent as Container;
+ 
+                if (p != null && p.Enabled)
+                {
+                    p.OnMouseScroll(e);
+ 
+                    break;
+                }
+ 
+                c = c.Parent;
+            }
+ 
+            return;
+        }
+ 
+        if (e.ScrollDirection == MouseScrollDirection.Down)
+            sbVert.ScrollDown(ScrollAlot);
+        else
+            sbVert.ScrollUp(ScrollAlot);
+ 
+        base.OnMouseScroll(e);
+    }
+    #endregion
+ }
+
+}

Neoforce/ContentReaders.cs

@@ -0,0 +1,155 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ContentReaders.cs                            //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+//////////////////////////////////////////////////////////////////////////////
+using System;
+using System.IO;
+using System.Xml;
+using Microsoft.Xna.Framework.Content;
+
+#if (!XBOX && !XBOX_FAKE)
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework;
+#endif
+//////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+    ////////////////////////////////////////////////////////////////////////////
+    public class LayoutXmlDocument : XmlDocument { }
+    public class SkinXmlDocument : XmlDocument { }
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    public class SkinReader : ContentTypeReader<SkinXmlDocument>
+    {
+
+        #region //// Methods ///////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override SkinXmlDocument Read(ContentReader input, SkinXmlDocument existingInstance)
+        {
+            if (existingInstance == null)
+            {
+                SkinXmlDocument doc = new SkinXmlDocument();
+                doc.LoadXml(input.ReadString());
+                return doc;
+            }
+            else
+            {
+                existingInstance.LoadXml(input.ReadString());
+            }
+
+            return existingInstance;
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+    }
+
+    public class LayoutReader : ContentTypeReader<LayoutXmlDocument>
+    {
+
+        #region //// Methods ///////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override LayoutXmlDocument Read(ContentReader input, LayoutXmlDocument existingInstance)
+        {
+            if (existingInstance == null)
+            {
+                LayoutXmlDocument doc = new LayoutXmlDocument();
+                doc.LoadXml(input.ReadString());
+                return doc;
+            }
+            else
+            {
+                existingInstance.LoadXml(input.ReadString());
+            }
+
+            return existingInstance;
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+    }
+
+#if (!XBOX && !XBOX_FAKE)
+
+    public class CursorReader : ContentTypeReader<Cursor>
+    {
+
+        #region //// Methods ///////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override Cursor Read(ContentReader input, Cursor existingInstance)
+        {
+            if (existingInstance == null)
+            {
+                int count = input.ReadInt32();
+                byte[] data = input.ReadBytes(count);
+
+                string path = Path.GetTempFileName();
+                File.WriteAllBytes(path, data);
+                string tPath = Path.GetTempFileName();
+                using(System.Drawing.Icon i = System.Drawing.Icon.ExtractAssociatedIcon(path))
+                {
+                    using (System.Drawing.Bitmap b = i.ToBitmap())
+                    {
+
+                        b.Save(tPath, System.Drawing.Imaging.ImageFormat.Png);
+                        b.Dispose();
+                    }
+                    
+                    i.Dispose();
+                }
+                //TODO: Replace with xml based solution for getting hotspot and size instead
+                IntPtr handle = NativeMethods.LoadCursor(path);
+                System.Windows.Forms.Cursor c = new System.Windows.Forms.Cursor(handle);
+                Vector2 hs = new Vector2(c.HotSpot.X, c.HotSpot.Y);
+                int w = c.Size.Width;
+                int h = c.Size.Height;
+                c.Dispose();
+                File.Delete(path);
+
+                return new Cursor(tPath, hs, w, h);
+            }
+            else
+            {
+            }
+
+            return existingInstance;
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+    }
+
+#endif
+
+}
+

Neoforce/ContextMenu.cs

@@ -0,0 +1,575 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ContextMenu.cs                               //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+  
+  public class ContextMenu: MenuBase
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private long timer = 0;
+    private Control sender = null; 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    protected internal Control Sender { get { return sender; } set { sender = value; } }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ContextMenu(Manager manager): base(manager)
+    {      
+      Visible = false;
+      Detached = true;      
+      StayOnBack = true;
+      
+      Manager.Input.MouseDown += new MouseEventHandler(Input_MouseDown);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Destructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void Dispose(bool disposing)
+    {
+      if (disposing)
+      {
+        Manager.Input.MouseDown -= Input_MouseDown;
+      }
+      base.Dispose(disposing);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion   
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["ContextMenu"]);
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {                              
+      base.DrawControl(renderer, rect, gameTime);
+      
+      SkinLayer l1 = Skin.Layers["Control"];
+      SkinLayer l2 = Skin.Layers["Selection"];      
+      
+      int vsize = LineHeight();
+      Color col = Color.White;
+     
+      for (int i = 0; i < Items.Count; i++)
+      {
+        int mod = i > 0 ? 2 : 0;
+        int left = rect.Left + l1.ContentMargins.Left + vsize;
+        int h = vsize - mod - (i < (Items.Count - 1) ? 1 : 0);
+        int top = rect.Top + l1.ContentMargins.Top + (i * vsize) + mod;                
+        
+
+        if (Items[i].Separated && i > 0)
+        {
+          Rectangle r = new Rectangle(left, rect.Top + l1.ContentMargins.Top + (i * vsize), LineWidth() - vsize + 4, 1);
+          renderer.Draw(Manager.Skin.Controls["Control"].Layers[0].Image.Resource, r, l1.Text.Colors.Enabled);
+        }
+        if (ItemIndex != i)
+        {                    
+          if (Items[i].Enabled)
+          {
+            Rectangle r = new Rectangle(left, top, LineWidth() - vsize, h);        
+            renderer.DrawString(this, l1, Items[i].Text, r, false);        
+            col = l1.Text.Colors.Enabled;
+          }
+          else
+          {
+            Rectangle r = new Rectangle(left + l1.Text.OffsetX,
+                                        top + l1.Text.OffsetY, 
+                                        LineWidth() - vsize, h);
+            renderer.DrawString(l1.Text.Font.Resource, Items[i].Text, r, l1.Text.Colors.Disabled, l1.Text.Alignment);
+            col = l1.Text.Colors.Disabled;
+          }  
+        }
+        else
+        {    
+          if (Items[i].Enabled)
+          {                  
+            Rectangle rs = new Rectangle(rect.Left + l1.ContentMargins.Left, 
+                                         top, 
+                                         Width - (l1.ContentMargins.Horizontal - Skin.OriginMargins.Horizontal), 
+                                         h);
+            renderer.DrawLayer(this, l2, rs);
+
+            Rectangle r = new Rectangle(left,
+                                        top, LineWidth() - vsize, h);
+
+            renderer.DrawString(this, l2, Items[i].Text, r, false);
+            col = l2.Text.Colors.Enabled;
+          }  
+          else
+          {
+            Rectangle rs = new Rectangle(rect.Left + l1.ContentMargins.Left,
+                                         top,
+                                         Width - (l1.ContentMargins.Horizontal - Skin.OriginMargins.Horizontal),
+                                         vsize);
+            renderer.DrawLayer(l2, rs, l2.States.Disabled.Color, l2.States.Disabled.Index);
+            
+            Rectangle r = new Rectangle(left + l1.Text.OffsetX,
+                                        top + l1.Text.OffsetY,
+                                        LineWidth() - vsize, h);
+            renderer.DrawString(l2.Text.Font.Resource, Items[i].Text, r, l2.Text.Colors.Disabled, l2.Text.Alignment);
+            col = l2.Text.Colors.Disabled;
+          }
+                    
+        }
+        
+        if (Items[i].Image != null)
+        {                     
+          Rectangle r = new Rectangle(rect.Left + l1.ContentMargins.Left + 3, 
+                                      rect.Top + top + 3, 
+                                      LineHeight() - 6, 
+                                      LineHeight() - 6);
+          renderer.Draw(Items[i].Image, r, Color.White);
+        }     
+        
+        if (Items[i].Items != null && Items[i].Items.Count > 0)
+        {          
+          renderer.Draw(Manager.Skin.Images["Shared.ArrowRight"].Resource, rect.Left + LineWidth() - 4, rect.Top + l1.ContentMargins.Top + (i * vsize) + 8, col);
+        }     
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////
+    private int LineHeight()
+    {
+      int h = 0;
+      if (Items.Count > 0)
+      {
+        SkinLayer l = Skin.Layers["Control"];
+        h = (int)l.Text.Font.Resource.LineSpacing + 9; 
+      }
+      return h;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private int LineWidth()
+    {
+      int w = 0;
+      SkinFont font = Skin.Layers["Control"].Text.Font;
+      if (Items.Count > 0)
+      {
+        for (int i = 0; i < Items.Count; i++)
+        {
+          int wx = (int)font.Resource.MeasureString(Items[i].Text).X + 16;
+          if (wx > w) w = wx;
+        }        
+      }      
+      
+      w += 4 + LineHeight();
+      
+      return w;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void AutoSize()
+    {      
+      SkinText font = Skin.Layers["Control"].Text;
+      if (Items != null && Items.Count > 0)
+      {        
+        Height = (LineHeight() * Items.Count) + (Skin.Layers["Control"].ContentMargins.Vertical - Skin.OriginMargins.Vertical);        
+        Width = LineWidth() + (Skin.Layers["Control"].ContentMargins.Horizontal - Skin.OriginMargins.Horizontal) + font.OffsetX; 
+      }
+      else
+      {
+        Height = 16;
+        Width = 16;
+      }    
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void TrackItem(int x, int y)
+    {            
+      if (Items != null && Items.Count > 0)
+      {
+        SkinText font = Skin.Layers["Control"].Text;
+        int h = LineHeight();
+        y -= Skin.Layers["Control"].ContentMargins.Top;
+        int i = (int)((float)y / h);
+        if (i < Items.Count)
+        {
+          if (i != ItemIndex && Items[i].Enabled)
+          {
+            if (ChildMenu != null)
+            {
+              this.HideMenu(false);
+            }
+
+            if (i >= 0 && i != ItemIndex)
+            {
+              Items[i].SelectedInvoke(new EventArgs());              
+            } 
+            
+            Focused = true;
+            ItemIndex = i;  
+            timer = (long)TimeSpan.FromTicks(DateTime.Now.Ticks).TotalMilliseconds;            
+          }
+          else if (!Items[i].Enabled && ChildMenu == null)
+          {
+            ItemIndex = -1;
+          }                              
+        }  
+        Invalidate();      
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+      base.OnMouseMove(e);
+      TrackItem(e.Position.X, e.Position.Y);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void Update(GameTime gameTime)
+    {      
+      base.Update(gameTime);
+      
+      AutoSize();
+            
+      long time = (long)TimeSpan.FromTicks(DateTime.Now.Ticks).TotalMilliseconds;            
+     
+      if (timer != 0 && time - timer >= Manager.MenuDelay && ItemIndex >= 0 && Items[ItemIndex].Items.Count > 0 && ChildMenu == null)
+      {
+        OnClick(new MouseEventArgs(new MouseState(), MouseButton.Left, Point.Zero));                  
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnMouseOut(MouseEventArgs e)
+    {
+      base.OnMouseOut(e);
+            
+      if (!CheckArea(e.State.X, e.State.Y) && ChildMenu == null)
+      {
+        ItemIndex = -1;
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnClick(EventArgs e)
+    {
+      if (sender != null && !(sender is MenuBase)) sender.Focused = true;   
+      base.OnClick(e);
+      timer = 0;
+
+      MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs)e : new MouseEventArgs();
+
+      if (ex.Button == MouseButton.Left || ex.Button == MouseButton.None)
+      {      
+        if (ItemIndex >= 0 && Items[ItemIndex].Enabled)
+        {
+          if (ItemIndex >= 0 && Items[ItemIndex].Items != null && Items[ItemIndex].Items.Count > 0)
+          {
+            if (ChildMenu == null)
+            {
+              ChildMenu = new ContextMenu(Manager);         
+              (ChildMenu as ContextMenu).RootMenu = this.RootMenu;
+              (ChildMenu as ContextMenu).ParentMenu = this;
+              (ChildMenu as ContextMenu).sender = sender;
+              ChildMenu.Items.AddRange(Items[ItemIndex].Items);
+              (ChildMenu as ContextMenu).AutoSize();                    
+            }  
+            int y = AbsoluteTop + Skin.Layers["Control"].ContentMargins.Top + (ItemIndex * LineHeight());
+            (ChildMenu as ContextMenu).Show(sender, AbsoluteLeft + Width - 1, y);
+            if (ex.Button == MouseButton.None) (ChildMenu as ContextMenu).ItemIndex = 0;
+          }
+          else
+          {                                
+            if (ItemIndex >= 0)
+            {
+              Items[ItemIndex].ClickInvoke(ex);
+            }          
+            if (RootMenu is ContextMenu) (RootMenu as ContextMenu).HideMenu(true);
+            else if (RootMenu is MainMenu)
+            {           
+              (RootMenu as MainMenu).HideMenu();            
+            }            
+          }      
+        }  
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnKeyPress(KeyEventArgs e)
+    {
+      base.OnKeyPress(e);
+      
+      timer = 0;
+      
+      if (e.Key == Keys.Down || (e.Key == Keys.Tab && !e.Shift))
+      {
+        e.Handled = true;
+        ItemIndex += 1;
+      }  
+      
+      if (e.Key == Keys.Up || (e.Key == Keys.Tab && e.Shift))
+      {
+        e.Handled = true;
+        ItemIndex -=1;        
+      }  
+      
+      if (ItemIndex > Items.Count - 1) ItemIndex = 0;            
+      if (ItemIndex < 0) ItemIndex = Items.Count - 1;
+      
+      if (e.Key == Keys.Right && Items[ItemIndex].Items.Count > 0)
+      {
+        e.Handled = true;
+        OnClick(new MouseEventArgs(new MouseState(), MouseButton.None, Point.Zero));
+      }  
+      if (e.Key == Keys.Left)
+      {
+        e.Handled = true;
+        if (ParentMenu != null && ParentMenu is ContextMenu)
+        {
+          (ParentMenu as ContextMenu).Focused = true;
+          (ParentMenu as ContextMenu).HideMenu(false);        
+        }        
+      }       
+      if (e.Key == Keys.Escape)
+      {
+        e.Handled = true;
+        if (ParentMenu != null) ParentMenu.Focused = true;        
+        HideMenu(true);
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnGamePadPress(GamePadEventArgs e)
+    {      
+      timer = 0;      
+
+      if (e.Button == GamePadButton.None) return;
+      
+      if (e.Button == GamePadActions.Down || e.Button == GamePadActions.NextControl)
+      {
+        e.Handled = true;
+        ItemIndex += 1;
+      }  
+      else if (e.Button == GamePadActions.Up || e.Button == GamePadActions.PrevControl)
+      {
+        e.Handled = true;
+        ItemIndex -= 1;
+      }  
+
+      if (ItemIndex > Items.Count - 1) ItemIndex = 0;
+      if (ItemIndex < 0) ItemIndex = Items.Count - 1;
+
+      if (e.Button == GamePadActions.Right && Items[ItemIndex].Items.Count > 0)
+      {
+        e.Handled = true;
+        OnClick(new MouseEventArgs(new MouseState(), MouseButton.None, Point.Zero));
+      }  
+      if (e.Button == GamePadActions.Left)
+      {
+        e.Handled = true;
+        if (ParentMenu != null && ParentMenu is ContextMenu)
+        {
+          (ParentMenu as ContextMenu).Focused = true;
+          (ParentMenu as ContextMenu).HideMenu(false);
+        }
+      }
+      
+      base.OnGamePadPress(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void HideMenu(bool hideCurrent)
+    {                
+      if (hideCurrent)
+      {
+        Visible = false;
+        ItemIndex = -1;                
+      }  
+      if (ChildMenu != null)
+      {
+        (ChildMenu as ContextMenu).HideMenu(true);
+        ChildMenu.Dispose();
+        ChildMenu = null;
+      }                 
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Show()
+    {     
+      Show(null, Left, Top);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void Show(Control sender, int x, int y)
+    {
+      AutoSize();
+      base.Show();  
+      if (!Initialized) Init();          
+      if (sender != null && sender.Root != null && sender.Root is Container)
+      {
+        (sender.Root as Container).Add(this, false);
+      }  
+      else
+      {
+        Manager.Add(this);
+      }
+        
+      this.sender = sender;
+
+      if (sender != null && sender.Root != null && sender.Root is Container)
+      {
+        Left = x - Root.AbsoluteLeft;
+        Top = y - Root.AbsoluteTop;                      
+      }
+      else
+      {
+        Left = x;
+        Top = y;      
+      }
+      
+      if (AbsoluteLeft + Width > Manager.TargetWidth)
+      {
+        Left = Left - Width;
+        if (ParentMenu != null && ParentMenu is ContextMenu)
+        {
+          Left = Left - ParentMenu.Width + 2;
+        }
+        else if (ParentMenu != null)
+        {
+          Left = Manager.TargetWidth - (Parent != null ? Parent.AbsoluteLeft : 0) - Width - 2;
+        }
+      }
+      if (AbsoluteTop + Height > Manager.TargetHeight)
+      {
+        Top = Top - Height;
+        if (ParentMenu != null && ParentMenu is ContextMenu)
+        {
+          Top = Top + LineHeight();
+        }
+        else if (ParentMenu != null)
+        {
+          Top = ParentMenu.Top - Height - 1;
+        }  
+      }           
+      
+      Focused = true;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    private void  Input_MouseDown(object sender, MouseEventArgs e)
+    {   
+      if ((RootMenu is ContextMenu) && !(RootMenu as ContextMenu).CheckArea(e.Position.X, e.Position.Y) && Visible)
+      {
+        HideMenu(true);
+      }
+      else if ((RootMenu is MainMenu) && RootMenu.ChildMenu != null && !(RootMenu.ChildMenu as ContextMenu).CheckArea(e.Position.X, e.Position.Y) && Visible)
+      {
+        (RootMenu as MainMenu).HideMenu();
+      }
+    }        
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private bool CheckArea(int x, int y)
+    {
+      if (Visible)
+      {
+        if (x <= AbsoluteLeft ||
+            x >= AbsoluteLeft + Width ||
+            y <= AbsoluteTop ||
+            y >= AbsoluteTop + Height)
+        {        
+          bool ret = false;          
+          if (ChildMenu != null)
+          {
+            ret = (ChildMenu as ContextMenu).CheckArea(x, y);
+          }  
+          return ret;
+        }  
+        else
+        {
+          return true;
+        }        
+      }
+      else
+      {
+        return false;
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion  
+
+  }
+
+}

Neoforce/Cursor.cs

@@ -0,0 +1,56 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TomShane.Neoforce.Controls
+{
+    /// <summary>
+    /// Provides a basic Software cursor
+    /// </summary>
+    public class Cursor
+    {
+        private Texture2D cursorTexture;
+
+        public Texture2D CursorTexture
+        {
+            get { return cursorTexture;}
+            set { cursorTexture = value; }
+        }
+
+        internal string cursorPath;
+
+        private Vector2 hotspot;
+        private int width;
+        private int height;
+
+        public int Height
+        {
+            get { return height; }
+            set { height = value; }
+        }
+
+        public int Width
+        {
+            get { return width; }
+            set { width = value; }
+        }
+
+        public Vector2 HotSpot
+        {
+            get { return hotspot; }
+            set { hotspot = value; }
+        }
+
+        public Cursor(string path, Vector2 hotspot, int width, int height)
+        {
+            this.cursorPath = path;
+            this.hotspot = hotspot;
+            this.width = width;
+            this.height = height;
+        }
+    }
+}

Neoforce/Delegates.cs

@@ -0,0 +1,53 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Delegates.cs                                 //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Delegates /////////
+  
+  ////////////////////////////////////////////////////////////////////////////  
+  public delegate void DeviceEventHandler(DeviceEventArgs e);
+  public delegate void SkinEventHandler(EventArgs e);  
+  ////////////////////////////////////////////////////////////////////////////  
+  
+  ////////////////////////////////////////////////////////////////////////////  
+  public delegate void EventHandler(object sender, EventArgs e);
+  public delegate void MouseEventHandler(object sender, MouseEventArgs e);
+  public delegate void KeyEventHandler(object sender, KeyEventArgs e);
+  public delegate void GamePadEventHandler(object sender, GamePadEventArgs e);
+  public delegate void DrawEventHandler(object sender, DrawEventArgs e);
+  public delegate void MoveEventHandler(object sender, MoveEventArgs e);
+  public delegate void ResizeEventHandler(object sender, ResizeEventArgs e);
+  public delegate void WindowClosingEventHandler(object sender, WindowClosingEventArgs e);
+  public delegate void WindowClosedEventHandler(object sender, WindowClosedEventArgs e);
+  public delegate void ConsoleMessageEventHandler(object sender, ConsoleMessageEventArgs e);
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion
+  
+}

Neoforce/Dialog.cs

@@ -0,0 +1,148 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Central                                          //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Dialog.cs                                    //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+  public class Dialog: Window
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private Panel pnlTop = null;
+    private Label lblCapt = null;
+    private Label lblDesc = null;    
+    private Panel pnlBottom = null;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public Panel TopPanel { get { return pnlTop; } }    
+    public Panel BottomPanel { get { return pnlBottom; } }
+    public Label Caption { get { return lblCapt; } }
+    public Label Description { get { return lblDesc; } }
+    ////////////////////////////////////////////////////////////////////////////       
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                         
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public Dialog(Manager manager): base(manager)
+    {                                      
+      pnlTop = new Panel(manager);
+      pnlTop.Anchor = Anchors.Left | Anchors.Top | Anchors.Right;     
+      pnlTop.Init();      
+      pnlTop.Parent = this;      
+      pnlTop.Width = ClientWidth;
+      pnlTop.Height = 64;      
+      pnlTop.BevelBorder = BevelBorder.Bottom;      
+   
+      lblCapt = new Label(manager);    
+      lblCapt.Init();
+      lblCapt.Parent = pnlTop;     
+      lblCapt.Width = lblCapt.Parent.ClientWidth - 16;      
+      lblCapt.Text = "Caption";
+      lblCapt.Left = 8;
+      lblCapt.Top = 8;            
+      lblCapt.Alignment = Alignment.TopLeft;      
+      lblCapt.Anchor = Anchors.Left | Anchors.Top | Anchors.Right;                  
+
+      lblDesc = new Label(manager);
+      lblDesc.Init();      
+      lblDesc.Parent = pnlTop;
+      lblDesc.Width = lblDesc.Parent.ClientWidth - 16;      
+      lblDesc.Left = 8;            
+      lblDesc.Text = "Description text.";      
+      lblDesc.Alignment = Alignment.TopLeft;      
+      lblDesc.Anchor = Anchors.Left | Anchors.Top | Anchors.Right;                
+
+      pnlBottom = new Panel(manager);
+      pnlBottom.Init();
+      pnlBottom.Parent = this;     
+      pnlBottom.Width = ClientWidth;
+      pnlBottom.Height = 24 + 16;
+      pnlBottom.Top = ClientHeight - pnlBottom.Height;
+      pnlBottom.BevelBorder = BevelBorder.Top;
+      pnlBottom.Anchor = Anchors.Left | Anchors.Bottom | Anchors.Right;
+
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+      
+      SkinLayer lc = new SkinLayer(lblCapt.Skin.Layers[0]);
+      lc.Text.Font.Resource = Manager.Skin.Fonts[Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["CaptFont"].Value].Resource;
+      lc.Text.Colors.Enabled = Utilities.ParseColor(Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["CaptFontColor"].Value);
+
+      SkinLayer ld = new SkinLayer(lblDesc.Skin.Layers[0]);
+      ld.Text.Font.Resource = Manager.Skin.Fonts[Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["DescFont"].Value].Resource;
+      ld.Text.Colors.Enabled = Utilities.ParseColor(Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["DescFontColor"].Value);
+      
+      pnlTop.Color = Utilities.ParseColor(Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["Color"].Value);
+      pnlTop.BevelMargin = int.Parse(Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["BevelMargin"].Value);
+      pnlTop.BevelStyle = Utilities.ParseBevelStyle(Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["BevelStyle"].Value);
+
+      lblCapt.Skin = new SkinControl(lblCapt.Skin);            
+      lblCapt.Skin.Layers[0] = lc;      
+      lblCapt.Height = Manager.Skin.Fonts[Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["CaptFont"].Value].Height;            
+      
+      lblDesc.Skin = new SkinControl(lblDesc.Skin);
+      lblDesc.Skin.Layers[0] = ld;
+      lblDesc.Height = Manager.Skin.Fonts[Manager.Skin.Controls["Dialog"].Layers["TopPanel"].Attributes["DescFont"].Value].Height;
+      lblDesc.Top = lblCapt.Top + lblCapt.Height + 4;  
+      lblDesc.Height = lblDesc.Parent.ClientHeight - lblDesc.Top - 8;      
+    
+      pnlBottom.Color = Utilities.ParseColor(Manager.Skin.Controls["Dialog"].Layers["BottomPanel"].Attributes["Color"].Value);
+      pnlBottom.BevelMargin = int.Parse(Manager.Skin.Controls["Dialog"].Layers["BottomPanel"].Attributes["BevelMargin"].Value);
+      pnlBottom.BevelStyle = Utilities.ParseBevelStyle(Manager.Skin.Controls["Dialog"].Layers["BottomPanel"].Attributes["BevelStyle"].Value);      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+  }
+
+}

Neoforce/Disposable.cs

@@ -0,0 +1,93 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Disposable.cs                                //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public abstract class Disposable: Unknown, IDisposable
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private static int count = 0;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public static int Count { get { return count; } }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected Disposable()
+    {
+      count += 1;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Destructors ///////
+
+    //////////////////////////////////////////////////////////////////////////
+    ~Disposable()
+    {      
+      Dispose(false);
+    }
+    //////////////////////////////////////////////////////////////////////////
+
+    //////////////////////////////////////////////////////////////////////////	  	  
+    public void Dispose()
+    {
+      Dispose(true);
+      GC.SuppressFinalize(this);
+    }
+    //////////////////////////////////////////////////////////////////////////	  	  	  
+
+    //////////////////////////////////////////////////////////////////////////	  	  	  
+    protected virtual void Dispose(bool disposing)
+    {
+      if (disposing)
+      {
+        count -= 1;                
+      }
+    }
+    //////////////////////////////////////////////////////////////////////////	  	  	  	  	 
+
+    #endregion
+
+  }
+  
+}

Neoforce/EventArgs.cs

@@ -0,0 +1,427 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: EventArgs.cs                                 //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Classes ///////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class EventArgs: System.EventArgs
+  {
+  
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public bool Handled = false; 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Consructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public EventArgs()
+    {              
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion    
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class KeyEventArgs: EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public Keys Key = Keys.None;
+    public bool Control = false;
+    public bool Shift = false;
+    public bool Alt = false;   
+    public bool Caps = false;  
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+		#region //// Constructors //////
+			
+		////////////////////////////////////////////////////////////////////////////
+		public KeyEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public KeyEventArgs(Keys key)
+    {
+      Key = key;
+      Control = false;
+      Shift = false;
+      Alt = false;
+      Caps = false;      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public KeyEventArgs(Keys key, bool control, bool shift, bool alt, bool caps)
+    {
+      Key = key;
+      Control = control;
+      Shift = shift;
+      Alt = alt;
+      Caps = caps;  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+			
+		#endregion  
+	}
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class MouseEventArgs: EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public MouseState State = new MouseState();
+    public MouseButton Button = MouseButton.None;
+    public Point Position = new Point(0, 0);
+    public Point Difference = new Point(0, 0);
+    /// <summary>
+    /// Mouse scroll direction
+    /// </summary>
+    public MouseScrollDirection ScrollDirection = MouseScrollDirection.None;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public MouseEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public MouseEventArgs(MouseState state, MouseButton button, Point position)
+    {
+      State = state;
+      Button = button;
+      Position = position;
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+
+    /// <summary>
+    /// Creates a new initialized instace of the MouseEventArgs class.
+    /// <param name="state">Mouse state at the time of the event.</param>
+    /// <param name="button">Mouse button state at the time of the event.</param>
+    /// <param name="position">Mosue cursor position at the time of the event.</param>
+    /// <param name="scrollDirection">Mouse scroll direction at the time of the event.</param>
+    public MouseEventArgs(MouseState state, MouseButton button, Point position, MouseScrollDirection scrollDirection)
+        : this(state, button, position)
+    {
+        ScrollDirection = scrollDirection;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    public MouseEventArgs(MouseEventArgs e)
+        : this(e.State, e.Button, e.Position)
+    {
+      Difference = e.Difference;
+      ScrollDirection = e.ScrollDirection;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    #endregion
+  }
+  ////////////////////////////////////////////////////////////////////////////   
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class GamePadEventArgs : EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public PlayerIndex PlayerIndex = PlayerIndex.One;
+    public GamePadState State = new GamePadState();
+    public GamePadButton Button = GamePadButton.None;   
+    public GamePadVectors Vectors;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+   /*
+    public GamePadEventArgs()
+    {                      
+    }*/
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////
+    public GamePadEventArgs(PlayerIndex playerIndex)
+    {
+      PlayerIndex = playerIndex;    
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public GamePadEventArgs(PlayerIndex playerIndex, GamePadButton button)
+    {
+      PlayerIndex = playerIndex;
+      Button = button;
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+
+    #endregion
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class DrawEventArgs: EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public Renderer Renderer = null;
+    public Rectangle Rectangle = Rectangle.Empty;
+    public GameTime GameTime = null; 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public DrawEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public DrawEventArgs(Renderer renderer, Rectangle rectangle, GameTime gameTime)
+    {
+      Renderer = renderer;
+      Rectangle = rectangle;
+      GameTime = gameTime;
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class ResizeEventArgs: EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public int Width = 0;
+    public int Height = 0;
+    public int OldWidth = 0;
+    public int OldHeight = 0; 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public ResizeEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public ResizeEventArgs(int width, int height, int oldWidth, int oldHeight)
+    {
+      Width = width;
+      Height = height;
+      OldWidth = oldWidth;
+      OldHeight = oldHeight;
+    }  
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion    
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class MoveEventArgs: EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public int Left = 0;
+    public int Top = 0;
+    public int OldLeft = 0;
+    public int OldTop = 0; 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public MoveEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public MoveEventArgs(int left, int top, int oldLeft, int oldTop)
+    {
+      Left = left;
+      Top = top;
+      OldLeft = oldLeft;
+      OldTop = oldTop;
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+  }
+  ////////////////////////////////////////////////////////////////////////////  
+  
+  ////////////////////////////////////////////////////////////////////////////
+  public class DeviceEventArgs: EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public PreparingDeviceSettingsEventArgs DeviceSettings = null;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public DeviceEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public DeviceEventArgs(PreparingDeviceSettingsEventArgs deviceSettings)
+    {
+      DeviceSettings = deviceSettings;
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class WindowClosingEventArgs: EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public bool Cancel = false;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Consructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public WindowClosingEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+  }
+  ////////////////////////////////////////////////////////////////////////////	
+  
+  ////////////////////////////////////////////////////////////////////////////
+  public class WindowClosedEventArgs: EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public bool Dispose = false;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Consructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public WindowClosedEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+  }
+  ////////////////////////////////////////////////////////////////////////////						
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class ConsoleMessageEventArgs : EventArgs
+  {
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public ConsoleMessage Message;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Consructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public ConsoleMessageEventArgs()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public ConsoleMessageEventArgs(ConsoleMessage message)
+    {
+      Message = message;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+  }
+  ////////////////////////////////////////////////////////////////////////////						
+
+
+  #endregion
+  
+}

Neoforce/EventedList.cs

@@ -0,0 +1,146 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: EventedList.cs                               //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections;
+using System.Collections.Generic;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+   
+  public class EventedList<T>: List<T>
+  {
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public event EventHandler ItemAdded;
+    public event EventHandler ItemRemoved; 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+         
+  	#region //// Constructors //////
+			
+		////////////////////////////////////////////////////////////////////////////
+		public EventedList(): base() {}
+		public EventedList(int capacity): base(capacity) {}
+		public EventedList(IEnumerable<T> collection): base(collection) {}
+    ////////////////////////////////////////////////////////////////////////////               
+
+    #endregion  
+        
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public new void Add(T item)
+    {
+      int c = this.Count;
+      base.Add(item);
+      if (ItemAdded != null && c != this.Count) ItemAdded.Invoke(this, new EventArgs());      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public new void Remove(T obj)
+    {
+      int c = this.Count;
+      base.Remove(obj);
+      if (ItemRemoved != null && c != this.Count) ItemRemoved.Invoke(this, new EventArgs());
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public new void Clear()
+    {
+      int c = this.Count;
+      base.Clear();
+      if (ItemRemoved != null && c != this.Count) ItemRemoved.Invoke(this, new EventArgs());            
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public new void AddRange(IEnumerable<T> collection)
+    {
+      int c = this.Count;
+      base.AddRange(collection);
+      if (ItemAdded != null && c != this.Count) ItemAdded.Invoke(this, new EventArgs());      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public new void Insert(int index, T item)
+    {
+      int c = this.Count;
+      base.Insert(index, item);
+      if (ItemAdded != null && c != this.Count) ItemAdded.Invoke(this, new EventArgs());            
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public new void InsertRange(int index, IEnumerable<T> collection)
+    {
+      int c = this.Count;
+      base.InsertRange(index, collection);
+      if (ItemAdded != null && c != this.Count) ItemAdded.Invoke(this, new EventArgs());
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public new int RemoveAll(Predicate<T> match)
+    {
+      int c = this.Count;
+      int ret = base.RemoveAll(match);
+      if (ItemRemoved != null && c != this.Count) ItemRemoved.Invoke(this, new EventArgs());                        
+      return ret;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public new void RemoveAt(int index)
+    {
+      int c = this.Count;
+      base.RemoveAt(index);
+      if (ItemRemoved != null && c != this.Count) ItemRemoved.Invoke(this, new EventArgs());            
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public new void RemoveRange(int index, int count)
+    {
+      int c = this.Count;
+      base.RemoveRange(index, count);      
+      if (ItemRemoved != null && c != this.Count) ItemRemoved.Invoke(this, new EventArgs());
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    #endregion
+
+  }
+
+}

Neoforce/ExitDialog.cs

@@ -0,0 +1,130 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Central                                          //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ExitDialog.cs                                //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+  public class ExitDialog: Dialog
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    public Button btnYes;
+    public Button btnNo;
+    private Label lblMessage;
+    private ImageBox imgIcon;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////     
+    ////////////////////////////////////////////////////////////////////////////       
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                         
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ExitDialog(Manager manager): base(manager)
+    {
+      string msg = "Do you really want to exit " + Manager.Game.Window.Title + "?";
+      ClientWidth = (int)Manager.Skin.Controls["Label"].Layers[0].Text.Font.Resource.MeasureString(msg).X + 48 + 16 + 16 + 16;                         
+      ClientHeight = 120;
+      TopPanel.Visible = false;
+      IconVisible = true;      
+      Resizable = false;
+      Text = Manager.Game.Window.Title;
+      Center();   
+            
+      imgIcon = new ImageBox(Manager);
+      imgIcon.Init();
+      imgIcon.Image = Manager.Skin.Images["Icon.Question"].Resource;
+      imgIcon.Left = 16;
+      imgIcon.Top = 16;
+      imgIcon.Width = 48;
+      imgIcon.Height = 48;
+      imgIcon.SizeMode = SizeMode.Stretched;
+      
+      lblMessage = new Label(Manager);      
+      lblMessage.Init();            
+      
+      lblMessage.Left = 80;
+      lblMessage.Top = 16;
+      lblMessage.Width = ClientWidth - lblMessage.Left;
+      lblMessage.Height = 48;
+      lblMessage.Alignment = Alignment.TopLeft;
+      lblMessage.Text = msg;
+      
+      btnYes = new Button(Manager);
+      btnYes.Init();      
+      btnYes.Left = (BottomPanel.ClientWidth / 2) - btnYes.Width - 4;
+      btnYes.Top = 8;
+      btnYes.Text = "Yes";      
+      btnYes.ModalResult = ModalResult.Yes;
+
+      btnNo = new Button(Manager);
+      btnNo.Init();
+      btnNo.Left = (BottomPanel.ClientWidth / 2) + 4;
+      btnNo.Top = 8;
+      btnNo.Text = "No";
+      btnNo.ModalResult = ModalResult.No;            
+
+      Add(imgIcon);                                      
+      Add(lblMessage);
+      BottomPanel.Add(btnYes);
+      BottomPanel.Add(btnNo);
+
+      DefaultControl = btnNo;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();                
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+  }
+
+}

Neoforce/External/Zip/Crc32.cs

@@ -0,0 +1,84 @@
+using System;
+
+namespace TomShane.Neoforce.External.Zip
+{
+   internal class CRC32
+   {      
+      private UInt32[] crc32Table;
+      private const int BUFFER_SIZE = 8192;
+     
+     private Int32 _TotalBytesRead= 0; 
+     public Int32 TotalBytesRead {
+       get {
+	 return _TotalBytesRead;
+       }
+     }
+
+      public UInt32 GetCrc32(System.IO.Stream input)
+      {
+	return GetCrc32AndCopy(input, null) ;
+      }
+
+      public UInt32 GetCrc32AndCopy(System.IO.Stream input, System.IO.Stream output)
+      {
+         unchecked
+         {
+            UInt32 crc32Result;
+            crc32Result = 0xFFFFFFFF;
+            byte[] buffer = new byte[BUFFER_SIZE];
+            int readSize = BUFFER_SIZE;
+
+	    _TotalBytesRead= 0;
+            int count = input.Read(buffer, 0, readSize);
+	    if (output != null) output.Write(buffer,0,count); 
+	    _TotalBytesRead += count;
+            while (count > 0)
+            {
+               for (int i = 0; i < count; i++)
+               {
+                  crc32Result = ((crc32Result) >> 8) ^ crc32Table[(buffer[i]) ^ ((crc32Result) & 0x000000FF)];
+               }
+               count = input.Read(buffer, 0, readSize);
+	       if (output != null) output.Write(buffer,0,count); 
+	       _TotalBytesRead += count;
+
+            }
+            
+            return ~crc32Result;
+         }
+      }
+
+
+      public CRC32()
+      {
+         unchecked
+         {
+            // This is the official polynomial used by CRC32 in PKZip.
+            // Often the polynomial is shown reversed as 0x04C11DB7.
+            UInt32 dwPolynomial = 0xEDB88320;
+            UInt32 i, j;
+
+            crc32Table = new UInt32[256];
+
+            UInt32 dwCrc;
+            for(i = 0; i < 256; i++)
+            {
+               dwCrc = i;
+               for(j = 8; j > 0; j--)
+               {
+                  if ((dwCrc & 1)==1)
+                  {
+                     dwCrc = (dwCrc >> 1) ^ dwPolynomial;
+                  }
+                  else
+                  {
+                     dwCrc >>= 1;
+                  }
+               }
+               crc32Table[i] = dwCrc;
+            }
+         }
+      }
+   }
+
+}

Neoforce/External/Zip/Shared.cs

@@ -0,0 +1,112 @@
+using System;
+
+namespace TomShane.Neoforce.External.Zip
+{
+
+	internal class Shared
+    {
+        protected internal static string StringFromBuffer(byte[] buf, int start, int maxlength)
+        {
+            int i;
+            char[] c = new char[maxlength];
+            for (i = 0; (i < maxlength) && (i < buf.Length) && (buf[i] != 0); i++)
+            {
+                c[i] = (char)buf[i]; // System.BitConverter.ToChar(buf, start+i*2);
+            }
+            string s = new System.String(c, 0, i);
+            return s;
+        }
+
+        protected internal static int ReadSignature(System.IO.Stream s)
+        {
+            int n = 0;
+            byte[] sig = new byte[4];
+            n = s.Read(sig, 0, sig.Length);
+            if (n != sig.Length) throw new Exception("Could not read signature - no data!");
+            int signature = (((sig[3] * 256 + sig[2]) * 256) + sig[1]) * 256 + sig[0];
+            return signature;
+        }
+
+        protected internal static long FindSignature(System.IO.Stream s, int SignatureToFind)
+        {
+            long startingPosition = s.Position;
+
+            int BATCH_SIZE = 1024;
+            byte[] targetBytes = new byte[4];
+            targetBytes[0] = (byte) (SignatureToFind >> 24);
+            targetBytes[1] = (byte) ((SignatureToFind & 0x00FF0000) >> 16);
+            targetBytes[2] = (byte) ((SignatureToFind & 0x0000FF00) >> 8);
+            targetBytes[3] = (byte) (SignatureToFind & 0x000000FF);
+            byte[] batch = new byte[BATCH_SIZE];
+            int n = 0;
+            bool success = false;
+            do
+            {
+                n = s.Read(batch, 0, batch.Length);
+                if (n != 0)
+                {
+                    for (int i = 0; i < n; i++)
+                    {
+                        if (batch[i] == targetBytes[3])
+                        {
+                            s.Seek(i - n, System.IO.SeekOrigin.Current);
+                            int sig = ReadSignature(s);
+                            success = (sig == SignatureToFind);
+                            if (!success) s.Seek(-3, System.IO.SeekOrigin.Current);
+                            break; // out of for loop
+                        }
+                    }
+                }
+                else break;
+                if (success) break;
+            } while (true);
+            if (!success)
+            {
+                s.Seek(startingPosition, System.IO.SeekOrigin.Begin);
+                return -1;  // or throw?
+            }
+
+            // subtract 4 for the signature.
+            long bytesRead = (s.Position - startingPosition) - 4 ;
+            // number of bytes read, should be the same as compressed size of file            
+            return bytesRead;   
+        }
+        protected internal static DateTime PackedToDateTime(Int32 packedDateTime)
+        {
+            Int16 packedTime = (Int16)(packedDateTime & 0x0000ffff);
+            Int16 packedDate = (Int16)((packedDateTime & 0xffff0000) >> 16);
+
+            int year = 1980 + ((packedDate & 0xFE00) >> 9);
+            int month = (packedDate & 0x01E0) >> 5;
+            int day = packedDate & 0x001F;
+
+
+            int hour = (packedTime & 0xF800) >> 11;
+            int minute = (packedTime & 0x07E0) >> 5;
+            int second = packedTime & 0x001F;
+
+            DateTime d = System.DateTime.Now;
+            try { d = new System.DateTime(year, month, day, hour, minute, second, 0); }
+            catch
+            {
+                Console.Write("\nInvalid date/time?:\nyear: {0} ", year);
+                Console.Write("month: {0} ", month);
+                Console.WriteLine("day: {0} ", day);
+                Console.WriteLine("HH:MM:SS= {0}:{1}:{2}", hour, minute, second);
+            }
+
+            return d;
+        }
+
+
+        protected internal static Int32 DateTimeToPacked(DateTime time)
+        {
+            UInt16 packedDate = (UInt16)((time.Day & 0x0000001F) | ((time.Month << 5) & 0x000001E0) | (((time.Year - 1980) << 9) & 0x0000FE00));
+            UInt16 packedTime = (UInt16)((time.Second & 0x0000001F) | ((time.Minute << 5) & 0x000007E0) | ((time.Hour << 11) & 0x0000F800));
+            return (Int32)(((UInt32)(packedDate << 16)) | packedTime);
+        }
+    }
+
+
+
+}

Neoforce/External/Zip/ZipDirEntry.cs

@@ -0,0 +1,149 @@
+using System;
+
+namespace TomShane.Neoforce.External.Zip
+{
+
+
+    internal class ZipDirEntry
+    {
+
+        internal const int ZipDirEntrySignature = 0x02014b50;
+
+        private bool _Debug = false;
+
+        private ZipDirEntry() { }
+
+        private DateTime _LastModified;
+        public DateTime LastModified
+        {
+            get { return _LastModified; }
+        }
+
+        private string _FileName;
+        public string FileName
+        {
+            get { return _FileName; }
+        }
+
+        private string _Comment;
+        public string Comment
+        {
+            get { return _Comment; }
+        }
+
+        private Int16 _VersionMadeBy;
+        public Int16 VersionMadeBy
+        {
+            get { return _VersionMadeBy; }
+        }
+
+        private Int16 _VersionNeeded;
+        public Int16 VersionNeeded
+        {
+            get { return _VersionNeeded; }
+        }
+
+        private Int16 _CompressionMethod;
+        public Int16 CompressionMethod
+        {
+            get { return _CompressionMethod; }
+        }
+
+        private Int32 _CompressedSize;
+        public Int32 CompressedSize
+        {
+            get { return _CompressedSize; }
+        }
+
+        private Int32 _UncompressedSize;
+        public Int32 UncompressedSize
+        {
+            get { return _UncompressedSize; }
+        }
+
+        public Double CompressionRatio
+        {
+            get
+            {
+                return 100 * (1.0 - (1.0 * CompressedSize) / (1.0 * UncompressedSize));
+            }
+        }
+
+        private Int16 _BitField;
+        private Int32 _LastModDateTime;
+
+        private Int32 _Crc32;
+        private byte[] _Extra;
+
+        internal ZipDirEntry(ZipEntry ze) { }
+
+
+        internal static ZipDirEntry Read(System.IO.Stream s)
+        {
+            return Read(s, false);
+        }
+
+
+        internal static ZipDirEntry Read(System.IO.Stream s, bool TurnOnDebug)
+        {
+
+            int signature = TomShane.Neoforce.External.Zip.Shared.ReadSignature(s);
+            // return null if this is not a local file header signature
+            if (SignatureIsNotValid(signature))
+            {
+                s.Seek(-4, System.IO.SeekOrigin.Current);
+                if (TurnOnDebug) System.Console.WriteLine("  ZipDirEntry::Read(): Bad signature ({0:X8}) at position {1}", signature, s.Position);
+                return null;
+            }
+
+            byte[] block = new byte[42];
+            int n = s.Read(block, 0, block.Length);
+            if (n != block.Length) return null;
+
+            int i = 0;
+            ZipDirEntry zde = new ZipDirEntry();
+
+            zde._Debug = TurnOnDebug;
+            zde._VersionMadeBy = (short)(block[i++] + block[i++] * 256);
+            zde._VersionNeeded = (short)(block[i++] + block[i++] * 256);
+            zde._BitField = (short)(block[i++] + block[i++] * 256);
+            zde._CompressionMethod = (short)(block[i++] + block[i++] * 256);
+            zde._LastModDateTime = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+            zde._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+            zde._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+            zde._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+
+            zde._LastModified = TomShane.Neoforce.External.Zip.Shared.PackedToDateTime(zde._LastModDateTime);
+
+            Int16 filenameLength = (short)(block[i++] + block[i++] * 256);
+            Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256);
+            Int16 commentLength = (short)(block[i++] + block[i++] * 256);
+            Int16 diskNumber = (short)(block[i++] + block[i++] * 256);
+            Int16 internalFileAttrs = (short)(block[i++] + block[i++] * 256);
+            Int32 externalFileAttrs = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+            Int32 Offset = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+
+            block = new byte[filenameLength];
+            n = s.Read(block, 0, block.Length);
+            zde._FileName = TomShane.Neoforce.External.Zip.Shared.StringFromBuffer(block, 0, block.Length);
+
+            zde._Extra = new byte[extraFieldLength];
+            n = s.Read(zde._Extra, 0, zde._Extra.Length);
+
+            block = new byte[commentLength];
+            n = s.Read(block, 0, block.Length);
+            zde._Comment = TomShane.Neoforce.External.Zip.Shared.StringFromBuffer(block, 0, block.Length);
+
+            return zde;
+        }
+
+        private static bool SignatureIsNotValid(int signature)
+        {
+            return (signature != ZipDirEntrySignature);
+        }
+
+    }
+
+
+
+}

Neoforce/External/Zip/ZipEntry.cs

@@ -0,0 +1,699 @@
+using System;
+
+namespace TomShane.Neoforce.External.Zip
+{
+	internal class ZipEntry
+    {
+
+        private const int ZipEntrySignature = 0x04034b50;
+        private const int ZipEntryDataDescriptorSignature= 0x08074b50;
+ 
+        private bool _Debug = false;
+
+        private DateTime _LastModified;
+        public DateTime LastModified
+        {
+            get { return _LastModified; }
+        }
+
+      // when this is set, we trim the volume (eg C:\) off any fully-qualified pathname, 
+      // before writing the ZipEntry into the ZipFile. 
+      private bool _TrimVolumeFromFullyQualifiedPaths= true;  // by default, trim them.
+        public bool TrimVolumeFromFullyQualifiedPaths
+        {
+            get { return _TrimVolumeFromFullyQualifiedPaths; }
+            set { _TrimVolumeFromFullyQualifiedPaths= value; }
+        }
+
+        private string _FileName;
+        public string FileName
+        {
+            get { return _FileName; }
+        }
+
+        private Int16 _VersionNeeded;
+        public Int16 VersionNeeded
+        {
+            get { return _VersionNeeded; }
+        }
+
+        private Int16 _BitField;
+        public Int16 BitField
+        {
+            get { return _BitField; }
+        }
+
+        private Int16 _CompressionMethod;
+        public Int16 CompressionMethod
+        {
+            get { return _CompressionMethod; }
+        }
+
+        private Int32 _CompressedSize;
+        public Int32 CompressedSize
+        {
+            get { return _CompressedSize; }
+        }
+
+        private Int32 _UncompressedSize;
+        public Int32 UncompressedSize
+        {
+            get { return _UncompressedSize; }
+        }
+
+        public Double CompressionRatio
+        {
+            get
+            {
+                return 100 * (1.0 - (1.0 * CompressedSize) / (1.0 * UncompressedSize));
+            }
+        }
+
+        private Int32 _LastModDateTime;
+        private Int32 _Crc32;
+        private byte[] _Extra;
+
+        private byte[] __filedata;
+        private byte[] _FileData
+        {
+            get
+            {
+                if (__filedata == null)
+                {
+                }
+                return __filedata;
+            }
+        }
+
+        private System.IO.MemoryStream _UnderlyingMemoryStream;
+        private System.IO.Compression.DeflateStream _CompressedStream;
+        private System.IO.Compression.DeflateStream CompressedStream
+        {
+            get
+            {
+                if (_CompressedStream == null)
+                {
+                    _UnderlyingMemoryStream = new System.IO.MemoryStream();
+                    bool LeaveUnderlyingStreamOpen = true;
+                    _CompressedStream = new System.IO.Compression.DeflateStream(_UnderlyingMemoryStream,
+                                                    System.IO.Compression.CompressionMode.Compress,
+                                                    LeaveUnderlyingStreamOpen);
+                }
+                return _CompressedStream;
+            }
+        }
+
+        private byte[] _header;
+        internal byte[] Header
+        {
+            get
+            {
+                return _header;
+            }
+        }
+
+        private int _RelativeOffsetOfHeader;
+
+
+        private static bool ReadHeader(System.IO.Stream s, ZipEntry ze)
+        {
+            int signature = TomShane.Neoforce.External.Zip.Shared.ReadSignature(s);
+
+            // return null if this is not a local file header signature
+            if (SignatureIsNotValid(signature))
+            {
+                s.Seek(-4, System.IO.SeekOrigin.Current);
+                if (ze._Debug) System.Console.WriteLine("  ZipEntry::Read(): Bad signature ({0:X8}) at position {1}", signature, s.Position);
+                return false;
+            }
+
+            byte[] block = new byte[26];
+            int n = s.Read(block, 0, block.Length);
+            if (n != block.Length) return false;
+
+            int i = 0;
+            ze._VersionNeeded = (short)(block[i++] + block[i++] * 256);
+            ze._BitField = (short)(block[i++] + block[i++] * 256);
+            ze._CompressionMethod = (short)(block[i++] + block[i++] * 256);
+            ze._LastModDateTime = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+
+            // the PKZIP spec says that if bit 3 is set (0x0008), then the CRC, Compressed size, and uncompressed size
+            // come directly after the file data.  The only way to find it is to scan the zip archive for the signature of 
+            // the Data Descriptor, and presume that that signature does not appear in the (compressed) data of the compressed file.  
+
+            if ((ze._BitField & 0x0008) != 0x0008)
+            {
+                ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+                ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+                ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+            }
+            else
+            {
+                // the CRC, compressed size, and uncompressed size are stored later in the stream.
+                // here, we advance the pointer.
+                i += 12;
+            }
+
+            Int16 filenameLength = (short)(block[i++] + block[i++] * 256);
+            Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256);
+
+            block = new byte[filenameLength];
+            n = s.Read(block, 0, block.Length);
+            ze._FileName = TomShane.Neoforce.External.Zip.Shared.StringFromBuffer(block, 0, block.Length);
+
+            ze._Extra = new byte[extraFieldLength];
+            n = s.Read(ze._Extra, 0, ze._Extra.Length);
+
+            // transform the time data into something usable
+            ze._LastModified = TomShane.Neoforce.External.Zip.Shared.PackedToDateTime(ze._LastModDateTime);
+
+            // actually get the compressed size and CRC if necessary
+            if ((ze._BitField & 0x0008) == 0x0008)
+            {
+                long posn = s.Position;
+                long SizeOfDataRead = TomShane.Neoforce.External.Zip.Shared.FindSignature(s, ZipEntryDataDescriptorSignature);
+                if (SizeOfDataRead == -1) return false; 
+
+                // read 3x 4-byte fields (CRC, Compressed Size, Uncompressed Size)
+                block = new byte[12];
+                n = s.Read(block, 0, block.Length);
+                if (n != 12) return false;
+                i = 0;
+                ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+                ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+                ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
+
+                if (SizeOfDataRead != ze._CompressedSize)
+                    throw new Exception("Data format error (bit 3 is set)"); 
+                
+                // seek back to previous position, to read file data
+                s.Seek(posn, System.IO.SeekOrigin.Begin);
+            }
+
+            return true;
+        }
+
+
+        private static bool SignatureIsNotValid(int signature)
+        {
+            return (signature != ZipEntrySignature);
+        }
+
+
+        public static ZipEntry Read(System.IO.Stream s)
+        {
+            return Read(s, false);
+        }
+
+
+        internal static ZipEntry Read(System.IO.Stream s, bool TurnOnDebug)
+        {
+            ZipEntry entry = new ZipEntry();
+            entry._Debug = TurnOnDebug;
+            if (!ReadHeader(s, entry)) return null;
+
+            entry.__filedata = new byte[entry.CompressedSize];
+            int n = s.Read(entry._FileData, 0, entry._FileData.Length);
+            if (n != entry._FileData.Length)
+            {
+                throw new Exception("badly formatted zip file.");
+            }
+            // finally, seek past the (already read) Data descriptor if necessary
+            if ((entry._BitField & 0x0008) == 0x0008)
+            {
+                s.Seek(16, System.IO.SeekOrigin.Current);
+            }
+            return entry;
+        }
+
+
+
+        internal static ZipEntry Create(String filename)
+        {
+            ZipEntry entry = new ZipEntry();
+            entry._FileName = filename;
+
+            entry._LastModified = System.IO.File.GetLastWriteTime(filename);
+	    // adjust the time if the .NET BCL thinks it is in DST.  
+	    // see the note elsewhere in this file for more info. 
+            if (entry._LastModified.IsDaylightSavingTime())
+            {
+                System.DateTime AdjustedTime = entry._LastModified - new System.TimeSpan(1, 0, 0);
+                entry._LastModDateTime = TomShane.Neoforce.External.Zip.Shared.DateTimeToPacked(AdjustedTime);
+            }
+            else
+                entry._LastModDateTime = TomShane.Neoforce.External.Zip.Shared.DateTimeToPacked(entry._LastModified);
+
+            // we don't actually slurp in the file until the caller invokes Write on this entry.
+
+            return entry;
+        }
+
+
+
+        public void Extract()
+        {
+            Extract(".");
+        }
+
+        public void Extract(System.IO.Stream s)
+        {
+            Extract(null, s);
+        }
+
+        public void Extract(string basedir)
+        {
+            Extract(basedir, null);
+        }
+
+
+		internal System.IO.Stream GetStream()
+		{
+			System.IO.MemoryStream memstream = new System.IO.MemoryStream(_FileData);
+
+			if (CompressedSize == UncompressedSize)
+				return memstream;
+
+			return new System.IO.Compression.DeflateStream(
+				memstream, System.IO.Compression.CompressionMode.Decompress);
+		}
+
+        // pass in either basedir or s, but not both. 
+        // In other words, you can extract to a stream or to a directory, but not both!
+        private void Extract(string basedir, System.IO.Stream s)
+        {
+            string TargetFile = null;
+            if (basedir != null)
+            {
+                TargetFile = System.IO.Path.Combine(basedir, FileName);
+
+                // check if a directory
+                if (FileName.EndsWith("/"))
+                {
+                    if (!System.IO.Directory.Exists(TargetFile))
+                        System.IO.Directory.CreateDirectory(TargetFile);
+                    return;
+                }
+            }
+            else if (s != null)
+            {
+                if (FileName.EndsWith("/"))
+                    // extract a directory to streamwriter?  nothing to do!
+                    return;
+            }
+            else throw new Exception("Invalid input.");
+
+
+            using (System.IO.MemoryStream memstream = new System.IO.MemoryStream(_FileData))
+            {
+
+                System.IO.Stream input = null;
+                try
+                {
+
+                    if (CompressedSize == UncompressedSize)
+                    {
+                        // the System.IO.Compression.DeflateStream class does not handle uncompressed data.
+                        // so if an entry is not compressed, then we just translate the bytes directly.
+                        input = memstream;
+                    }
+                    else
+                    {
+                        input = new System.IO.Compression.DeflateStream(memstream, System.IO.Compression.CompressionMode.Decompress);
+                    }
+
+
+                    if (TargetFile != null)
+                    {
+                        // ensure the target path exists
+                        if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(TargetFile)))
+                        {
+                            System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(TargetFile));
+                        }
+                    }
+
+
+                    System.IO.Stream output = null;
+                    try
+                    {
+                        if (TargetFile != null)
+                            output = new System.IO.FileStream(TargetFile, System.IO.FileMode.CreateNew);
+                        else
+                            output = s;
+
+
+                        byte[] bytes = new byte[4096];
+                        int n;
+
+                        if (_Debug)
+                        {
+                            Console.WriteLine("{0}: _FileData.Length= {1}", TargetFile, _FileData.Length);
+                            Console.WriteLine("{0}: memstream.Position: {1}", TargetFile, memstream.Position);
+                            n = _FileData.Length;
+                            if (n > 1000)
+                            {
+                                n = 500;
+                                Console.WriteLine("{0}: truncating dump from {1} to {2} bytes...", TargetFile, _FileData.Length, n);
+                            }
+                            for (int j = 0; j < n; j += 2)
+                            {
+                                if ((j > 0) && (j % 40 == 0))
+                                    System.Console.WriteLine();
+                                System.Console.Write(" {0:X2}", _FileData[j]);
+                                if (j + 1 < n)
+                                    System.Console.Write("{0:X2}", _FileData[j + 1]);
+                            }
+                            System.Console.WriteLine("\n");
+                        }
+
+                        n = 1; // anything non-zero
+                        while (n != 0)
+                        {
+                            if (_Debug) Console.WriteLine("{0}: about to read...", TargetFile);
+                            n = input.Read(bytes, 0, bytes.Length);
+                            if (_Debug) Console.WriteLine("{0}: got {1} bytes", TargetFile, n);
+                            if (n > 0)
+                            {
+                                if (_Debug) Console.WriteLine("{0}: about to write...", TargetFile);
+                                output.Write(bytes, 0, n);
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        // we only close the output stream if we opened it. 
+                        if ((output != null) && (TargetFile != null))
+                        {
+                            output.Close();
+                            output.Dispose();
+                        }
+                    }
+
+                    if (TargetFile != null)
+                    {
+                      // We may have to adjust the last modified time to compensate
+                      // for differences in how the .NET Base Class Library deals
+                      // with daylight saving time (DST) versus how the Windows
+                      // filesystem deals with daylight saving time. See 
+		      // http://blogs.msdn.com/oldnewthing/archive/2003/10/24/55413.aspx for some context. 
+
+		      // in a nutshell: Daylight savings time rules change regularly.  In
+		      // 2007, for example, the inception week of DST changed.  In 1977,
+		      // DST was in place all year round. in 1945, likewise.  And so on.
+		      // Win32 does not attempt to guess which time zone rules were in
+		      // effect at the time in question.  It will render a time as
+		      // "standard time" and allow the app to change to DST as necessary.
+		      //  .NET makes a different choice.
+
+		      // -------------------------------------------------------
+		      // Compare the output of FileInfo.LastWriteTime.ToString("f") with
+		      // what you see in the property sheet for a file that was last
+		      // written to on the other side of the DST transition. For example,
+		      // suppose the file was last modified on October 17, during DST but
+		      // DST is not currently in effect. Explorer's file properties
+		      // reports Thursday, October 17, 2003, 8:45:38 AM, but .NETs
+		      // FileInfo reports Thursday, October 17, 2003, 9:45 AM.
+		      
+		      // Win32 says, "Thursday, October 17, 2002 8:45:38 AM PST". Note:
+		      // Pacific STANDARD Time. Even though October 17 of that year
+		      // occurred during Pacific Daylight Time, Win32 displays the time as
+		      // standard time because that's what time it is NOW.
+
+		      // .NET BCL assumes that the current DST rules were in place at the
+		      // time in question.  So, .NET says, "Well, if the rules in effect
+		      // now were also in effect on October 17, 2003, then that would be
+		      // daylight time" so it displays "Thursday, October 17, 2003, 9:45
+		      // AM PDT" - daylight time.
+
+		      // So .NET gives a value which is more intuitively correct, but is
+		      // also potentially incorrect, and which is not invertible. Win32
+		      // gives a value which is intuitively incorrect, but is strictly
+		      // correct.
+		      // -------------------------------------------------------
+
+		      // With this adjustment, I add one hour to the tweaked .NET time, if
+		      // necessary.  That is to say, if the time in question had occurred
+		      // in what the .NET BCL assumed to be DST (an assumption that may be
+		      // wrong given the constantly changing DST rules).
+
+#if !XBOX
+                        if (LastModified.IsDaylightSavingTime())
+                        {
+                            DateTime AdjustedLastModified = LastModified + new System.TimeSpan(1, 0, 0);
+                            System.IO.File.SetLastWriteTime(TargetFile, AdjustedLastModified);
+                        }
+                        else
+                            System.IO.File.SetLastWriteTime(TargetFile, LastModified);
+#endif
+                    }
+
+                }
+                finally
+                {
+		  // we only close the output stream if we opened it. 
+                    // we cannot use using() here because in some cases we do not want to Dispose the stream!
+                    if ((input != null) && (input != memstream))
+                    {
+                        input.Close();
+                        input.Dispose();
+                    }
+                }
+            }
+        }
+
+
+        internal void WriteCentralDirectoryEntry(System.IO.Stream s)
+        {
+            byte[] bytes = new byte[4096];
+            int i = 0;
+            // signature
+            bytes[i++] = (byte)(ZipDirEntry.ZipDirEntrySignature & 0x000000FF);
+            bytes[i++] = (byte)((ZipDirEntry.ZipDirEntrySignature & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((ZipDirEntry.ZipDirEntrySignature & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((ZipDirEntry.ZipDirEntrySignature & 0xFF000000) >> 24);
+
+            // Version Made By
+            bytes[i++] = Header[4];
+            bytes[i++] = Header[5];
+
+            // Version Needed, Bitfield, compression method, lastmod,
+            // crc, sizes, filename length and extra field length -
+            // are all the same as the local file header. So just copy them
+            int j = 0;
+            for (j = 0; j < 26; j++)
+                bytes[i + j] = Header[4 + j];
+
+            i += j;  // positioned at next available byte
+
+            // File Comment Length
+            bytes[i++] = 0;
+            bytes[i++] = 0;
+
+            // Disk number start
+            bytes[i++] = 0;
+            bytes[i++] = 0;
+
+            // internal file attrs            
+            bytes[i++] = 1;
+            bytes[i++] = 0;
+
+            // external file attrs            
+            bytes[i++] = 0x20;
+            bytes[i++] = 0;
+            bytes[i++] = 0xb6;
+            bytes[i++] = 0x81;
+
+            // relative offset of local header (I think this can be zero)
+            bytes[i++] = (byte)(_RelativeOffsetOfHeader & 0x000000FF);
+            bytes[i++] = (byte)((_RelativeOffsetOfHeader & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((_RelativeOffsetOfHeader & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((_RelativeOffsetOfHeader & 0xFF000000) >> 24);
+
+            if (_Debug) System.Console.WriteLine("\ninserting filename into CDS: (length= {0})", Header.Length - 30);
+            // actual filename (starts at offset 34 in header) 
+            for (j = 0; j < Header.Length - 30; j++)
+            {
+                bytes[i + j] = Header[30 + j];
+                if (_Debug) System.Console.Write(" {0:X2}", bytes[i + j]);
+            }
+            if (_Debug) System.Console.WriteLine();
+            i += j;
+
+            s.Write(bytes, 0, i);
+        }
+
+
+        private void WriteHeader(System.IO.Stream s, byte[] bytes)
+        {
+            // write the header info
+
+            int i = 0;
+            // signature
+            bytes[i++] = (byte)(ZipEntrySignature & 0x000000FF);
+            bytes[i++] = (byte)((ZipEntrySignature & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((ZipEntrySignature & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((ZipEntrySignature & 0xFF000000) >> 24);
+
+            // version needed
+            Int16 FixedVersionNeeded = 0x14; // from examining existing zip files
+            bytes[i++] = (byte)(FixedVersionNeeded & 0x00FF);
+            bytes[i++] = (byte)((FixedVersionNeeded & 0xFF00) >> 8);
+
+            // bitfield
+            Int16 BitField = 0x00; // from examining existing zip files
+            bytes[i++] = (byte)(BitField & 0x00FF);
+            bytes[i++] = (byte)((BitField & 0xFF00) >> 8);
+
+            // compression method
+            Int16 CompressionMethod = 0x08; // 0x08 = Deflate
+            bytes[i++] = (byte)(CompressionMethod & 0x00FF);
+            bytes[i++] = (byte)((CompressionMethod & 0xFF00) >> 8);
+
+            // LastMod
+            bytes[i++] = (byte)(_LastModDateTime & 0x000000FF);
+            bytes[i++] = (byte)((_LastModDateTime & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((_LastModDateTime & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((_LastModDateTime & 0xFF000000) >> 24);
+
+            // CRC32 (Int32)
+            CRC32 crc32 = new CRC32();
+            UInt32 crc = 0;
+            using (System.IO.Stream input = System.IO.File.OpenRead(FileName))
+            {
+                crc = crc32.GetCrc32AndCopy(input, CompressedStream);
+            }
+            CompressedStream.Close();  // to get the footer bytes written to the underlying stream
+
+            bytes[i++] = (byte)(crc & 0x000000FF);
+            bytes[i++] = (byte)((crc & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((crc & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((crc & 0xFF000000) >> 24);
+
+            // CompressedSize (Int32)
+            Int32 isz = (Int32)_UnderlyingMemoryStream.Length;
+            UInt32 sz = (UInt32)isz;
+            bytes[i++] = (byte)(sz & 0x000000FF);
+            bytes[i++] = (byte)((sz & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((sz & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((sz & 0xFF000000) >> 24);
+
+            // UncompressedSize (Int32)
+            if (_Debug) System.Console.WriteLine("Uncompressed Size: {0}", crc32.TotalBytesRead);
+            bytes[i++] = (byte)(crc32.TotalBytesRead & 0x000000FF);
+            bytes[i++] = (byte)((crc32.TotalBytesRead & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((crc32.TotalBytesRead & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((crc32.TotalBytesRead & 0xFF000000) >> 24);
+
+            // filename length (Int16)
+            Int16 length = (Int16)FileName.Length;
+	    // see note below about TrimVolumeFromFullyQualifiedPaths.
+	    if ( (TrimVolumeFromFullyQualifiedPaths) && (FileName[1]==':') && (FileName[2]=='\\')) length-=3;
+            bytes[i++] = (byte)(length & 0x00FF);
+            bytes[i++] = (byte)((length & 0xFF00) >> 8);
+
+            // extra field length (short)
+            Int16 ExtraFieldLength = 0x00;
+            bytes[i++] = (byte)(ExtraFieldLength & 0x00FF);
+            bytes[i++] = (byte)((ExtraFieldLength & 0xFF00) >> 8);
+
+	    // Tue, 27 Mar 2007  16:35
+
+	    // Creating a zip that contains entries with "fully qualified" pathnames
+	    // can result in a zip archive that is unreadable by Windows Explorer.
+	    // Such archives are valid according to other tools but not to explorer.
+	    // To avoid this, we can trim off the leading volume name and slash (eg
+	    // c:\) when creating (writing) a zip file.  We do this by default and we
+	    // leave the old behavior available with the
+	    // TrimVolumeFromFullyQualifiedPaths flag - set it to false to get the old
+	    // behavior.  It only affects zip creation.
+
+            // actual filename
+            char[] c =  ( (TrimVolumeFromFullyQualifiedPaths) && (FileName[1]==':') && (FileName[2]=='\\')) ? 
+	      FileName.Substring(3).ToCharArray() :  // trim off volume letter, colon, and slash
+	      FileName.ToCharArray();
+            int j = 0;
+
+            if (_Debug)
+            {
+                System.Console.WriteLine("local header: writing filename, {0} chars", c.Length);
+                System.Console.WriteLine("starting offset={0}", i);
+            }
+            for (j = 0; (j < c.Length) && (i + j < bytes.Length); j++)
+            {
+                bytes[i + j] = System.BitConverter.GetBytes(c[j])[0];
+                if (_Debug) System.Console.Write(" {0:X2}", bytes[i + j]);
+            }
+            if (_Debug) System.Console.WriteLine();
+
+            i += j;
+
+            // extra field (we always write nothing in this implementation)
+            // ;;
+
+            // remember the file offset of this header
+            _RelativeOffsetOfHeader = (int)s.Length;
+
+
+            if (_Debug)
+            {
+                System.Console.WriteLine("\nAll header data:");
+                for (j = 0; j < i; j++)
+                    System.Console.Write(" {0:X2}", bytes[j]);
+                System.Console.WriteLine();
+            }
+            // finally, write the header to the stream
+            s.Write(bytes, 0, i);
+
+            // preserve this header data for use with the central directory structure.
+            _header = new byte[i];
+            if (_Debug) System.Console.WriteLine("preserving header of {0} bytes", _header.Length);
+            for (j = 0; j < i; j++)
+                _header[j] = bytes[j];
+
+        }
+
+
+        internal void Write(System.IO.Stream s)
+        {
+            byte[] bytes = new byte[4096];
+            int n;
+
+            // write the header:
+            WriteHeader(s, bytes);
+
+            // write the actual file data: 
+            _UnderlyingMemoryStream.Position = 0;
+
+            if (_Debug)
+            {
+                Console.WriteLine("{0}: writing compressed data to zipfile...", FileName);
+                Console.WriteLine("{0}: total data length: {1}", FileName, _UnderlyingMemoryStream.Length);
+            }
+            while ((n = _UnderlyingMemoryStream.Read(bytes, 0, bytes.Length)) != 0)
+            {
+
+                if (_Debug)
+                {
+                    Console.WriteLine("{0}: transferring {1} bytes...", FileName, n);
+
+                    for (int j = 0; j < n; j += 2)
+                    {
+                        if ((j > 0) && (j % 40 == 0))
+                            System.Console.WriteLine();
+                        System.Console.Write(" {0:X2}", bytes[j]);
+                        if (j + 1 < n)
+                            System.Console.Write("{0:X2}", bytes[j + 1]);
+                    }
+                    System.Console.WriteLine("\n");
+                }
+
+                s.Write(bytes, 0, n);
+            }
+
+            //_CompressedStream.Close();
+            //_CompressedStream= null;
+            _UnderlyingMemoryStream.Close();
+            _UnderlyingMemoryStream = null;
+        }
+    }
+}

Neoforce/External/Zip/ZipFile.cs

@@ -0,0 +1,505 @@
+using System;
+
+namespace TomShane.Neoforce.External.Zip
+{
+
+    internal class ZipFile : System.Collections.Generic.IEnumerable<ZipEntry>,
+      IDisposable
+    {
+        private string _name;
+        public string Name
+        {
+            get { return _name; }
+        }
+
+
+
+      // when this is set, we trim the volume (eg C:) off any fully-qualified pathname, 
+      // before writing the ZipEntry into the ZipFile. 
+      // We default this to true.  This allows Windows Explorer to read the zip archives properly. 
+      private bool _TrimVolumeFromFullyQualifiedPaths= true;
+      public bool TrimVolumeFromFullyQualifiedPaths
+      {
+            get { return _TrimVolumeFromFullyQualifiedPaths; }
+            set { _TrimVolumeFromFullyQualifiedPaths= value; }
+      }
+
+        private System.IO.Stream ReadStream
+        {
+            get
+            {
+                if (_readstream == null)
+                {
+                    _readstream = System.IO.File.OpenRead(_name);
+                }
+                return _readstream;
+            }
+        }
+
+        private System.IO.FileStream WriteStream
+        {
+            get
+            {
+                if (_writestream == null)
+                {
+                    _writestream = new System.IO.FileStream(_name, System.IO.FileMode.CreateNew);
+                }
+                return _writestream;
+            }
+        }
+
+        private ZipFile() { }
+
+
+        #region For Writing Zip Files
+
+        public ZipFile(string NewZipFileName)
+        {
+            // create a new zipfile
+            _name = NewZipFileName;
+            if (System.IO.File.Exists(_name))
+                throw new System.Exception(String.Format("That file ({0}) already exists.", NewZipFileName));
+            _entries = new System.Collections.Generic.List<ZipEntry>();
+        }
+
+
+        public void AddItem(string FileOrDirectoryName)
+        {
+            AddItem(FileOrDirectoryName, false);
+        }
+
+        public void AddItem(string FileOrDirectoryName, bool WantVerbose)
+        {
+            if (System.IO.File.Exists(FileOrDirectoryName))
+                AddFile(FileOrDirectoryName, WantVerbose);
+            else if (System.IO.Directory.Exists(FileOrDirectoryName))
+                AddDirectory(FileOrDirectoryName, WantVerbose);
+
+            else
+                throw new Exception(String.Format("That file or directory ({0}) does not exist!", FileOrDirectoryName));
+        }
+
+        public void AddFile(string FileName)
+        {
+            AddFile(FileName, false);
+        }
+
+        public void AddFile(string FileName, bool WantVerbose)
+        {
+            ZipEntry ze = ZipEntry.Create(FileName);
+            ze.TrimVolumeFromFullyQualifiedPaths= TrimVolumeFromFullyQualifiedPaths;
+            if (WantVerbose) Console.WriteLine("adding {0}...", FileName);
+			ze.Write(WriteStream);
+            _entries.Add(ze);
+        }
+
+        public void AddDirectory(string DirectoryName)
+        {
+            AddDirectory(DirectoryName, false);
+        }
+
+        public void AddDirectory(string DirectoryName, bool WantVerbose)
+        {
+            String[] filenames = System.IO.Directory.GetFiles(DirectoryName);
+            foreach (String filename in filenames)
+            {
+                if (WantVerbose) Console.WriteLine("adding {0}...", filename);
+                AddFile(filename);
+            }
+        }
+
+
+        public void Save()
+        {
+            WriteCentralDirectoryStructure();
+            WriteStream.Close();
+            _writestream = null;
+        }
+
+
+        private void WriteCentralDirectoryStructure()
+        {
+            // the central directory structure
+            long Start = WriteStream.Length;
+            foreach (ZipEntry e in _entries)
+            {
+                e.WriteCentralDirectoryEntry(WriteStream);
+            }
+            long Finish = WriteStream.Length;
+
+            // now, the footer
+            WriteCentralDirectoryFooter(Start, Finish);
+        }
+
+
+        private void WriteCentralDirectoryFooter(long StartOfCentralDirectory, long EndOfCentralDirectory)
+        {
+            byte[] bytes = new byte[1024];
+            int i = 0;
+            // signature
+            UInt32 EndOfCentralDirectorySignature = 0x06054b50;
+            bytes[i++] = (byte)(EndOfCentralDirectorySignature & 0x000000FF);
+            bytes[i++] = (byte)((EndOfCentralDirectorySignature & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((EndOfCentralDirectorySignature & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((EndOfCentralDirectorySignature & 0xFF000000) >> 24);
+
+            // number of this disk
+            bytes[i++] = 0;
+            bytes[i++] = 0;
+
+            // number of the disk with the start of the central directory
+            bytes[i++] = 0;
+            bytes[i++] = 0;
+
+            // total number of entries in the central dir on this disk
+            bytes[i++] = (byte)(_entries.Count & 0x00FF);
+            bytes[i++] = (byte)((_entries.Count & 0xFF00) >> 8);
+
+            // total number of entries in the central directory
+            bytes[i++] = (byte)(_entries.Count & 0x00FF);
+            bytes[i++] = (byte)((_entries.Count & 0xFF00) >> 8);
+
+            // size of the central directory
+            Int32 SizeOfCentralDirectory = (Int32)(EndOfCentralDirectory - StartOfCentralDirectory);
+            bytes[i++] = (byte)(SizeOfCentralDirectory & 0x000000FF);
+            bytes[i++] = (byte)((SizeOfCentralDirectory & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((SizeOfCentralDirectory & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((SizeOfCentralDirectory & 0xFF000000) >> 24);
+
+            // offset of the start of the central directory 
+            Int32 StartOffset = (Int32)StartOfCentralDirectory;  // cast down from Long
+            bytes[i++] = (byte)(StartOffset & 0x000000FF);
+            bytes[i++] = (byte)((StartOffset & 0x0000FF00) >> 8);
+            bytes[i++] = (byte)((StartOffset & 0x00FF0000) >> 16);
+            bytes[i++] = (byte)((StartOffset & 0xFF000000) >> 24);
+
+            // zip comment length
+            bytes[i++] = 0;
+            bytes[i++] = 0;
+
+            WriteStream.Write(bytes, 0, i);
+        }
+
+        #endregion
+
+        #region For Reading Zip Files
+
+        internal static ZipFile Read(string zipfilename)
+        {
+            return Read(zipfilename, false);
+        }
+
+        internal static ZipFile Read(string zipfilename, bool TurnOnDebug)
+        {
+
+            ZipFile zf = new ZipFile();
+            zf._Debug = TurnOnDebug;
+            zf._name = zipfilename;
+            zf._entries = new System.Collections.Generic.List<ZipEntry>();
+            ZipEntry e;
+            while ((e = ZipEntry.Read(zf.ReadStream, zf._Debug)) != null)
+            {
+                if (zf._Debug) System.Console.WriteLine("  ZipFile::Read(): ZipEntry: {0}", e.FileName);
+                zf._entries.Add(e);
+            }
+
+            // read the zipfile's central directory structure here.
+            zf._direntries = new System.Collections.Generic.List<ZipDirEntry>();
+
+            ZipDirEntry de;
+            while ((de = ZipDirEntry.Read(zf.ReadStream, zf._Debug)) != null)
+            {
+                if (zf._Debug) System.Console.WriteLine("  ZipFile::Read(): ZipDirEntry: {0}", de.FileName);
+                zf._direntries.Add(de);
+            }
+
+            return zf;
+        }
+
+        public System.Collections.Generic.IEnumerator<ZipEntry> GetEnumerator()
+        {
+            foreach (ZipEntry e in _entries)
+                yield return e;
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+
+        public void ExtractAll(string path)
+        {
+            ExtractAll(path, false);
+        }
+
+
+        public void ExtractAll(string path, bool WantVerbose)
+        {
+            bool header = WantVerbose;
+            foreach (ZipEntry e in _entries)
+            {
+                if (header)
+                {
+                    System.Console.WriteLine("\n{1,-22} {2,-6} {3,4}   {4,-8}  {0}",
+                                 "Name", "Modified", "Size", "Ratio", "Packed");
+                    System.Console.WriteLine(new System.String('-', 72));
+                    header = false;
+                }
+                if (WantVerbose)
+                    System.Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8} {0}",
+                                 e.FileName,
+                                 e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),
+                                 e.UncompressedSize,
+                                 e.CompressionRatio,
+                                 e.CompressedSize);
+                e.Extract(path);
+            }
+        }
+
+
+        public void Extract(string filename)
+        {
+            this[filename].Extract();
+        }
+
+
+        public void Extract(string filename, System.IO.Stream s)
+        {
+            this[filename].Extract(s);
+        }
+
+
+        public ZipEntry this[String filename]
+        {
+            get
+            {
+                foreach (ZipEntry e in _entries)
+                {
+                    if (e.FileName == filename) return e;
+                }
+                return null;
+            }
+        }
+
+        #endregion
+
+        // the destructor
+        ~ZipFile()
+        {
+            // call Dispose with false.  Since we're in the
+            // destructor call, the managed resources will be
+            // disposed of anyways.
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            // dispose of the managed and unmanaged resources
+            Dispose(true);
+
+            // tell the GC that the Finalize process no longer needs
+            // to be run for this object.
+            GC.SuppressFinalize(this);
+        }
+
+
+        protected virtual void Dispose(bool disposeManagedResources)
+        {
+            if (!this._disposed)
+            {
+                if (disposeManagedResources)
+                {
+                    // dispose managed resources
+                    if (_readstream != null)
+                    {
+                        _readstream.Dispose();
+                        _readstream = null;
+                    }
+                    if (_writestream != null)
+                    {
+                        _writestream.Dispose();
+                        _writestream = null;
+                    }
+                }
+                this._disposed = true;
+            }
+        }
+
+
+        private System.IO.Stream _readstream;
+        private System.IO.FileStream _writestream;
+        private bool _Debug = false;
+        private bool _disposed = false;
+        private System.Collections.Generic.List<ZipEntry> _entries = null;
+        private System.Collections.Generic.List<ZipDirEntry> _direntries = null;
+    }
+
+}
+
+#region More Info
+// Example usage: 
+// 1. Extracting all files from a Zip file: 
+//
+//     try 
+//     {
+//       using(ZipFile zip= ZipFile.Read(ZipFile))
+//       {
+//         zip.ExtractAll(TargetDirectory, true);
+//       }
+//     }
+//     catch (System.Exception ex1)
+//     {
+//       System.Console.Error.WriteLine("exception: " + ex1);
+//     }
+//
+// 2. Extracting files from a zip individually:
+//
+//     try 
+//     {
+//       using(ZipFile zip= ZipFile.Read(ZipFile)) 
+//       {
+//         foreach (ZipEntry e in zip) 
+//         {
+//           e.Extract(TargetDirectory);
+//         }
+//       }
+//     }
+//     catch (System.Exception ex1)
+//     {
+//       System.Console.Error.WriteLine("exception: " + ex1);
+//     }
+//
+// 3. Creating a zip archive: 
+//
+//     try 
+//     {
+//       using(ZipFile zip= new ZipFile(NewZipFile)) 
+//       {
+//
+//         String[] filenames= System.IO.Directory.GetFiles(Directory); 
+//         foreach (String filename in filenames) 
+//         {
+//           zip.Add(filename);
+//         }
+//
+//         zip.Save(); 
+//       }
+//
+//     }
+//     catch (System.Exception ex1)
+//     {
+//       System.Console.Error.WriteLine("exception: " + ex1);
+//     }
+//
+//
+// ==================================================================
+//
+//
+//
+// Information on the ZIP format:
+//
+// From
+// http://www.pkware.com/business_and_developers/developer/popups/appnote.txt
+//
+//  Overall .ZIP file format:
+//
+//     [local file header 1]
+//     [file data 1]
+//     [data descriptor 1]  ** sometimes
+//     . 
+//     .
+//     .
+//     [local file header n]
+//     [file data n]
+//     [data descriptor n]   ** sometimes
+//     [archive decryption header] 
+//     [archive extra data record] 
+//     [central directory]
+//     [zip64 end of central directory record]
+//     [zip64 end of central directory locator] 
+//     [end of central directory record]
+//
+// Local File Header format:
+//         local file header signature     4 bytes  (0x04034b50)
+//         version needed to extract       2 bytes
+//         general purpose bit flag        2 bytes
+//         compression method              2 bytes
+//         last mod file time              2 bytes
+//         last mod file date              2 bytes
+//         crc-32                          4 bytes
+//         compressed size                 4 bytes
+//         uncompressed size               4 bytes
+//         file name length                2 bytes
+//         extra field length              2 bytes
+//         file name                       varies
+//         extra field                     varies
+//
+//
+// Data descriptor:  (used only when bit 3 of the general purpose bitfield is set)
+//         local file header signature     4 bytes  (0x08074b50)
+//         crc-32                          4 bytes
+//         compressed size                 4 bytes
+//         uncompressed size               4 bytes
+//
+//
+//   Central directory structure:
+//
+//       [file header 1]
+//       .
+//       .
+//       . 
+//       [file header n]
+//       [digital signature] 
+//
+//
+//       File header:  (This is ZipDirEntry in the code above)
+//         central file header signature   4 bytes  (0x02014b50)
+//         version made by                 2 bytes
+//         version needed to extract       2 bytes
+//         general purpose bit flag        2 bytes
+//         compression method              2 bytes
+//         last mod file time              2 bytes
+//         last mod file date              2 bytes
+//         crc-32                          4 bytes
+//         compressed size                 4 bytes
+//         uncompressed size               4 bytes
+//         file name length                2 bytes
+//         extra field length              2 bytes
+//         file comment length             2 bytes
+//         disk number start               2 bytes
+//         internal file attributes        2 bytes
+//         external file attributes        4 bytes
+//         relative offset of local header 4 bytes
+//         file name (variable size)
+//         extra field (variable size)
+//         file comment (variable size)
+//
+// End of central directory record:
+//
+//         end of central dir signature    4 bytes  (0x06054b50)
+//         number of this disk             2 bytes
+//         number of the disk with the
+//         start of the central directory  2 bytes
+//         total number of entries in the
+//         central directory on this disk  2 bytes
+//         total number of entries in
+//         the central directory           2 bytes
+//         size of the central directory   4 bytes
+//         offset of start of central
+//         directory with respect to
+//         the starting disk number        4 bytes
+//         .ZIP file comment length        2 bytes
+//         .ZIP file comment       (variable size)
+//
+// date and time are packed values, as MSDOS did them
+// time: bits 0-4 : second
+//            5-10: minute
+//            11-15: hour
+// date  bits 0-4 : day
+//            5-8: month
+//            9-15 year (since 1980)
+//
+// see http://www.vsft.com/hal/dostime.htm
+
+#endregion

Neoforce/GroupBox.cs

@@ -0,0 +1,139 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: GroupBox.cs                                  //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+    public enum GroupBoxType
+    {
+        Normal,
+        Flat
+    }
+
+    public class GroupBox : Container
+    {
+
+        #region //// Fields ////////////
+
+        ////////////////////////////////////////////////////////////////////////////       
+        private GroupBoxType type = GroupBoxType.Normal;
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Properties ////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual GroupBoxType Type
+        {
+            get { return type; }
+            set { type = value; Invalidate(); }
+        }
+        ////////////////////////////////////////////////////////////////////////////    
+
+        #endregion
+
+        #region //// Construstors //////
+
+        ////////////////////////////////////////////////////////////////////////////       
+        public GroupBox(Manager manager)
+            : base(manager)
+        {
+            CheckLayer(Skin, "Control");
+            CheckLayer(Skin, "Flat");
+
+            CanFocus = false;
+            Passive = true;
+            Width = 64;
+            Height = 64;
+            BackColor = Color.Transparent;
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Methods ///////////
+
+        ////////////////////////////////////////////////////////////////////////////   
+        public override void Init()
+        {
+            base.Init();
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+
+        private void AdjustClientMargins()
+        {
+            SkinLayer layer = this.type == GroupBoxType.Normal ? this.Skin.Layers["Control"] : this.Skin.Layers["Flat"];
+            SpriteFont font = (layer.Text != null && layer.Text.Font != null) ? layer.Text.Font.Resource : null;
+            Vector2 size = font.MeasureString(this.Text);
+            var cm = this.ClientMargins;
+            cm.Top = string.IsNullOrWhiteSpace(this.Text) ? this.ClientTop : (int)size.Y;
+            this.ClientMargins = new Margins(cm.Left, cm.Top, cm.Right, cm.Bottom);
+        }
+
+        protected override void OnTextChanged(EventArgs e)
+        {
+            base.OnTextChanged(e);
+            AdjustClientMargins();
+        }
+
+        protected internal override void OnSkinChanged(EventArgs e)
+        {
+            base.OnSkinChanged(e);
+            AdjustClientMargins();
+        }
+
+        ////////////////////////////////////////////////////////////////////////////   
+        protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+        {
+            SkinLayer layer = type == GroupBoxType.Normal ? Skin.Layers["Control"] : Skin.Layers["Flat"];
+            SpriteFont font = (layer.Text != null && layer.Text.Font != null) ? layer.Text.Font.Resource : null;
+            Color col = (layer.Text != null) ? layer.Text.Colors.Enabled : Color.White;
+            Point offset = new Point(layer.Text.OffsetX, layer.Text.OffsetY);
+            Vector2 size = font.MeasureString(Text);
+            size.Y = font.LineSpacing;
+            Rectangle r = new Rectangle(rect.Left, rect.Top + (int)(size.Y / 2), rect.Width, rect.Height - (int)(size.Y / 2));
+
+            renderer.DrawLayer(this, layer, r);
+
+            if (font != null && Text != null && Text != "")
+            {
+                Rectangle bg = new Rectangle(r.Left + offset.X, (r.Top - (int)(size.Y / 2)) + offset.Y, (int)size.X + layer.ContentMargins.Horizontal, (int)size.Y);
+                renderer.DrawLayer(Manager.Skin.Controls["Control"].Layers[0], bg, new Color(64, 64, 64), 0);
+                renderer.DrawString(this, layer, Text, new Rectangle(r.Left, r.Top - (int)(size.Y / 2), (int)(size.X), (int)size.Y), true, 0, 0, false);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////     
+
+        #endregion
+
+    }
+
+}

Neoforce/GroupPanel.cs

@@ -0,0 +1,94 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: GroupPanel.cs                                //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public class GroupPanel: Container
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////           
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////    
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public GroupPanel(Manager manager): base(manager)
+    {     
+      CanFocus = false;
+      Passive = true;
+      Width = 64;
+      Height = 64;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public override void Init()
+    {
+      base.Init();      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////   
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {                  
+      SkinLayer layer = Skin.Layers["Control"];      
+      SpriteFont font = (layer.Text != null && layer.Text.Font != null) ? layer.Text.Font.Resource : null;
+      Color col = (layer.Text != null) ? layer.Text.Colors.Enabled : Color.White;
+      Point offset = new Point(layer.Text.OffsetX, layer.Text.OffsetY);        
+               
+      renderer.DrawLayer(this, layer, rect);
+     
+      if (font != null && Text != null && Text != "")
+      {                      
+        renderer.DrawString(this, layer, Text, new Rectangle(rect.Left, rect.Top + layer.ContentMargins.Top, rect.Width, Skin.ClientMargins.Top - layer.ContentMargins.Horizontal), false, offset.X, offset.Y, false);
+      } 
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    #endregion
+
+  }
+
+}

Neoforce/ImageBox.cs

@@ -0,0 +1,197 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ImageBox.cs                                  //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+  public class ImageBox: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private Texture2D image = null;
+    private SizeMode sizeMode = SizeMode.Normal;
+    private Rectangle sourceRect = Rectangle.Empty;   
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public Texture2D Image
+    {
+      get { return image; }
+      set 
+      {         
+        image = value;
+        sourceRect = new Rectangle(0, 0, image.Width, image.Height);
+        Invalidate();
+        if (!Suspended) OnImageChanged(new EventArgs());
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public Rectangle SourceRect
+    {
+      get { return sourceRect; }
+      set 
+      {                 
+        if (value != null && image != null)
+        {
+          int l = value.Left;
+          int t = value.Top;
+          int w = value.Width;        
+          int h = value.Height;
+          
+          if (l < 0) l = 0;
+          if (t < 0) t = 0;
+          if (w > image.Width) w = image.Width;
+          if (h > image.Height) h = image.Height;
+          if (l + w > image.Width) w = (image.Width - l); 
+          if (t + h > image.Height) h = (image.Height - t);
+
+          sourceRect = new Rectangle(l, t, w, h); 
+        }
+        else if (image != null)
+        {
+          sourceRect = new Rectangle(0, 0, image.Width, image.Height);
+        }  
+        else
+        {
+          sourceRect = Rectangle.Empty;
+        }                
+        Invalidate();
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public SizeMode SizeMode
+    {
+      get { return sizeMode; }
+      set
+      {
+        if (value == SizeMode.Auto && image != null)
+        {
+          Width = image.Width;
+          Height = image.Height;
+        }
+        sizeMode = value;
+        Invalidate();
+        if (!Suspended) OnSizeModeChanged(new EventArgs());
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                     
+    public event EventHandler ImageChanged;
+    public event EventHandler SizeModeChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ImageBox(Manager manager): base(manager)
+    {                 
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();  
+      CanFocus = false;   
+      Color = Color.White;        
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {      
+      if (image != null)
+      {
+        if (sizeMode == SizeMode.Normal)
+        {
+          renderer.Draw(image, rect.X, rect.Y, sourceRect, Color);
+        }
+        else if (sizeMode == SizeMode.Auto)
+        {          
+          renderer.Draw(image, rect.X, rect.Y, sourceRect, Color);
+        }
+        else if (sizeMode == SizeMode.Stretched)
+        {    
+          renderer.Draw(image, rect, sourceRect, Color);
+        }
+        else if (sizeMode == SizeMode.Centered)
+        {
+          int x = (rect.Width / 2) - (image.Width / 2);
+          int y = (rect.Height / 2) - (image.Height / 2);
+          
+          renderer.Draw(image, x, y, sourceRect, Color);
+        }
+        else if (sizeMode == SizeMode.Tiled)
+        {
+            renderer.DrawTileTexture(image, rect, Color);
+        }
+      }           
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnImageChanged(EventArgs e)
+    {
+      if (ImageChanged != null) ImageChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnSizeModeChanged(EventArgs e)
+    {
+      if (SizeModeChanged != null) SizeModeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+
+    #endregion  
+
+  }
+
+}

Neoforce/InputSystem.cs

@@ -0,0 +1,735 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: InputSystem.cs                               //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.GamerServices;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+ 
+  #region //// Enums /////////////
+  
+  ////////////////////////////////////////////////////////////////////////////
+  [Flags]
+  public enum InputMethods
+  {    
+    None = 0x00,    
+    Keyboard = 0x01,
+    Mouse = 0x02,
+    GamePad = 0x04,
+    All = Keyboard | Mouse | 0x04
+  }
+  ////////////////////////////////////////////////////////////////////////////
+  
+  ////////////////////////////////////////////////////////////////////////////
+  public enum MouseButton
+  {
+    None = 0,
+    Left,
+    Right,
+    Middle,
+    XButton1,
+    XButton2    
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  public enum MouseScrollDirection
+  {
+    None = 0,
+    Down = 1,
+    Up = 2
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  public enum GamePadButton
+  {
+    None = 0,
+    Start = 6,
+    Back,
+    Up,
+    Down,
+    Left,
+    Right,
+    A,
+    B,
+    X,
+    Y,
+    BigButton,
+    LeftShoulder,
+    RightShoulder,
+    LeftTrigger,
+    RightTrigger,
+    LeftStick,
+    RightStick,
+    LeftStickLeft,
+    LeftStickRight,
+    LeftStickUp,
+    LeftStickDown,
+    RightStickLeft,
+    RightStickRight,
+    RightStickUp,
+    RightStickDown    
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public enum ActivePlayer
+  {
+    None = -1,
+    One = 0,
+    Two = 1,
+    Three = 2,
+    Four = 3
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion       
+
+  #region //// Structs ///////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public struct GamePadVectors
+  {
+    public Vector2 LeftStick;
+    public Vector2 RightStick;
+    public float LeftTrigger;
+    public float RightTrigger;
+  } 
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public struct InputOffset
+  {
+    public int X;
+    public int Y;
+    public float RatioX;
+    public float RatioY;        
+    
+    public InputOffset(int x, int y, float rx, float ry)
+    {
+      X = x;
+      Y = y;
+      RatioX = rx;
+      RatioY = ry;
+    }
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion
+
+  #region //// Classes ///////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class InputSystem: Disposable
+  {
+  
+    #region //// Classes ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    private class InputKey
+    {
+      public Keys Key = Keys.None;
+      public bool Pressed = false;
+      public double Countdown = RepeatDelay;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private class InputMouseButton
+    {
+      public MouseButton Button = MouseButton.None;
+      public bool Pressed = false;
+      public double Countdown = RepeatDelay;
+      
+      public InputMouseButton()
+      {
+      }
+      
+      public InputMouseButton(MouseButton button)
+      {
+        Button = button;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    private class InputMouse
+    {
+      public MouseState State = new MouseState();
+      public Point Position = new Point(0, 0);    
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private class InputGamePadButton
+    {
+      public GamePadButton Button = GamePadButton.None;
+      public bool Pressed = false;
+      public double Countdown = RepeatDelay;
+      
+      public InputGamePadButton()
+      {        
+      }
+      
+      public InputGamePadButton(GamePadButton button)
+      {
+        Button = button;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Consts ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private const int RepeatDelay = 500;
+    private const int RepeatRate = 50;
+    private float ClickThreshold = 0.5f;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    private List<InputKey> keys = new List<InputKey>();
+    private List<InputMouseButton> mouseButtons = new List<InputMouseButton>();
+    private List<InputGamePadButton> gamePadButtons = new List<InputGamePadButton>();        
+    private MouseState mouseState = new MouseState();
+    private GamePadState gamePadState = new GamePadState();    
+    private Manager manager = null;
+    private InputOffset inputOffset = new InputOffset(0, 0, 1.0f, 1.0f);
+    private InputMethods inputMethods = InputMethods.All;
+    private ActivePlayer activePlayer = ActivePlayer.None;       
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion   
+        
+    #region //// Properties ////////
+    
+    ////////////////////////////////////////////////////////////////////////////                
+    /// <summary>
+    /// Sets or gets input offset and ratio when rescaling controls in render target.
+    /// </summary>
+    public virtual InputOffset InputOffset
+    {
+      get { return inputOffset; }
+      set { inputOffset = value; }
+    }  
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////                
+    /// <summary>
+    /// Sets or gets input methods allowed for navigation.
+    /// </summary>
+    public virtual InputMethods InputMethods
+    {
+      get { return inputMethods; }
+      set { inputMethods = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual ActivePlayer ActivePlayer
+    {
+      get { return activePlayer; }
+      set { activePlayer = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////		        
+    public event KeyEventHandler KeyDown;
+    public event KeyEventHandler KeyPress;
+    public event KeyEventHandler KeyUp;    
+        
+    public event MouseEventHandler MouseDown;
+    public event MouseEventHandler MousePress;
+    public event MouseEventHandler MouseUp;        
+    public event MouseEventHandler MouseMove; 
+    /// <summary>
+    /// Occurs when the mouse is scrolled.
+    /// </summary>
+    public event MouseEventHandler MouseScroll;
+    
+    public event GamePadEventHandler GamePadUp;
+    public event GamePadEventHandler GamePadDown;
+    public event GamePadEventHandler GamePadPress;
+    public event GamePadEventHandler GamePadMove;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public InputSystem(Manager manager, InputOffset offset)
+    {
+      this.inputOffset = offset;
+      this.manager = manager;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public InputSystem(Manager manager): this(manager, new InputOffset(0, 0, 1.0f, 1.0f))
+    {          
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void Initialize()
+    {
+      keys.Clear();
+      mouseButtons.Clear();
+      gamePadButtons.Clear();      
+      
+      #if (!XBOX && !XBOX_FAKE)      
+        foreach (string str in Enum.GetNames(typeof(Keys)))
+        {
+          InputKey key = new InputKey();
+          key.Key = (Keys)Enum.Parse(typeof(Keys), str);
+          keys.Add(key);
+        }
+              
+        foreach (string str in Enum.GetNames(typeof(MouseButton)))
+        {
+          InputMouseButton btn = new InputMouseButton();
+          btn.Button = (MouseButton)Enum.Parse(typeof(MouseButton), str);
+          mouseButtons.Add(btn);
+        }     
+              
+        foreach (string str in Enum.GetNames(typeof(GamePadButton)))
+        {
+          InputGamePadButton btn = new InputGamePadButton();
+          btn.Button = (GamePadButton)Enum.Parse(typeof(GamePadButton), str);
+          gamePadButtons.Add(btn);
+        }     
+      #else             
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.None));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.Start));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.Back));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.Up));        
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.Down));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.Left));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.Right));       
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.A));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.B));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.X));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.Y));         
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.BigButton)); 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.LeftShoulder)); 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.RightShoulder)); 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.LeftTrigger)); 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.RightTrigger));         
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.LeftStick)); 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.RightStick));         
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.LeftStickLeft));         
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.LeftStickRight));                 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.LeftStickUp));
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.LeftStickDown));                         
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.RightStickLeft));                 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.RightStickRight));                 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.RightStickUp));                 
+        gamePadButtons.Add(new InputGamePadButton(GamePadButton.RightStickDown));                 
+      #endif        
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void SendMouseState(MouseState state, GameTime gameTime)
+    {
+      UpdateMouse(state, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void SendKeyboardState(KeyboardState state, GameTime gameTime)
+    {
+      UpdateKeys(state, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void SendGamePadState(PlayerIndex playerIndex, GamePadState state, GameTime gameTime)
+    {
+      UpdateGamePad(playerIndex, state, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void Update(GameTime gameTime)
+    {
+      if (manager.UseGuide && Guide.IsVisible) return;
+      
+      #if (!XBOX && !XBOX_FAKE)
+        MouseState ms = Mouse.GetState();
+        KeyboardState ks = Keyboard.GetState();      
+      #endif  
+            
+          
+      
+      {
+        #if (!XBOX && !XBOX_FAKE)
+          if ((inputMethods & InputMethods.Mouse) == InputMethods.Mouse) UpdateMouse(ms, gameTime);
+          if ((inputMethods & InputMethods.Keyboard) == InputMethods.Keyboard) UpdateKeys(ks, gameTime);                    
+        #endif  
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private ButtonState GetVectorState(GamePadButton button, GamePadState state)
+    {
+      ButtonState ret = ButtonState.Released;
+      bool down = false;
+      float t = ClickThreshold;
+      
+      switch (button)
+      {
+        case GamePadButton.LeftStickLeft: down = state.ThumbSticks.Left.X < -t; break;
+        case GamePadButton.LeftStickRight: down = state.ThumbSticks.Left.X > t; break;
+        case GamePadButton.LeftStickUp: down = state.ThumbSticks.Left.Y > t; break;
+        case GamePadButton.LeftStickDown: down = state.ThumbSticks.Left.Y < -t; break;
+
+        case GamePadButton.RightStickLeft: down = state.ThumbSticks.Right.X < -t; break;
+        case GamePadButton.RightStickRight: down = state.ThumbSticks.Right.X > t; break;
+        case GamePadButton.RightStickUp: down = state.ThumbSticks.Right.Y > t; break;
+        case GamePadButton.RightStickDown: down = state.ThumbSticks.Right.Y < -t; break;      
+        
+        case GamePadButton.LeftTrigger: down = state.Triggers.Left > t; break;
+        case GamePadButton.RightTrigger: down = state.Triggers.Right > t; break;
+      }
+      
+      ret = down ? ButtonState.Pressed : ButtonState.Released;
+            
+      return ret;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void UpdateGamePad(PlayerIndex playerIndex, GamePadState state, GameTime gameTime)
+    {          
+      GamePadEventArgs e = new GamePadEventArgs(playerIndex);      
+      
+      if (state.ThumbSticks.Left != gamePadState.ThumbSticks.Left ||
+          state.ThumbSticks.Right != gamePadState.ThumbSticks.Right ||
+          state.Triggers.Left != gamePadState.Triggers.Left ||
+          state.Triggers.Right != gamePadState.Triggers.Right)
+      {
+        BuildGamePadEvent(state, GamePadButton.None, ref e);
+        if (GamePadMove != null) GamePadMove.Invoke(this, e);        
+      }           
+
+      foreach (InputGamePadButton btn in gamePadButtons)
+      {
+        ButtonState bs = ButtonState.Released;
+
+        if (btn.Button == GamePadButton.None) continue;
+        else if (btn.Button == GamePadButton.A) bs = state.Buttons.A;
+        else if (btn.Button == GamePadButton.B) bs = state.Buttons.B;
+        else if (btn.Button == GamePadButton.Back) bs = state.Buttons.Back;
+        else if (btn.Button == GamePadButton.Down) bs = state.DPad.Down;
+        else if (btn.Button == GamePadButton.Left) bs = state.DPad.Left;
+        else if (btn.Button == GamePadButton.Right) bs = state.DPad.Right;
+        else if (btn.Button == GamePadButton.Start) bs = state.Buttons.Start;
+        else if (btn.Button == GamePadButton.Up) bs = state.DPad.Up;
+        else if (btn.Button == GamePadButton.X) bs = state.Buttons.X;
+        else if (btn.Button == GamePadButton.Y) bs = state.Buttons.Y;
+        else if (btn.Button == GamePadButton.BigButton) bs = state.Buttons.BigButton;
+        else if (btn.Button == GamePadButton.LeftShoulder) bs = state.Buttons.LeftShoulder;
+        else if (btn.Button == GamePadButton.RightShoulder) bs = state.Buttons.RightShoulder;
+        else if (btn.Button == GamePadButton.LeftStick) bs = state.Buttons.LeftStick;
+        else if (btn.Button == GamePadButton.RightStick) bs = state.Buttons.RightStick;                        
+        else bs = GetVectorState(btn.Button, state);
+        
+        bool pressed = (bs == ButtonState.Pressed);
+        if (pressed)
+        {
+          double ms = gameTime.ElapsedGameTime.TotalMilliseconds;          
+          if (pressed) btn.Countdown -= ms;
+        }
+
+        if ((pressed) && (!btn.Pressed))
+        {
+          btn.Pressed = true;
+          BuildGamePadEvent(state, btn.Button, ref e);
+
+          if (GamePadDown != null) GamePadDown.Invoke(this, e);
+          if (GamePadPress != null) GamePadPress.Invoke(this, e);
+        }
+        else if ((!pressed) && (btn.Pressed))
+        {
+          btn.Pressed = false;
+          btn.Countdown = RepeatDelay;
+          BuildGamePadEvent(state, btn.Button, ref e);
+
+          if (GamePadUp != null) GamePadUp.Invoke(this, e);
+        }
+        else if (btn.Pressed && btn.Countdown < 0)
+        {
+          e.Button = btn.Button;
+          btn.Countdown = RepeatRate;          
+          BuildGamePadEvent(state, btn.Button, ref e);
+
+          if (GamePadPress != null) GamePadPress.Invoke(this, e);          
+        }
+      }    
+      gamePadState = state;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void BuildGamePadEvent(GamePadState state, GamePadButton button, ref GamePadEventArgs e)
+    {      
+      e.State = state;
+      e.Button = button;   
+      e.Vectors.LeftStick = new Vector2(state.ThumbSticks.Left.X, state.ThumbSticks.Left.Y);
+      e.Vectors.RightStick = new Vector2(state.ThumbSticks.Right.X, state.ThumbSticks.Right.Y);
+      e.Vectors.LeftTrigger = state.Triggers.Left;
+      e.Vectors.RightTrigger = state.Triggers.Right;
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+    
+    ////////////////////////////////////////////////////////////////////////////
+    private void UpdateKeys(KeyboardState state, GameTime gameTime)
+    {            
+      #if (!XBOX && !XBOX_FAKE)
+      
+      KeyEventArgs e = new KeyEventArgs();
+      
+      e.Caps = (((ushort)NativeMethods.GetKeyState(0x14)) & 0xffff) != 0;      
+      
+      foreach (Keys key in state.GetPressedKeys())
+      {
+        if (key == Keys.LeftAlt || key == Keys.RightAlt) e.Alt = true;
+        else if (key == Keys.LeftShift || key == Keys.RightShift) e.Shift = true;
+        else if (key == Keys.LeftControl || key == Keys.RightControl) e.Control = true;        
+      }        
+
+      foreach (InputKey key in keys)
+      {
+        if (key.Key == Keys.LeftAlt || key.Key == Keys.RightAlt ||
+            key.Key == Keys.LeftShift || key.Key == Keys.RightShift ||
+            key.Key == Keys.LeftControl || key.Key == Keys.RightControl)
+        {
+          continue;
+        }
+
+        bool pressed = state.IsKeyDown(key.Key);
+
+        double ms = gameTime.ElapsedGameTime.TotalMilliseconds;        
+        if (pressed) key.Countdown -= ms;        
+
+        if ((pressed) && (!key.Pressed))
+        {
+          key.Pressed = true;
+          e.Key = key.Key;     
+                                       
+          if (KeyDown != null) KeyDown.Invoke(this, e);
+          if (KeyPress != null) KeyPress.Invoke(this, e);
+        }
+        else if ((!pressed) && (key.Pressed))
+        {
+          key.Pressed = false;
+          key.Countdown = RepeatDelay;
+          e.Key = key.Key;
+          
+          if (KeyUp != null) KeyUp.Invoke(this, e);
+        }
+        else if (key.Pressed && key.Countdown < 0)
+        {
+          key.Countdown = RepeatRate;   
+          e.Key = key.Key;          
+          
+          if (KeyPress != null) KeyPress.Invoke(this, e);                 
+        }
+      }
+      #endif
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private Point RecalcPosition(Point pos)
+    {
+      return new Point((int)((pos.X - InputOffset.X) / InputOffset.RatioX), (int)((pos.Y - InputOffset.Y) / InputOffset.RatioY));
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    private void AdjustPosition(ref MouseEventArgs e)
+    {
+      Rectangle screen = manager.Game.Window.ClientBounds;
+
+      if (e.Position.X < 0) e.Position.X = 0;
+      if (e.Position.Y < 0) e.Position.Y = 0;
+      if (e.Position.X >= screen.Width) e.Position.X = screen.Width - 1;
+      if (e.Position.Y >= screen.Height) e.Position.Y = screen.Height - 1;            
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void BuildMouseEvent(MouseState state, MouseButton button, ref MouseEventArgs e)
+    {
+      e.State = state;      
+      e.Button = button;
+
+      e.Position = new Point(state.X, state.Y);                        
+      AdjustPosition(ref e);
+
+      e.Position = RecalcPosition(e.Position);      
+      e.State = new MouseState(e.Position.X, e.Position.Y, e.State.ScrollWheelValue, e.State.LeftButton, e.State.MiddleButton, e.State.RightButton, e.State.XButton1, e.State.XButton2);      
+      
+      Point pos = RecalcPosition(new Point(mouseState.X, mouseState.Y));                              
+      e.Difference = new Point(e.Position.X - pos.X, e.Position.Y - pos.Y);                              
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    private void BuildMouseEvent(MouseState state, MouseButton button, MouseScrollDirection direction, ref MouseEventArgs e)
+    {
+        BuildMouseEvent(state, button, ref e);
+
+        e.ScrollDirection = direction;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void UpdateMouse(MouseState state, GameTime gameTime)
+    {            
+      #if (!XBOX && !XBOX_FAKE)   
+      
+      if ((state.X != mouseState.X) || (state.Y != mouseState.Y))
+      {
+        MouseEventArgs e = new MouseEventArgs();          
+        
+        MouseButton btn = MouseButton.None;       
+        if (state.LeftButton == ButtonState.Pressed) btn = MouseButton.Left;
+        else if (state.RightButton == ButtonState.Pressed) btn = MouseButton.Right;
+        else if (state.MiddleButton == ButtonState.Pressed) btn = MouseButton.Middle;
+        else if (state.XButton1 == ButtonState.Pressed) btn = MouseButton.XButton1;
+        else if (state.XButton2 == ButtonState.Pressed) btn = MouseButton.XButton2;
+        
+        BuildMouseEvent(state, btn, ref e);
+        if (MouseMove != null) 
+        {
+          MouseMove.Invoke(this, e);
+        }  
+      }
+
+      // Mouse wheel position changed
+      if (state.ScrollWheelValue != mouseState.ScrollWheelValue)
+      {
+          MouseEventArgs e = new MouseEventArgs();
+          MouseScrollDirection direction = state.ScrollWheelValue < mouseState.ScrollWheelValue ? MouseScrollDirection.Down : MouseScrollDirection.Up;
+
+          BuildMouseEvent(state, MouseButton.None, direction, ref e);
+
+          if (MouseScroll != null)
+          {
+              MouseScroll.Invoke(this, e);
+          }
+      }
+      
+      UpdateButtons(state, gameTime);    
+      
+      mouseState = state;
+      
+      #endif
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void UpdateButtons(MouseState state, GameTime gameTime)
+    {          
+      #if (!XBOX && !XBOX_FAKE)      
+
+      MouseEventArgs e = new MouseEventArgs();
+
+      foreach (InputMouseButton btn in mouseButtons)
+      {      
+        ButtonState bs = ButtonState.Released;
+        
+        if (btn.Button == MouseButton.Left) bs = state.LeftButton;
+        else if (btn.Button == MouseButton.Right) bs = state.RightButton;
+        else if (btn.Button == MouseButton.Middle) bs = state.MiddleButton;
+        else if (btn.Button == MouseButton.XButton1) bs = state.XButton1;
+        else if (btn.Button == MouseButton.XButton2) bs = state.XButton2;
+        else continue;
+      
+        bool pressed = (bs == ButtonState.Pressed);                
+        if (pressed)
+        {
+          double ms = gameTime.ElapsedGameTime.TotalMilliseconds;          
+          if (pressed) btn.Countdown -= ms;
+        } 
+
+        if ((pressed) && (!btn.Pressed))
+        {
+          btn.Pressed = true;                    
+          BuildMouseEvent(state, btn.Button, ref e);
+          
+          if (MouseDown != null) MouseDown.Invoke(this, e);
+          if (MousePress != null) MousePress.Invoke(this, e);          
+        }
+        else if ((!pressed) && (btn.Pressed))
+        {
+          btn.Pressed = false;
+          btn.Countdown = RepeatDelay;
+          BuildMouseEvent(state, btn.Button, ref e);
+
+          if (MouseUp != null) MouseUp.Invoke(this, e);
+        }
+        else if (btn.Pressed && btn.Countdown < 0)
+        {
+          e.Button = btn.Button;
+          btn.Countdown = RepeatRate;
+          BuildMouseEvent(state, btn.Button, ref e);
+          
+          if (MousePress != null) MousePress.Invoke(this, e);          
+        }
+      }      
+      
+      #endif
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+  } 
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion
+  
+}

Neoforce/KeyboardLayout.cs

@@ -0,0 +1,461 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: KeyboardLayout.cs                            //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+/*****
+ * Made Changes to the German Input, based on Kergos, input.
+ *****/
+
+#region //// Using /////////////
+        
+//////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework.Input;
+using System.Globalization;
+using System.Collections.Generic;
+using System;
+using System.Text;
+//////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+
+namespace TomShane.Neoforce.Controls
+{     
+		
+	public class KeyboardLayout
+	{    
+        
+    #region //// Fields ////////////
+                
+    //////////////////////////////////////////////////////////////////////////            
+    private string name = "English";  
+    public List<int> LayoutList = new List<int>();
+    //////////////////////////////////////////////////////////////////////////    
+   
+    #endregion                
+    
+    #region //// Properties ////////
+	  
+	  //////////////////////////////////////////////////////////////////////////	  
+    public virtual string Name
+    {
+      get { return name; }
+      set { name = value; }
+    }    
+	  //////////////////////////////////////////////////////////////////////////
+	  
+	  #endregion        
+	  
+    #region //// Constructors //////
+        
+	  //////////////////////////////////////////////////////////////////////////
+    public KeyboardLayout()
+    {          
+      LayoutList.Add(1033);
+    }
+    //////////////////////////////////////////////////////////////////////////
+    
+    #endregion      	  
+        
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual string GetKey(KeyEventArgs args)
+    {
+      string ret = "";
+      
+      if (args.Caps && !args.Shift) ret = KeyToString(args).ToUpper();
+      else if (!args.Caps && args.Shift) ret = KeyToString(args).ToUpper();
+      else if (args.Caps && args.Shift) ret = KeyToString(args).ToLower();
+      else if (!args.Caps && !args.Shift) ret = KeyToString(args).ToLower();
+      
+      
+      return ret;
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    ////////////////////////////////////////////////////////////////////////////    
+    protected virtual string KeyToString(KeyEventArgs args)
+    {
+      switch (args.Key)
+      {
+        case Keys.A:
+          return "a";        
+        case Keys.B:
+          return "b";
+        case Keys.C:
+          return "c";
+        case Keys.D:
+          return "d";
+        case Keys.E:
+          return "e";
+        case Keys.F:
+          return "f";
+        case Keys.G:
+          return "g";
+        case Keys.H:
+          return "h";
+        case Keys.I:
+          return "i";
+        case Keys.J:
+          return "j";
+        case Keys.K:
+          return "k";
+        case Keys.L:
+          return "l";
+        case Keys.M:
+          return "m";
+        case Keys.N:
+          return "n";
+        case Keys.O:
+          return "o";
+        case Keys.P:
+          return "p";
+        case Keys.Q:
+          return "q";
+        case Keys.R:
+          return "r";
+        case Keys.S:
+          return "s";
+        case Keys.T:
+          return "t";
+        case Keys.U:
+          return "u";
+        case Keys.V:
+          return "v";
+        case Keys.W:
+          return "w";
+        case Keys.X:
+          return "x";
+        case Keys.Y:
+          return "y";
+        case Keys.Z:
+          return "z";
+
+        case Keys.D0:
+          return (args.Shift) ? ")" : "0";
+        case Keys.D1:
+          return (args.Shift) ? "!" : "1";
+        case Keys.D2:
+          return (args.Shift) ? "@" : "2";
+        case Keys.D3:
+          return (args.Shift) ? "#" : "3";
+        case Keys.D4:
+          return (args.Shift) ? "$" : "4";
+        case Keys.D5:
+          return (args.Shift) ? "%" : "5";
+        case Keys.D6:
+          return (args.Shift) ? "^" : "6";
+        case Keys.D7:
+          return (args.Shift) ? "&" : "7";
+        case Keys.D8:
+          return (args.Shift) ? "*" : "8";          
+        case Keys.D9:
+          return (args.Shift) ? "(" : "9";
+
+        case Keys.OemPlus:
+          return (args.Shift) ? "+" : "=";
+        case Keys.OemMinus:
+          return (args.Shift) ? "_" : "-";
+        case Keys.OemOpenBrackets:
+          return (args.Shift) ? "{" : "[";
+        case Keys.OemCloseBrackets:
+          return (args.Shift) ? "}" : "]";
+        case Keys.OemQuestion:
+          return (args.Shift) ? "?" : "/";
+        case Keys.OemPeriod:
+          return (args.Shift) ? ">" : ".";
+        case Keys.OemComma:
+          return (args.Shift) ? "<" : ",";
+        case Keys.OemPipe:
+          return (args.Shift) ? "|" : "\\";
+        case Keys.Space:
+          return " ";
+        case Keys.OemSemicolon:
+          return (args.Shift) ? ":" : ";";
+        case Keys.OemQuotes:
+          return (args.Shift) ? "\"" : "'";
+        case Keys.OemTilde:
+          return (args.Shift) ? "~" : "`";
+
+        case Keys.NumPad0:
+          return (args.Shift) ? "" : "0";
+        case Keys.NumPad1:
+          return (args.Shift) ? "" : "1";
+        case Keys.NumPad2:
+          return (args.Shift) ? "" : "2";
+        case Keys.NumPad3:
+          return (args.Shift) ? "" : "3";
+        case Keys.NumPad4:
+          return (args.Shift) ? "" : "4";
+        case Keys.NumPad5:
+          return (args.Shift) ? "" : "5";
+        case Keys.NumPad6:
+          return (args.Shift) ? "" : "6";
+        case Keys.NumPad7:
+          return (args.Shift) ? "" : "7";
+        case Keys.NumPad8:
+          return (args.Shift) ? "" : "8";
+        case Keys.NumPad9:
+          return (args.Shift) ? "" : "9";
+        case Keys.Decimal:
+          return (args.Shift) ? "" : ".";
+
+        case Keys.Divide:
+          return (args.Shift) ? "/" : "/";
+        case Keys.Multiply:
+          return (args.Shift) ? "*" : "*";
+        case Keys.Subtract:
+          return (args.Shift) ? "-" : "-";
+        case Keys.Add:
+          return (args.Shift) ? "+" : "+";
+          
+        default:
+          return "";
+      }           
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+	  
+  }
+
+  public class CzechKeyboardLayout: KeyboardLayout
+  {
+
+    #region //// Constructors //////
+
+    //////////////////////////////////////////////////////////////////////////
+    public CzechKeyboardLayout()
+    {
+        Name = "Czech";
+        LayoutList.Clear();
+        LayoutList.Add(1029);
+    }
+    //////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    protected override string KeyToString(KeyEventArgs args)
+    {                            
+      switch (args.Key)
+      {        
+        case Keys.D0:
+          return (args.Shift) ? "0" : "<22>";
+        case Keys.D1:
+          return (args.Shift) ? "1" : "+";
+        case Keys.D2:
+          return (args.Shift) ? "2" : "<22>";
+        case Keys.D3:
+          return (args.Shift) ? "3" : "<22>";
+        case Keys.D4:
+          return (args.Shift) ? "4" : "<22>";
+        case Keys.D5:
+          return (args.Shift) ? "5" : "<22>";
+        case Keys.D6:
+          return (args.Shift) ? "6" : "<22>";
+        case Keys.D7:
+          return (args.Shift) ? "7" : "<22>";
+        case Keys.D8:
+          return (args.Shift) ? "8" : "<22>";
+        case Keys.D9:
+          return (args.Shift) ? "9" : "<22>";
+
+        case Keys.OemPlus:
+          return (args.Shift) ? "<22>" : "<22>";
+        case Keys.OemMinus:
+          return (args.Shift) ? "%" : "=";
+        case Keys.OemOpenBrackets:
+          return (args.Shift) ? "/" : "<22>";
+        case Keys.OemCloseBrackets:
+          return (args.Shift) ? "(" : ")";
+        case Keys.OemQuestion:
+          return (args.Shift) ? "_" : "-";
+        case Keys.OemPeriod:
+          return (args.Shift) ? ":" : ".";
+        case Keys.OemComma:
+          return (args.Shift) ? "?" : ",";
+        case Keys.OemPipe:
+          return (args.Shift) ? "'" : "<22>";
+        case Keys.Space:
+          return " ";
+        case Keys.OemSemicolon:
+          return (args.Shift) ? "\"" : "<22>";
+        case Keys.OemQuotes:
+          return (args.Shift) ? "!" : "<22>";
+        case Keys.OemTilde:
+          return (args.Shift) ? "<22>" : ";";
+        
+        case Keys.Decimal:
+          return (args.Shift) ? "" : ",";
+
+        default:
+          return base.KeyToString(args);
+      }            
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+  }
+
+  public class GermanKeyboardLayout : KeyboardLayout
+  {
+
+    #region //// Constructors //////
+
+    //////////////////////////////////////////////////////////////////////////
+    public GermanKeyboardLayout()
+    {
+      Name = "German";
+      LayoutList.Clear();
+      LayoutList.Add(1031);
+    }
+    //////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    protected override string KeyToString(KeyEventArgs args)
+    {
+      switch (args.Key)
+      {
+        case Keys.D0:
+          return (args.Shift) ? "=" : "0";
+        case Keys.D1:
+          return (args.Shift) ? "!" : "1";
+        case Keys.D2:
+          return (args.Shift) ? "\"": "2";
+        case Keys.D3:
+          return (args.Shift) ? "<22>" : "3";
+        case Keys.D4:
+          return (args.Shift) ? "$" : "4";
+        case Keys.D5:
+          return (args.Shift) ? "%" : "5";
+        case Keys.D6:
+          return (args.Shift) ? "&" : "6";
+        case Keys.D7:
+          return (args.Shift) ? "/" : "7";
+        case Keys.D8:
+          return (args.Shift) ? "(" : "8";
+        case Keys.D9:
+          return (args.Shift) ? ")" : "9";
+        case Keys.OemBackslash:
+          return (args.Shift) ? ">" : "<";
+        case Keys.OemPlus:
+          return (args.Shift) ? "*" : "+";
+        case Keys.OemMinus:
+          return (args.Shift) ? "_" : "-";
+        case Keys.OemOpenBrackets:
+          return (args.Shift) ? "?" : "<22>";
+        case Keys.OemCloseBrackets:
+          return (args.Shift) ? "`" : "<22>";
+        case Keys.OemQuestion:
+          return (args.Shift) ? "'" : "#";
+        case Keys.OemPeriod:
+          return (args.Shift) ? ":" : ".";
+        case Keys.OemComma:
+          return (args.Shift) ? ";" : ",";
+        case Keys.OemPipe:
+          return (args.Shift) ? "<22>" : "^";
+        case Keys.Space:
+          return " ";
+        case Keys.OemSemicolon:
+          return (args.Shift) ? "<22>" : "<22>";
+        case Keys.OemQuotes:
+          return (args.Shift) ? "<22>" : "<22>";
+        case Keys.OemTilde:
+          return (args.Shift) ? "<22>" : "<22>";
+          
+        case Keys.Decimal:
+          return (args.Shift) ? "" : ".";
+
+        default:
+          return base.KeyToString(args);
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+ 
+   
+  #endregion
+  
+  }
+
+  public class PolishKeyboardLayout: KeyboardLayout
+  {
+
+    #region //// Constructors //////
+    //////////////////////////////////////////////////////////////////////////
+    public PolishKeyboardLayout()
+    {
+      Name = "Polish"; 
+      LayoutList.Clear();
+      LayoutList.Add(1045);
+    }
+    //////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override string KeyToString(KeyEventArgs args)
+    {     
+      if (args.Alt)
+      {
+        switch (args.Key)
+        {
+          case Keys.A:
+            return (args.Shift) ? "<22>" : "<22>";
+          case Keys.C:
+            return (args.Shift) ? "<22>" : "<22>";
+          case Keys.E:
+            return (args.Shift) ? "<22>" : "<22>";
+          case Keys.L:
+            return (args.Shift) ? "<22>" : "<22>";
+          case Keys.N:
+            return (args.Shift) ? "<22>" : "<22>";
+          case Keys.O:
+            return (args.Shift) ? "<22>" : "<22>";
+          case Keys.S:
+            return (args.Shift) ? "<22>" : "<22>";
+          case Keys.X:
+            return (args.Shift) ? "<22>" : "<22>";
+          case Keys.Z:
+            return (args.Shift) ? "<22>" : "<22>";
+        }
+      }
+      return base.KeyToString(args);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    #endregion
+  
+  }
+		
+}
+

Neoforce/Label.cs

@@ -0,0 +1,104 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Label.cs                                     //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public class Label: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////           
+    private Alignment alignment = Alignment.MiddleLeft;    
+    private bool ellipsis = true;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual Alignment Alignment 
+    { 
+      get { return alignment; } 
+      set { alignment = value; } 
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual bool Ellipsis 
+    {
+      get { return ellipsis; }
+      set { ellipsis = value; }       
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public Label(Manager manager): base(manager)
+    {      
+      CanFocus = false;    
+      Passive = true;    
+      Width = 64;
+      Height = 16;    
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+    
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public override void Init()
+    {
+      base.Init();            
+    }
+    ////////////////////////////////////////////////////////////////////////////           
+
+    ////////////////////////////////////////////////////////////////////////////   
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {      
+      //base.DrawControl(renderer, rect, gameTime);
+   
+      SkinLayer s = new SkinLayer(Skin.Layers[0]);
+      s.Text.Alignment = alignment;
+      renderer.DrawString(this, s, Text, rect, true, 0, 0, ellipsis);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+  }
+
+}

Neoforce/Layout.cs

@@ -0,0 +1,182 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Layout.cs                                    //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using Microsoft.Xna.Framework;
+using System.Xml;
+using System.Reflection;
+using System.IO;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+
+  public static class Layout
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                     
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Methods ///////////    
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public static Container Load(Manager manager, string asset)
+    {
+      Container win = null;
+      LayoutXmlDocument doc = new LayoutXmlDocument();
+      ArchiveManager content = new ArchiveManager(manager.Game.Services);            
+      
+      try
+      {      
+        content.RootDirectory = manager.LayoutDirectory;
+        
+        #if (!XBOX && !XBOX_FAKE)
+        
+        string file = content.RootDirectory + asset;
+        
+        if (File.Exists(file))
+        {
+          doc.Load(file);
+        }
+        else
+        
+        #endif
+        {
+          doc = content.Load<LayoutXmlDocument>(asset);
+        }  
+          
+        
+        if (doc != null && doc["Layout"]["Controls"] != null && doc["Layout"]["Controls"].HasChildNodes)
+        {       
+          XmlNode node = doc["Layout"]["Controls"].GetElementsByTagName("Control").Item(0);         
+          string cls = node.Attributes["Class"].Value;
+          Type type = Type.GetType(cls);
+          
+          if (type == null)
+          {
+            cls = "TomShane.Neoforce.Controls." + cls;
+            type = Type.GetType(cls);
+          }
+                    
+          win = (Container)LoadControl(manager, node, type, null);                    
+        }  
+        
+      }
+      finally
+      {
+        content.Dispose();
+      }                  
+      
+      return win;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private static Control LoadControl(Manager manager, XmlNode node, Type type, Control parent)
+    {
+      Control c = null;   
+      
+      Object[] args = new Object[] {manager};      
+      
+      c = (Control)type.InvokeMember(null, BindingFlags.CreateInstance, null, null, args);    
+      if (parent != null) c.Parent = parent;
+      c.Name = node.Attributes["Name"].Value;            
+      
+      if (node != null && node["Properties"] != null && node["Properties"].HasChildNodes)
+      {
+        LoadProperties(node["Properties"].GetElementsByTagName("Property"), c);
+      }  
+
+      if (node != null && node["Controls"] != null && node["Controls"].HasChildNodes)
+      {
+        foreach (XmlElement e in node["Controls"].GetElementsByTagName("Control"))
+        {
+          string cls = e.Attributes["Class"].Value;
+          Type t = Type.GetType(cls);
+          
+          if (t == null)
+          {
+            cls = "TomShane.Neoforce.Controls." + cls;
+            t = Type.GetType(cls);
+          }
+          LoadControl(manager, e, t, c);
+        }
+      }                    
+      
+      return c;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private static void LoadProperties(XmlNodeList node, Control c)        
+    {
+      foreach (XmlElement e in node)
+      {
+        string name = e.Attributes["Name"].Value;
+        string val = e.Attributes["Value"].Value;
+        
+        PropertyInfo i = c.GetType().GetProperty(name);
+        
+        if (i != null)
+        {                                       
+          {  
+            try
+            {                          
+              i.SetValue(c, Convert.ChangeType(val, i.PropertyType, null), null);
+            }
+            catch
+            {              
+            }  
+          }  
+        }                              
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion  
+
+  }
+
+}

Neoforce/ListBox.cs

@@ -0,0 +1,485 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ListBox.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+    #region //// Classes ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ///  <include file='Documents/ListBox.xml' path='ListBox/Class[@name="ListBox"]/*' />          
+    public class ListBox : Control
+    {
+
+        #region //// Fields ////////////
+
+        ////////////////////////////////////////////////////////////////////////////                     
+        private List<object> items = new List<object>();
+        private ScrollBar sbVert = null;
+        private ClipBox pane = null;
+        private int itemIndex = -1;
+        private bool hotTrack = false;
+        private int itemsCount = 0;
+        private bool hideSelection = true;
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Properties ////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual List<object> Items
+        {
+            get { return items; }
+            internal set { items = value; }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual bool HotTrack
+        {
+            get { return hotTrack; }
+            set
+            {
+                if (hotTrack != value)
+                {
+                    hotTrack = value;
+                    if (!Suspended) OnHotTrackChanged(new EventArgs());
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual int ItemIndex
+        {
+            get { return itemIndex; }
+            set
+            {
+                //if (itemIndex != value)
+                {
+                    if (value >= 0 && value < items.Count)
+                    {
+                        itemIndex = value;
+                    }
+                    else
+                    {
+                        itemIndex = -1;
+                    }
+                    ScrollTo(itemIndex);
+
+                    if (!Suspended) OnItemIndexChanged(new EventArgs());
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual bool HideSelection
+        {
+            get { return hideSelection; }
+            set
+            {
+                if (hideSelection != value)
+                {
+                    hideSelection = value;
+                    Invalidate();
+                    if (!Suspended) OnHideSelectionChanged(new EventArgs());
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Events ////////////
+
+        ////////////////////////////////////////////////////////////////////////////                 
+        public event EventHandler HotTrackChanged;
+        public event EventHandler ItemIndexChanged;
+        public event EventHandler HideSelectionChanged;
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Construstors //////
+
+        ////////////////////////////////////////////////////////////////////////////       
+        public ListBox(Manager manager)
+            : base(manager)
+        {
+            Width = 64;
+            Height = 64;
+            MinimumHeight = 16;
+
+            sbVert = new ScrollBar(Manager, Orientation.Vertical);
+            sbVert.Init();
+            sbVert.Parent = this;
+            sbVert.Left = Left + Width - sbVert.Width - Skin.Layers["Control"].ContentMargins.Right;
+            sbVert.Top = Top + Skin.Layers["Control"].ContentMargins.Top;
+            sbVert.Height = Height - Skin.Layers["Control"].ContentMargins.Vertical;
+            sbVert.Anchor = Anchors.Top | Anchors.Right | Anchors.Bottom;
+            sbVert.PageSize = 25;
+            sbVert.Range = 1;
+            sbVert.PageSize = 1;
+            sbVert.StepSize = 10;
+
+            pane = new ClipBox(manager);
+            pane.Init();
+            pane.Parent = this;
+            pane.Top = Skin.Layers["Control"].ContentMargins.Top;
+            pane.Left = Skin.Layers["Control"].ContentMargins.Left;
+            pane.Width = Width - sbVert.Width - Skin.Layers["Control"].ContentMargins.Horizontal - 1;
+            pane.Height = Height - Skin.Layers["Control"].ContentMargins.Vertical;
+            pane.Anchor = Anchors.All;
+            pane.Passive = true;
+            pane.CanFocus = false;
+            pane.Draw += new DrawEventHandler(DrawPane);
+
+            CanFocus = true;
+            Passive = false;
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Methods ///////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public override void Init()
+        {
+            base.Init();
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void AutoHeight(int maxItems)
+        {
+            if (items != null && items.Count < maxItems) maxItems = items.Count;
+            if (maxItems < 3)
+            {
+                //maxItems = 3;
+                sbVert.Visible = false;
+                pane.Width = Width - Skin.Layers["Control"].ContentMargins.Horizontal - 1;
+            }
+            else
+            {
+                pane.Width = Width - sbVert.Width - Skin.Layers["Control"].ContentMargins.Horizontal - 1;
+                sbVert.Visible = true;
+            }
+
+            SkinText font = Skin.Layers["Control"].Text;
+            if (items != null && items.Count > 0)
+            {
+                int h = (int)font.Font.Resource.MeasureString(items[0].ToString()).Y;
+                Height = (h * maxItems) + (Skin.Layers["Control"].ContentMargins.Vertical);// - Skin.OriginMargins.Vertical);
+            }
+            else
+            {
+                Height = 32;
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        public override int MinimumHeight
+        {
+            get { return base.MinimumHeight; }
+            set
+            {
+                base.MinimumHeight = value;
+                if (this.sbVert != null) this.sbVert.MinimumHeight = value;
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+        {
+            sbVert.Invalidate();
+            pane.Invalidate();
+            //DrawPane(this, new DrawEventArgs(renderer, rect, gameTime));
+
+            base.DrawControl(renderer, rect, gameTime);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        private void DrawPane(object sender, DrawEventArgs e)
+        {
+            if (items != null && items.Count > 0)
+            {
+                SkinText font = Skin.Layers["Control"].Text;
+                SkinLayer sel = Skin.Layers["ListBox.Selection"];
+                int h = (int)font.Font.Resource.MeasureString(items[0].ToString()).Y;
+                int v = (sbVert.Value / 10);
+                int p = (sbVert.PageSize / 10);
+                int d = (int)(((sbVert.Value % 10) / 10f) * h);
+                int c = items.Count;
+                int s = itemIndex;
+
+                for (int i = v; i <= v + p + 1; i++)
+                {
+                    if (i < c)
+                    {
+                        e.Renderer.DrawString(this, Skin.Layers["Control"], items[i].ToString(), new Rectangle(e.Rectangle.Left, e.Rectangle.Top - d + ((i - v) * h), e.Rectangle.Width, h), false);
+                    }
+                }
+                if (s >= 0 && s < c && (Focused || !hideSelection))
+                {
+                    int pos = -d + ((s - v) * h);
+                    if (pos > -h && pos < (p + 1) * h)
+                    {
+                        e.Renderer.DrawLayer(this, sel, new Rectangle(e.Rectangle.Left, e.Rectangle.Top + pos, e.Rectangle.Width, h));
+                        e.Renderer.DrawString(this, sel, items[s].ToString(), new Rectangle(e.Rectangle.Left, e.Rectangle.Top + pos, e.Rectangle.Width, h), false);
+                    }
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override void OnMouseDown(MouseEventArgs e)
+        {
+            base.OnMouseDown(e);
+
+            if (e.Button == MouseButton.Left || e.Button == MouseButton.Right)
+            {
+                TrackItem(e.Position.X, e.Position.Y);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        private void TrackItem(int x, int y)
+        {
+            if (items != null && items.Count > 0 && (pane.ControlRect.Contains(new Point(x, y))))
+            {
+                SkinText font = Skin.Layers["Control"].Text;
+                int h = (int)font.Font.Resource.MeasureString(items[0].ToString()).Y;
+                int d = (int)(((sbVert.Value % 10) / 10f) * h);
+                int i = (int)Math.Floor((sbVert.Value / 10f) + ((float)y / h));
+                if (i >= 0 && i < Items.Count && i >= (int)Math.Floor((float)sbVert.Value / 10f) && i < (int)Math.Ceiling((float)(sbVert.Value + sbVert.PageSize) / 10f)) ItemIndex = i;
+                Focused = true;
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override void OnMouseMove(MouseEventArgs e)
+        {
+            base.OnMouseMove(e);
+
+            if (hotTrack)
+            {
+                TrackItem(e.Position.X, e.Position.Y);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override void OnKeyPress(KeyEventArgs e)
+        {
+            if (e.Key == Keys.Down)
+            {
+                e.Handled = true;
+                itemIndex += sbVert.StepSize / 10;
+            }
+            else if (e.Key == Keys.Up)
+            {
+                e.Handled = true;
+                itemIndex -= sbVert.StepSize / 10;
+            }
+            else if (e.Key == Keys.PageDown)
+            {
+                e.Handled = true;
+                itemIndex += sbVert.PageSize / 10;
+            }
+            else if (e.Key == Keys.PageUp)
+            {
+                e.Handled = true;
+                itemIndex -= sbVert.PageSize / 10;
+            }
+            else if (e.Key == Keys.Home)
+            {
+                e.Handled = true;
+                itemIndex = 0;
+            }
+            else if (e.Key == Keys.End)
+            {
+                e.Handled = true;
+                itemIndex = items.Count - 1;
+            }
+
+            if (itemIndex < 0) itemIndex = 0;
+            else if (itemIndex >= Items.Count) itemIndex = Items.Count - 1;
+
+            ItemIndex = itemIndex;
+
+            base.OnKeyPress(e);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Handles mouse scroll events for the list box.
+        /// </summary>
+        /// <param name="e"></param>
+        protected override void OnMouseScroll(MouseEventArgs e)
+        {
+            Focused = true;
+ 
+            if (e.ScrollDirection == MouseScrollDirection.Down)
+            {
+                e.Handled = true;
+                itemIndex += sbVert.StepSize / 10;
+            }
+            else if (e.ScrollDirection == MouseScrollDirection.Up)
+            {
+                e.Handled = true;
+                itemIndex -= sbVert.StepSize / 10;
+            }
+ 
+            // Wrap index in collection range.
+            if (itemIndex < 0) itemIndex = 0;
+            else if (itemIndex >= Items.Count) itemIndex = Items.Count - 1;
+ 
+            ItemIndex = itemIndex;
+ 
+            base.OnMouseScroll(e);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override void OnGamePadPress(GamePadEventArgs e)
+        {
+            if (e.Button == GamePadActions.Down)
+            {
+                e.Handled = true;
+                itemIndex += sbVert.StepSize / 10;
+            }
+            else if (e.Button == GamePadActions.Up)
+            {
+                e.Handled = true;
+                itemIndex -= sbVert.StepSize / 10;
+            }
+
+            if (itemIndex < 0) itemIndex = 0;
+            else if (itemIndex >= Items.Count) itemIndex = Items.Count - 1;
+
+            ItemIndex = itemIndex;
+            base.OnGamePadPress(e);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        private void ItemsChanged()
+        {
+            if (items != null && items.Count > 0)
+            {
+                SkinText font = Skin.Layers["Control"].Text;
+                int h = (int)font.Font.Resource.MeasureString(items[0].ToString()).Y;
+
+                int sizev = Height - Skin.Layers["Control"].ContentMargins.Vertical;
+                sbVert.Range = items.Count * 10;
+                sbVert.PageSize = (int)Math.Floor((float)sizev * 10 / h);
+                Invalidate();
+            }
+            else if (items == null || items.Count <= 0)
+            {
+                sbVert.Range = 1;
+                sbVert.PageSize = 1;
+                Invalidate();
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////    
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override void OnResize(ResizeEventArgs e)
+        {
+            base.OnResize(e);
+            ItemsChanged();
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void ScrollTo(int index)
+        {
+            ItemsChanged();
+            if ((index * 10) < sbVert.Value)
+            {
+                sbVert.Value = index * 10;
+            }
+            else if (index >= (int)Math.Floor(((float)sbVert.Value + sbVert.PageSize) / 10f))
+            {
+                sbVert.Value = ((index + 1) * 10) - sbVert.PageSize;
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected internal override void Update(GameTime gameTime)
+        {
+            base.Update(gameTime);
+
+            if (Visible && items != null && items.Count != itemsCount)
+            {
+                itemsCount = items.Count;
+                ItemsChanged();
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////     
+        protected virtual void OnItemIndexChanged(EventArgs e)
+        {
+            if (ItemIndexChanged != null) ItemIndexChanged.Invoke(this, e);
+        }
+        ////////////////////////////////////////////////////////////////////////////     
+
+        ////////////////////////////////////////////////////////////////////////////     
+        protected virtual void OnHotTrackChanged(EventArgs e)
+        {
+            if (HotTrackChanged != null) HotTrackChanged.Invoke(this, e);
+        }
+        ////////////////////////////////////////////////////////////////////////////  
+
+        ////////////////////////////////////////////////////////////////////////////     
+        protected virtual void OnHideSelectionChanged(EventArgs e)
+        {
+            if (HideSelectionChanged != null) HideSelectionChanged.Invoke(this, e);
+        }
+        ////////////////////////////////////////////////////////////////////////////       
+
+        #endregion
+
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+}

Neoforce/MainMenu.cs

@@ -0,0 +1,362 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: MainMenu.cs                                  //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+  public class MainMenu: MenuBase
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private Rectangle[] rs;
+    private int lastIndex = -1;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public MainMenu(Manager manager): base(manager)
+    {      
+      Left = 0;
+      Top = 0;
+      Height = 24;
+      Detached = false;
+      DoubleClicks = false;    
+      StayOnBack = true;  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Destructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void Dispose(bool disposing)
+    {
+      if (disposing)
+      {        
+      }
+      base.Dispose(disposing);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion   
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();      
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["MainMenu"]);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {                                          
+      SkinLayer l1 = Skin.Layers["Control"];
+      SkinLayer l2 = Skin.Layers["Selection"];
+      rs = new Rectangle[Items.Count];       
+
+      renderer.DrawLayer(this, l1, rect, ControlState.Enabled);
+      
+      int prev = l1.ContentMargins.Left;
+      for (int i = 0; i < Items.Count; i++)
+      {     
+        MenuItem mi = Items[i];
+
+        int tw = (int)l1.Text.Font.Resource.MeasureString(mi.Text).X + l1.ContentMargins.Horizontal;
+        rs[i] = new Rectangle(rect.Left + prev, rect.Top + l1.ContentMargins.Top, tw, Height - l1.ContentMargins.Vertical);
+        prev += tw;      
+        
+        if (ItemIndex != i)
+        {          
+          if (mi.Enabled && Enabled)
+          {             
+            renderer.DrawString(this, l1, mi.Text, rs[i], ControlState.Enabled, false);
+          }
+          else
+          {
+            renderer.DrawString(this, l1, mi.Text, rs[i], ControlState.Disabled, false);
+          }  
+        }
+        else
+        {
+          if (Items[i].Enabled && Enabled)
+          {      
+            renderer.DrawLayer(this, l2, rs[i], ControlState.Enabled);
+            renderer.DrawString(this, l2, mi.Text, rs[i], ControlState.Enabled, false);           
+          }  
+          else
+          {
+            renderer.DrawLayer(this, l2, rs[i], ControlState.Disabled);
+            renderer.DrawString(this, l2, mi.Text, rs[i], ControlState.Disabled, false);  
+          }
+        }  
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void TrackItem(int x, int y)
+    {          
+      if (Items != null && Items.Count > 0 && rs != null)
+      {
+        Invalidate();
+        for (int i = 0; i < rs.Length; i++)
+        {
+          if (rs[i].Contains(x, y))
+          {
+            if (i >= 0 && i != ItemIndex)
+            {
+              Items[i].SelectedInvoke(new EventArgs());              
+            } 
+            ItemIndex = i;        
+            return;
+          }
+        }
+        if (ChildMenu == null) ItemIndex = -1;        
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private bool CheckArea(int x, int y)
+    {
+      return true;       
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+      base.OnMouseMove(e);
+      int i = lastIndex;      
+                  
+      TrackItem(e.State.X - Root.AbsoluteLeft, e.State.Y - Root.AbsoluteTop);
+
+      if (ItemIndex >= 0 && (i == -1 || i != ItemIndex) && Items[ItemIndex].Items != null && Items[ItemIndex].Items.Count > 0 && ChildMenu != null)
+      {                               
+        HideSubMenu();
+        lastIndex = ItemIndex; 
+        OnClick(e);          
+      }
+      else if (ChildMenu != null && i != ItemIndex)
+      {                 
+         HideSubMenu();
+         Focused = true;             
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////   
+    protected override void OnMouseDown(MouseEventArgs e)
+    {
+      base.OnMouseDown(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////   
+    protected override void OnMouseOut(MouseEventArgs e)
+    {
+      base.OnMouseOut(e);
+      
+      OnMouseMove(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+  
+    ////////////////////////////////////////////////////////////////////////////   
+    private void HideSubMenu()
+    {
+      if (ChildMenu != null)
+      {
+        (ChildMenu as ContextMenu).HideMenu(true);
+        ChildMenu.Dispose();
+        ChildMenu = null;
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public virtual void HideMenu()
+    {
+      if (ChildMenu != null)
+      {
+        (ChildMenu as ContextMenu).HideMenu(true);
+        ChildMenu.Dispose();
+        ChildMenu = null;
+      }
+      if (Manager.FocusedControl is MenuBase) Focused = true;
+      Invalidate();
+      ItemIndex = -1;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnClick(EventArgs e)
+    {      
+      base.OnClick(e);
+
+      MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs)e : new MouseEventArgs();
+      
+      if (ex.Button == MouseButton.Left || ex.Button == MouseButton.None)
+      {
+        if (ItemIndex >= 0 && Items[ItemIndex].Enabled)
+        {
+          if (ItemIndex >= 0 && Items[ItemIndex].Items != null && Items[ItemIndex].Items.Count > 0)
+          {
+            if (ChildMenu != null)
+            {
+              ChildMenu.Dispose();
+              ChildMenu = null;
+            }
+            ChildMenu = new ContextMenu(Manager);
+            (ChildMenu as ContextMenu).RootMenu = this;
+            (ChildMenu as ContextMenu).ParentMenu = this;
+            (ChildMenu as ContextMenu).Sender = this.Root;
+            ChildMenu.Items.AddRange(Items[ItemIndex].Items);                
+
+            int y = Root.AbsoluteTop + rs[ItemIndex].Bottom + 1;
+            (ChildMenu as ContextMenu).Show(this.Root, Root.AbsoluteLeft + rs[ItemIndex].Left, y);
+            if (ex.Button == MouseButton.None) (ChildMenu as ContextMenu).ItemIndex = 0;            
+          }        
+          else
+          {
+            if (ItemIndex >= 0)
+            {
+              Items[ItemIndex].ClickInvoke(ex);
+            }
+          }
+        }
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnKeyPress(KeyEventArgs e)
+    {
+      base.OnKeyPress(e);      
+
+      if (e.Key == Keys.Right)
+      {
+        ItemIndex += 1;
+        e.Handled = true;
+      }
+      if (e.Key == Keys.Left)
+      {
+        ItemIndex -= 1;
+        e.Handled = true;
+      } 
+
+      if (ItemIndex > Items.Count - 1) ItemIndex = 0;
+      if (ItemIndex < 0) ItemIndex = Items.Count - 1;
+
+      if (e.Key == Keys.Down && Items.Count > 0 && Items[ItemIndex].Items.Count > 0)
+      {
+        e.Handled = true;
+        OnClick(new MouseEventArgs(new MouseState(), MouseButton.None, Point.Zero));        
+      }  
+      if (e.Key == Keys.Escape)
+      {
+        e.Handled = true;
+        ItemIndex = -1;
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnGamePadPress(GamePadEventArgs e)
+    {
+      base.OnGamePadPress(e);
+
+      if (e.Button == GamePadActions.Right)
+      {
+        ItemIndex += 1;
+        e.Handled = true;
+      }
+      if (e.Button == GamePadActions.Left)
+      {
+        ItemIndex -= 1;
+        e.Handled = true;
+      }
+
+      if (ItemIndex > Items.Count - 1) ItemIndex = 0;
+      if (ItemIndex < 0) ItemIndex = Items.Count - 1;
+
+      if (e.Button == GamePadActions.Down && Items[ItemIndex].Items.Count > 0)
+      {
+        e.Handled = true;
+        OnClick(new MouseEventArgs(new MouseState(), MouseButton.None, Point.Zero));
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnFocusGained(EventArgs e)
+    {
+      base.OnFocusGained(e);  
+      if (ItemIndex < 0 && Items.Count > 0) ItemIndex = 0;    
+    }    
+    ////////////////////////////////////////////////////////////////////////////    
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    protected override void OnFocusLost(EventArgs e)
+    {
+      base.OnFocusLost(e);
+      if (ChildMenu == null || !ChildMenu.Visible) ItemIndex = -1;
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+      
+    #endregion  
+
+  }
+
+}

Neoforce/MenuBase.cs

@@ -0,0 +1,141 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: MenuBase.cs                                  //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+  public class MenuItem: Unknown
+  {    
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public string Text = "MenuItem";
+    public List<MenuItem> Items = new List<MenuItem>();
+    public bool Separated = false;     
+    public Texture2D Image = null;
+    public bool Enabled = true;
+    public object Tag { get; set; }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public MenuItem()
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public MenuItem(string text): this()
+    {
+      Text = text;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public MenuItem(string text, bool separated): this(text)
+    {      
+      Separated = separated;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public event EventHandler Click;
+    public event EventHandler Selected;
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    internal void ClickInvoke(EventArgs e)
+    {
+      if (Click != null) Click.Invoke(this, e);
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    internal void SelectedInvoke(EventArgs e)
+    {
+      if (Selected != null) Selected.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+  } 
+
+  public abstract class MenuBase: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private int itemIndex = -1;
+    private List<MenuItem> items = new List<MenuItem>();
+    private MenuBase childMenu = null;   
+    private MenuBase rootMenu = null;
+    private MenuBase parentMenu = null;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal int ItemIndex { get { return itemIndex; } set { itemIndex = value; } }
+    protected internal MenuBase ChildMenu { get { return childMenu; } set { childMenu = value; } }
+    protected internal MenuBase RootMenu { get { return rootMenu; } set { rootMenu = value; } }
+    protected internal MenuBase ParentMenu { get { return parentMenu; } set { parentMenu = value; } }    
+    public List<MenuItem> Items { get { return items; } }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public MenuBase(Manager manager): base(manager)
+    {            
+      rootMenu = this;            
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+        
+  }
+
+}

Neoforce/ModalContainer.cs

@@ -0,0 +1,194 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ModalContainer.cs                            //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+   
+  public class ModalContainer: Container
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private ModalResult modalResult = ModalResult.None;
+    private ModalContainer lastModal = null; 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override bool Visible
+    {
+      get
+      {
+        return base.Visible;
+      }
+      set
+      {
+        if (value) Focused = true;
+        base.Visible = value;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual bool IsModal
+    {
+      get { return Manager.ModalWindow == this; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual ModalResult ModalResult
+    {
+      get
+      {
+        return modalResult;
+      }
+      set
+      {
+        modalResult = value;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public event WindowClosingEventHandler Closing;
+    public event WindowClosedEventHandler Closed;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+  
+    #region //// Consructors ///////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public ModalContainer(Manager manager): base(manager)
+    {      
+      Manager.Input.GamePadDown += new GamePadEventHandler(Input_GamePadDown);
+      GamePadActions = new WindowGamePadActions();
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion 
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void ShowModal()
+    {
+      lastModal = Manager.ModalWindow;
+      Manager.ModalWindow = this;
+      Manager.Input.KeyDown += new KeyEventHandler(Input_KeyDown);
+      Manager.Input.GamePadDown += new GamePadEventHandler(Input_GamePadDown);
+    }
+    ////////////////////////////////////////////////////////////////////////////  
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual void Close()
+    {
+      WindowClosingEventArgs ex = new WindowClosingEventArgs();
+      OnClosing(ex);
+      if (!ex.Cancel)
+      {
+        Manager.Input.KeyDown -= Input_KeyDown;
+        Manager.Input.GamePadDown -= Input_GamePadDown;
+        Manager.ModalWindow = lastModal;
+        if (lastModal != null) lastModal.Focused = true;
+        Hide();
+        WindowClosedEventArgs ev = new WindowClosedEventArgs();
+        OnClosed(ev);        
+
+        if (ev.Dispose)
+        {
+          this.Dispose();          
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual void Close(ModalResult modalResult)
+    {
+      ModalResult = modalResult;
+      Close();
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    ////////////////////////////////////////////////////////////////////////////    
+    protected virtual void OnClosing(WindowClosingEventArgs e)
+    {
+      if (Closing != null) Closing.Invoke(this, e);
+    }
+    //////////////////////////////////////////////////////////////////////////// 
+
+    ////////////////////////////////////////////////////////////////////////////    
+    protected virtual void OnClosed(WindowClosedEventArgs e)
+    {
+      if (Closed != null) Closed.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////      
+
+    ////////////////////////////////////////////////////////////////////////////
+    void Input_KeyDown(object sender, KeyEventArgs e)
+    {
+      if (Visible && (Manager.FocusedControl != null && Manager.FocusedControl.Root == this) && 
+          e.Key == Microsoft.Xna.Framework.Input.Keys.Escape)
+      {        
+        //Close(ModalResult.Cancel);
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    void Input_GamePadDown(object sender, GamePadEventArgs e)
+    {
+      if (Visible && (Manager.FocusedControl != null && Manager.FocusedControl.Root == this))
+      {
+        if (e.Button == (GamePadActions as WindowGamePadActions).Accept)
+        {          
+          Close(ModalResult.Ok);
+        }
+        else if (e.Button == (GamePadActions as WindowGamePadActions).Cancel)
+        {          
+          Close(ModalResult.Cancel);
+        }
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion  
+  
+  }        
+
+}

Neoforce/NativeMethods.cs

@@ -0,0 +1,69 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: NativeMethods.cs                             //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using System.Runtime.InteropServices;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+    [Obsolete("Native methods should be avoided at all times")]
+    internal static class NativeMethods
+    {
+
+        #region //// Methods ///////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        [Obsolete]
+        [DllImport("User32.dll", CharSet = CharSet.Unicode)]
+        internal static extern IntPtr LoadImage(IntPtr instance, string fileName, uint type, int width, int height, uint load);
+        ////////////////////////////////////////////////////////////////////////////    
+
+        ////////////////////////////////////////////////////////////////////////////
+        [Obsolete]
+        [DllImport("User32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool DestroyCursor(IntPtr cursor);
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        [Obsolete]
+        internal static IntPtr LoadCursor(string fileName)
+        {
+            return LoadImage(IntPtr.Zero, fileName, 2, 0, 0, 0x0010);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        [Obsolete]
+        [DllImport("user32.dll")]
+        internal static extern short GetKeyState(int key);
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+    }
+
+}

Neoforce/Panel.cs

@@ -0,0 +1,280 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Panel.cs                                     //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+  public class Panel: Container
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private Bevel bevel = null;
+    private BevelStyle bevelStyle = BevelStyle.None;
+    private BevelBorder bevelBorder = BevelBorder.None;
+    private int bevelMargin = 0;
+    private Color bevelColor = Color.Transparent;   
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public BevelStyle BevelStyle
+    {
+      get { return bevelStyle; }
+      set 
+      { 
+        if (bevelStyle != value)
+        {
+          bevelStyle = bevel.Style = value; 
+          AdjustMargins();
+          if (!Suspended) OnBevelStyleChanged(new EventArgs());
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public BevelBorder BevelBorder
+    {
+      get { return bevelBorder; }
+      set 
+      { 
+        if (bevelBorder != value)
+        {
+          bevelBorder = bevel.Border = value; 
+          bevel.Visible = bevelBorder != BevelBorder.None; 
+          AdjustMargins();
+          if (!Suspended) OnBevelBorderChanged(new EventArgs());
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public int BevelMargin
+    {
+      get { return bevelMargin; }
+      set 
+      { 
+        if (bevelMargin != value)
+        {
+          bevelMargin = value; 
+          AdjustMargins();
+          if (!Suspended) OnBevelMarginChanged(new EventArgs());
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual Color BevelColor
+    {
+      get { return bevelColor; }
+      set 
+      {
+        bevel.Color = bevelColor = value; 
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+       
+    #endregion
+    
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    public event EventHandler BevelBorderChanged;
+    public event EventHandler BevelStyleChanged;
+    public event EventHandler BevelMarginChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion    
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public Panel(Manager manager): base(manager)
+    {
+      Passive = false;
+      CanFocus = false;
+      Width = 64;
+      Height = 64;
+      
+      bevel = new Bevel(Manager);                     
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    #endregion
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();            
+      
+      bevel.Init();
+      bevel.Style = bevelStyle;
+      bevel.Border = bevelBorder;
+      bevel.Left = 0;
+      bevel.Top = 0;
+      bevel.Width = Width;
+      bevel.Height = Height;
+      bevel.Color = bevelColor;
+      bevel.Visible = (bevelBorder != BevelBorder.None);
+      bevel.Anchor = Anchors.Left | Anchors.Top | Anchors.Right | Anchors.Bottom;
+      Add(bevel, false);      
+      AdjustMargins();  
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["Panel"]);  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void AdjustMargins()
+    {
+      int l = 0;
+      int t = 0;
+      int r = 0;
+      int b = 0;
+      int s = bevelMargin;
+
+      if (bevelBorder != BevelBorder.None)
+      {
+        if (bevelStyle != BevelStyle.Flat)
+        {
+          s += 2;
+        }
+        else
+        {
+          s += 1;
+        }
+
+        if (bevelBorder == BevelBorder.Left || bevelBorder == BevelBorder.All)
+        {
+          l = s;
+        }
+        if (bevelBorder == BevelBorder.Top || bevelBorder == BevelBorder.All)
+        {
+          t = s;
+        }
+        if (bevelBorder == BevelBorder.Right || bevelBorder == BevelBorder.All)
+        {
+          r = s;
+        }
+        if (bevelBorder == BevelBorder.Bottom || bevelBorder == BevelBorder.All)
+        {
+          b = s;
+        }
+      }
+      ClientMargins = new Margins(Skin.ClientMargins.Left + l, Skin.ClientMargins.Top + t, Skin.ClientMargins.Right + r, Skin.ClientMargins.Bottom + b);      
+      
+      base.AdjustMargins();                        
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {              
+      int x = rect.Left;
+      int y = rect.Top;
+      int w = rect.Width;
+      int h = rect.Height;
+      int s = bevelMargin;
+
+      if (bevelBorder != BevelBorder.None)
+      {      
+        if (bevelStyle != BevelStyle.Flat)
+        {
+          s += 2;
+        }
+        else 
+        {
+          s += 1;
+        }      
+      
+        if (bevelBorder == BevelBorder.Left || bevelBorder == BevelBorder.All)
+        {
+          x += s; 
+          w -= s; 
+        }
+        if (bevelBorder == BevelBorder.Top || bevelBorder == BevelBorder.All)
+        {
+          y += s;
+          h -= s;
+        } 
+        if (bevelBorder == BevelBorder.Right || bevelBorder == BevelBorder.All)
+        {
+          w -= s;
+        } 
+        if (bevelBorder == BevelBorder.Bottom || bevelBorder == BevelBorder.All)
+        {
+          h -= s;
+        }              
+      }                  
+      
+      base.DrawControl(renderer, new Rectangle(x, y, w, h), gameTime);      
+    }
+    ////////////////////////////////////////////////////////////////////////////          
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnBevelBorderChanged(EventArgs e)
+    {
+      if (BevelBorderChanged != null) BevelBorderChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnBevelStyleChanged(EventArgs e)
+    {
+      if (BevelStyleChanged != null) BevelStyleChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnBevelMarginChanged(EventArgs e)
+    {
+      if (BevelMarginChanged != null) BevelMarginChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    #endregion  
+
+  }
+
+}

Neoforce/ProgressBar.cs

@@ -0,0 +1,264 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ProgressBar.cs                               //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using System;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Enums /////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public enum ProgressBarMode
+  {
+    Default,
+    Infinite
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion
+
+  public class ProgressBar : Control
+  {
+
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private int range = 100;
+    private int value = 0;
+    private double time = 0;
+    private int sign = 1;
+    private ProgressBarMode mode = ProgressBarMode.Default;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public int Value
+    {
+      get { return this.value; }
+      set
+      {
+        if (mode == ProgressBarMode.Default)
+        {
+          if (this.value != value)
+          {
+            this.value = value;
+            if (this.value > range) this.value = range;
+            if (this.value < 0) this.value = 0;
+            Invalidate();
+
+            if (!Suspended) OnValueChanged(new EventArgs());
+          }
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public ProgressBarMode Mode
+    {
+      get { return mode; }
+      set
+      {
+        if (mode != value)
+        {
+          mode = value;
+          if (mode == ProgressBarMode.Infinite)
+          {
+            range = 100;
+            this.value = 0;
+            time = 0;
+            sign = 1;
+          }
+          else
+          {
+            this.value = 0;
+            range = 100;
+          }
+          Invalidate();
+
+          if (!Suspended) OnModeChanged(new EventArgs());
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public int Range
+    {
+      get { return range; }
+      set
+      {
+        if (range != value)
+        {
+          if (mode == ProgressBarMode.Default)
+          {
+            range = value;
+            if (range < 0) range = 0;
+            if (range < this.value) this.value = range;
+            Invalidate();
+
+            if (!Suspended) OnRangeChanged(new EventArgs());
+          }
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    public event EventHandler ValueChanged;
+    public event EventHandler RangeChanged;
+    public event EventHandler ModeChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ProgressBar(Manager manager)
+      : base(manager)
+    {
+      Width = 128;
+      Height = 16;
+      MinimumHeight = 8;
+      MinimumWidth = 32;
+      Passive = true;
+      CanFocus = false;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      CheckLayer(Skin, "Control");
+      CheckLayer(Skin, "Scale");
+
+      base.DrawControl(renderer, rect, gameTime);
+
+      if (Value > 0 || mode == ProgressBarMode.Infinite)
+      {
+        SkinLayer p = Skin.Layers["Control"];
+        SkinLayer l = Skin.Layers["Scale"];
+        Rectangle r = new Rectangle(rect.Left + p.ContentMargins.Left,
+                                    rect.Top + p.ContentMargins.Top,
+                                    rect.Width - p.ContentMargins.Vertical,
+                                    rect.Height - p.ContentMargins.Horizontal);
+
+        float perc = ((float)value / range) * 100;
+        int w = (int)((perc / 100) * r.Width);
+        Rectangle rx;
+        if (mode == ProgressBarMode.Default)
+        {
+          if (w < l.SizingMargins.Vertical) w = l.SizingMargins.Vertical;
+          rx = new Rectangle(r.Left, r.Top, w, r.Height);
+        }
+        else
+        {
+          int s = r.Left + w;
+          if (s > r.Left + p.ContentMargins.Left + r.Width - (r.Width / 4)) s = r.Left + p.ContentMargins.Left + r.Width - (r.Width / 4);
+          rx = new Rectangle(s, r.Top, (r.Width / 4), r.Height);
+        }
+        
+        renderer.DrawLayer(this, l, rx);
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected internal override void Update(GameTime gameTime)
+    {
+      base.Update(gameTime);
+
+      if (mode == ProgressBarMode.Infinite && Enabled && Visible)
+      {
+        time += gameTime.ElapsedGameTime.TotalMilliseconds;
+        if (time >= 33f)
+        {
+          value += sign * (int)Math.Ceiling(time / 20f);
+          if (value >= Range - (Range / 4))
+          {
+            value = Range - (Range / 4);
+            sign = -1;
+          }
+          else if (value <= 0)
+          {
+            value = 0;
+            sign = 1;
+          }  
+          time = 0;          
+          Invalidate();
+        }                        
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnValueChanged(EventArgs e)
+    {
+      if (ValueChanged != null) ValueChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnRangeChanged(EventArgs e)
+    {
+      if (RangeChanged != null) RangeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected virtual void OnModeChanged(EventArgs e)
+    {
+      if (ModeChanged != null) ModeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    #endregion
+
+  }
+
+}

Neoforce/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("MonoGame.Controls")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("MonoGame.Controls")]
+[assembly: AssemblyCopyright("Copyright ©  2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("581cd203-a917-4a56-87f8-79ef3cbe4f5e")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Neoforce/RadioButton.cs

@@ -0,0 +1,159 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: RadioButton.cs                               //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Enums /////////////
+
+  ////////////////////////////////////////////////////////////////////////////               
+  public enum RadioButtonMode
+  {
+    Auto,
+    Manual
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+ #endregion
+
+  public class RadioButton: CheckBox
+  {
+
+    #region //// Consts ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private const string skRadioButton = "RadioButton";
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////               
+    private RadioButtonMode mode = RadioButtonMode.Auto;  
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public RadioButtonMode Mode
+    {
+      get { return mode; }
+      set { mode = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////       
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                         
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public RadioButton(Manager manager): base(manager)
+    {
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls[skRadioButton]);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      base.DrawControl(renderer, rect, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnClick(EventArgs e)
+    {
+      MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs)e : new MouseEventArgs();      
+      
+      if (ex.Button == MouseButton.Left || ex.Button == MouseButton.None)      
+      {      
+        if (mode == RadioButtonMode.Auto)
+        {
+          if (Parent != null)
+          {
+            ControlsList lst = Parent.Controls as ControlsList;
+            for (int i = 0; i < lst.Count; i++)
+            {
+              if (lst[i] is RadioButton)
+              {
+                (lst[i] as RadioButton).Checked = false;
+              }
+            }  
+          }
+          else if (Parent == null && Manager != null)
+          {
+            ControlsList lst = Manager.Controls as ControlsList;
+            
+            for (int i = 0; i < lst.Count; i++)
+            {              
+              if (lst[i] is RadioButton)
+              {
+                (lst[i] as RadioButton).Checked = false;
+              }
+            }  
+          }  
+        }  
+      }              
+      base.OnClick(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////          
+
+    #endregion
+
+  }
+
+}

Neoforce/Renderer.cs

@@ -0,0 +1,767 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Renderer.cs                                  //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+    public enum BlendingMode
+    {
+        Default,
+        None,
+    }
+
+    #region //// Classes ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public class DeviceStates
+    {
+        public readonly BlendState BlendState;
+        public readonly RasterizerState RasterizerState;
+        public readonly DepthStencilState DepthStencilState;
+        public readonly SamplerState SamplerState;
+
+        public DeviceStates()
+        {
+            BlendState = new BlendState();
+            BlendState.AlphaBlendFunction = BlendState.AlphaBlend.AlphaBlendFunction;
+            BlendState.AlphaDestinationBlend = BlendState.AlphaBlend.AlphaDestinationBlend;
+            BlendState.AlphaSourceBlend = BlendState.AlphaBlend.AlphaSourceBlend;
+            BlendState.BlendFactor = BlendState.AlphaBlend.BlendFactor;
+            BlendState.ColorBlendFunction = BlendState.AlphaBlend.ColorBlendFunction;
+            BlendState.ColorDestinationBlend = BlendState.AlphaBlend.ColorDestinationBlend;
+            BlendState.ColorSourceBlend = BlendState.AlphaBlend.ColorSourceBlend;
+            BlendState.ColorWriteChannels = BlendState.AlphaBlend.ColorWriteChannels;
+            BlendState.ColorWriteChannels1 = BlendState.AlphaBlend.ColorWriteChannels1;
+            BlendState.ColorWriteChannels2 = BlendState.AlphaBlend.ColorWriteChannels2;
+            BlendState.ColorWriteChannels3 = BlendState.AlphaBlend.ColorWriteChannels3;
+            BlendState.MultiSampleMask = BlendState.AlphaBlend.MultiSampleMask;
+
+            RasterizerState = new RasterizerState();
+            RasterizerState.CullMode = RasterizerState.CullNone.CullMode;
+            RasterizerState.DepthBias = RasterizerState.CullNone.DepthBias;
+            RasterizerState.FillMode = RasterizerState.CullNone.FillMode;
+            RasterizerState.MultiSampleAntiAlias = RasterizerState.CullNone.MultiSampleAntiAlias;
+            RasterizerState.ScissorTestEnable = RasterizerState.CullNone.ScissorTestEnable;
+            RasterizerState.SlopeScaleDepthBias = RasterizerState.CullNone.SlopeScaleDepthBias;
+
+            RasterizerState.ScissorTestEnable = true;
+
+            SamplerState = new SamplerState();
+            SamplerState.AddressU = SamplerState.AnisotropicClamp.AddressU;
+            SamplerState.AddressV = SamplerState.AnisotropicClamp.AddressV;
+            SamplerState.AddressW = SamplerState.AnisotropicClamp.AddressW;
+            SamplerState.Filter = SamplerState.AnisotropicClamp.Filter;
+            SamplerState.MaxAnisotropy = SamplerState.AnisotropicClamp.MaxAnisotropy;
+            SamplerState.MaxMipLevel = SamplerState.AnisotropicClamp.MaxMipLevel;
+            SamplerState.MipMapLevelOfDetailBias = SamplerState.AnisotropicClamp.MipMapLevelOfDetailBias;
+
+            DepthStencilState = new DepthStencilState();
+            DepthStencilState = DepthStencilState.None;
+        }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    public class Renderer : Component
+    {
+
+        #region //// Fields ////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        private SpriteBatch sb = null;
+        private DeviceStates states = new DeviceStates();
+        private BlendingMode bmode = BlendingMode.Default;
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Properties ////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual SpriteBatch SpriteBatch
+        {
+            get
+            {
+                return sb;
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Constructors //////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public Renderer(Manager manager)
+            : base(manager)
+        {
+            sb = new SpriteBatch(Manager.GraphicsDevice);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Destructors ///////
+
+        ////////////////////////////////////////////////////////////////////////////
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (sb != null)
+                {
+                    sb.Dispose();
+                    sb = null;
+                }
+            }
+            base.Dispose(disposing);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        #endregion
+
+        #region //// Methods ///////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public override void Init()
+        {
+            base.Init();
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void Begin(BlendingMode mode)
+        {
+            bmode = mode;
+            if (mode != BlendingMode.None)
+            {
+                sb.Begin(SpriteSortMode.Immediate, states.BlendState, states.SamplerState, states.DepthStencilState, states.RasterizerState);
+            }
+            else
+            {
+                sb.Begin(SpriteSortMode.Immediate, BlendState.Opaque, states.SamplerState, states.DepthStencilState, states.RasterizerState);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void End()
+        {
+            sb.End();
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void Draw(Texture2D texture, Rectangle destination, Color color)
+        {
+            if (destination.Width > 0 && destination.Height > 0)
+            {
+                sb.Draw(texture, destination, null, color, 0.0f, Vector2.Zero, SpriteEffects.None, Manager.GlobalDepth);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        public virtual void DrawTileTexture(Texture2D texture, Rectangle destination, Color color)
+        {
+            if (destination.Width > 0 && destination.Height > 0)
+            {
+                End();
+
+                sb.Begin(SpriteSortMode.Texture, BlendState.AlphaBlend, SamplerState.LinearWrap, DepthStencilState.Default, RasterizerState.CullNone);
+
+                sb.Draw(texture, new Vector2(destination.X,destination.Y), destination, color, 0, Vector2.Zero, 1, SpriteEffects.None, 0);
+
+                End();
+                Begin(bmode);
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void Draw(Texture2D texture, Rectangle destination, Rectangle source, Color color)
+        {
+            if (source.Width > 0 && source.Height > 0 && destination.Width > 0 && destination.Height > 0)
+            {
+                sb.Draw(texture, destination, source, color, 0.0f, Vector2.Zero, SpriteEffects.None, Manager.GlobalDepth);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void Draw(Texture2D texture, int left, int top, Color color)
+        {
+            sb.Draw(texture, new Vector2(left, top), null, color, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, Manager.GlobalDepth);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void Draw(Texture2D texture, int left, int top, Rectangle source, Color color)
+        {
+            if (source.Width > 0 && source.Height > 0)
+            {
+                sb.Draw(texture, new Vector2(left, top), source, color, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, Manager.GlobalDepth);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(SpriteFont font, string text, int left, int top, Color color)
+        {
+            sb.DrawString(font, text, new Vector2(left, top), color, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, Manager.GlobalDepth);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(SpriteFont font, string text, Rectangle rect, Color color, Alignment alignment)
+        {
+            DrawString(font, text, rect, color, alignment, 0, 0, true);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(SpriteFont font, string text, Rectangle rect, Color color, Alignment alignment, bool ellipsis)
+        {
+            DrawString(font, text, rect, color, alignment, 0, 0, ellipsis);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(Control control, SkinLayer layer, string text, Rectangle rect)
+        {
+            DrawString(control, layer, text, rect, true, 0, 0, true);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(Control control, SkinLayer layer, string text, Rectangle rect, ControlState state)
+        {
+            DrawString(control, layer, text, rect, state, true, 0, 0, true);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(Control control, SkinLayer layer, string text, Rectangle rect, bool margins)
+        {
+            DrawString(control, layer, text, rect, margins, 0, 0, true);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(Control control, SkinLayer layer, string text, Rectangle rect, ControlState state, bool margins)
+        {
+            DrawString(control, layer, text, rect, state, margins, 0, 0, true);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(Control control, SkinLayer layer, string text, Rectangle rect, bool margins, int ox, int oy)
+        {
+            DrawString(control, layer, text, rect, margins, ox, oy, true);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(Control control, SkinLayer layer, string text, Rectangle rect, ControlState state, bool margins, int ox, int oy)
+        {
+            DrawString(control, layer, text, rect, state, margins, ox, oy, true);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(Control control, SkinLayer layer, string text, Rectangle rect, bool margins, int ox, int oy, bool ellipsis)
+        {
+            DrawString(control, layer, text, rect, control.ControlState, margins, ox, oy, ellipsis);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(Control control, SkinLayer layer, string text, Rectangle rect, ControlState state, bool margins, int ox, int oy, bool ellipsis)
+        {
+            Color col = Color.White;
+
+            if (layer.Text != null)
+            {
+                if (margins)
+                {
+                    Margins m = layer.ContentMargins;
+                    rect = new Rectangle(rect.Left + m.Left, rect.Top + m.Top, rect.Width - m.Horizontal, rect.Height - m.Vertical);
+                }
+
+                if (state == ControlState.Hovered && (layer.States.Hovered.Index != -1))
+                {
+                    col = layer.Text.Colors.Hovered;
+                }
+                else if (state == ControlState.Pressed)
+                {
+                    col = layer.Text.Colors.Pressed;
+                }
+                else if (state == ControlState.Focused || (control.Focused && state == ControlState.Hovered && layer.States.Hovered.Index == -1))
+                {
+                    col = layer.Text.Colors.Focused;
+                }
+                else if (state == ControlState.Disabled)
+                {
+                    col = layer.Text.Colors.Disabled;
+                }
+                else
+                {
+                    col = layer.Text.Colors.Enabled;
+                }
+
+                if (text != null && text != "")
+                {
+                    SkinText font = layer.Text;
+                    if (control.TextColor != Control.UndefinedColor && control.ControlState != ControlState.Disabled) col = control.TextColor;
+                    DrawString(font.Font.Resource, text, rect, col, font.Alignment, font.OffsetX + ox, font.OffsetY + oy, ellipsis);
+                }
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawString(SpriteFont font, string text, Rectangle rect, Color color, Alignment alignment, int offsetX, int offsetY, bool ellipsis)
+        {
+
+            if (ellipsis)
+            {
+                const string elli = "...";
+                int size = (int)Math.Ceiling(font.MeasureString(text).X);
+                if (size > rect.Width)
+                {
+                    int es = (int)Math.Ceiling(font.MeasureString(elli).X);
+                    for (int i = text.Length - 1; i > 0; i--)
+                    {
+                        int c = 1;
+                        if (char.IsWhiteSpace(text[i - 1]))
+                        {
+                            c = 2;
+                            i--;
+                        }
+                        text = text.Remove(i, c);
+                        size = (int)Math.Ceiling(font.MeasureString(text).X);
+                        if (size + es <= rect.Width)
+                        {
+                            break;
+                        }
+                    }
+                    text += elli;
+                }
+            }
+
+            if (rect.Width > 0 && rect.Height > 0)
+            {
+                Vector2 pos = new Vector2(rect.Left, rect.Top);
+                Vector2 size = font.MeasureString(text);
+
+                int x = 0; int y = 0;
+
+                switch (alignment)
+                {
+                    case Alignment.TopLeft:
+                        break;
+                    case Alignment.TopCenter:
+                        x = GetTextCenter(rect.Width, size.X);
+                        break;
+                    case Alignment.TopRight:
+                        x = rect.Width - (int)size.X;
+                        break;
+                    case Alignment.MiddleLeft:
+                        y = GetTextCenter(rect.Height, size.Y);
+                        break;
+                    case Alignment.MiddleRight:
+                        x = rect.Width - (int)size.X;
+                        y = GetTextCenter(rect.Height, size.Y);
+                        break;
+                    case Alignment.BottomLeft:
+                        y = rect.Height - (int)size.Y;
+                        break;
+                    case Alignment.BottomCenter:
+                        x = GetTextCenter(rect.Width, size.X);
+                        y = rect.Height - (int)size.Y;
+                        break;
+                    case Alignment.BottomRight:
+                        x = rect.Width - (int)size.X;
+                        y = rect.Height - (int)size.Y;
+                        break;
+
+                    default:
+                        x = GetTextCenter(rect.Width, size.X);
+                        y = GetTextCenter(rect.Height, size.Y);
+                        break;
+                }
+
+                pos.X = (int)(pos.X + x);
+                pos.Y = (int)(pos.Y + y);
+
+                DrawString(font, text, (int)pos.X + offsetX, (int)pos.Y + offsetY, color);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        private static int GetTextCenter(float size1, float size2)
+        {
+            return (int)Math.Ceiling((size1 / 2) - (size2 / 2));
+        }
+        ////////////////////////////////////////////////////////////////////////////              
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawLayer(SkinLayer layer, Rectangle rect, Color color, int index)
+        {
+            Size imageSize = new Size(layer.Image.Resource.Width, layer.Image.Resource.Height);
+            Size partSize = new Size(layer.Width, layer.Height);
+
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.TopLeft), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.TopLeft, index), color);
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.TopCenter), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.TopCenter, index), color);
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.TopRight), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.TopRight, index), color);
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.MiddleLeft), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.MiddleLeft, index), color);
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.MiddleCenter), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.MiddleCenter, index), color);
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.MiddleRight), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.MiddleRight, index), color);
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.BottomLeft), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.BottomLeft, index), color);
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.BottomCenter), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.BottomCenter, index), color);
+            Draw(layer.Image.Resource, GetDestinationArea(rect, layer.SizingMargins, Alignment.BottomRight), GetSourceArea(imageSize, partSize, layer.SizingMargins, Alignment.BottomRight, index), color);
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        private static Rectangle GetSourceArea(Size imageSize, Size partSize, Margins margins, Alignment alignment, int index)
+        {
+            Rectangle rect = new Rectangle();
+            int xc = (int)((float)imageSize.Width / partSize.Width);
+            int yc = (int)((float)imageSize.Height / partSize.Height);
+
+            int xm = (index) % xc;
+            int ym = (index) / xc;
+
+            int adj = 1;
+            margins.Left += margins.Left > 0 ? adj : 0;
+            margins.Top += margins.Top > 0 ? adj : 0;
+            margins.Right += margins.Right > 0 ? adj : 0;
+            margins.Bottom += margins.Bottom > 0 ? adj : 0;
+
+            margins = new Margins(margins.Left, margins.Top, margins.Right, margins.Bottom);
+            switch (alignment)
+            {
+                case Alignment.TopLeft:
+                    {
+                        rect = new Rectangle((0 + (xm * partSize.Width)),
+                                             (0 + (ym * partSize.Height)),
+                                             margins.Left,
+                                             margins.Top);
+                        break;
+                    }
+                case Alignment.TopCenter:
+                    {
+                        rect = new Rectangle((0 + (xm * partSize.Width)) + margins.Left,
+                                             (0 + (ym * partSize.Height)),
+                                             partSize.Width - margins.Left - margins.Right,
+                                             margins.Top);
+                        break;
+                    }
+                case Alignment.TopRight:
+                    {
+                        rect = new Rectangle((partSize.Width + (xm * partSize.Width)) - margins.Right,
+                                             (0 + (ym * partSize.Height)),
+                                             margins.Right,
+                                             margins.Top);
+                        break;
+                    }
+                case Alignment.MiddleLeft:
+                    {
+                        rect = new Rectangle((0 + (xm * partSize.Width)),
+                                             (0 + (ym * partSize.Height)) + margins.Top,
+                                             margins.Left,
+                                             partSize.Height - margins.Top - margins.Bottom);
+                        break;
+                    }
+                case Alignment.MiddleCenter:
+                    {
+                        rect = new Rectangle((0 + (xm * partSize.Width)) + margins.Left,
+                                             (0 + (ym * partSize.Height)) + margins.Top,
+                                             partSize.Width - margins.Left - margins.Right,
+                                             partSize.Height - margins.Top - margins.Bottom);
+                        break;
+                    }
+                case Alignment.MiddleRight:
+                    {
+                        rect = new Rectangle((partSize.Width + (xm * partSize.Width)) - margins.Right,
+                                             (0 + (ym * partSize.Height)) + margins.Top,
+                                             margins.Right,
+                                             partSize.Height - margins.Top - margins.Bottom);
+                        break;
+                    }
+                case Alignment.BottomLeft:
+                    {
+                        rect = new Rectangle((0 + (xm * partSize.Width)),
+                                             (partSize.Height + (ym * partSize.Height)) - margins.Bottom,
+                                             margins.Left,
+                                             margins.Bottom);
+                        break;
+                    }
+                case Alignment.BottomCenter:
+                    {
+                        rect = new Rectangle((0 + (xm * partSize.Width)) + margins.Left,
+                                             (partSize.Height + (ym * partSize.Height)) - margins.Bottom,
+                                             partSize.Width - margins.Left - margins.Right,
+                                             margins.Bottom);
+                        break;
+                    }
+                case Alignment.BottomRight:
+                    {
+                        rect = new Rectangle((partSize.Width + (xm * partSize.Width)) - margins.Right,
+                                             (partSize.Height + (ym * partSize.Height)) - margins.Bottom,
+                                             margins.Right,
+                                             margins.Bottom);
+                        break;
+                    }
+            }
+
+            return rect;
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public static Rectangle GetDestinationArea(Rectangle area, Margins margins, Alignment alignment)
+        {
+            Rectangle rect = new Rectangle();
+
+            int adj = 1;
+            margins.Left += margins.Left > 0 ? adj : 0;
+            margins.Top += margins.Top > 0 ? adj : 0;
+            margins.Right += margins.Right > 0 ? adj : 0;
+            margins.Bottom += margins.Bottom > 0 ? adj : 0;
+
+            margins = new Margins(margins.Left, margins.Top, margins.Right, margins.Bottom);
+
+            switch (alignment)
+            {
+                case Alignment.TopLeft:
+                    {
+                        rect = new Rectangle(area.Left + 0,
+                                             area.Top + 0,
+                                             margins.Left,
+                                             margins.Top);
+                        break;
+
+                    }
+                case Alignment.TopCenter:
+                    {
+                        rect = new Rectangle(area.Left + margins.Left,
+                                             area.Top + 0,
+                                             area.Width - margins.Left - margins.Right,
+                                             margins.Top);
+                        break;
+
+                    }
+                case Alignment.TopRight:
+                    {
+                        rect = new Rectangle(area.Left + area.Width - margins.Right,
+                                             area.Top + 0,
+                                             margins.Right,
+                                             margins.Top);
+                        break;
+
+                    }
+                case Alignment.MiddleLeft:
+                    {
+                        rect = new Rectangle(area.Left + 0,
+                                             area.Top + margins.Top,
+                                             margins.Left,
+                                             area.Height - margins.Top - margins.Bottom);
+                        break;
+                    }
+                case Alignment.MiddleCenter:
+                    {
+                        rect = new Rectangle(area.Left + margins.Left,
+                                             area.Top + margins.Top,
+                                             area.Width - margins.Left - margins.Right,
+                                             area.Height - margins.Top - margins.Bottom);
+                        break;
+                    }
+                case Alignment.MiddleRight:
+                    {
+                        rect = new Rectangle(area.Left + area.Width - margins.Right,
+                                             area.Top + margins.Top,
+                                             margins.Right,
+                                             area.Height - margins.Top - margins.Bottom);
+                        break;
+                    }
+                case Alignment.BottomLeft:
+                    {
+                        rect = new Rectangle(area.Left + 0,
+                                             area.Top + area.Height - margins.Bottom,
+                                             margins.Left,
+                                             margins.Bottom);
+                        break;
+                    }
+                case Alignment.BottomCenter:
+                    {
+                        rect = new Rectangle(area.Left + margins.Left,
+                                             area.Top + area.Height - margins.Bottom,
+                                             area.Width - margins.Left - margins.Right,
+                                             margins.Bottom);
+                        break;
+                    }
+                case Alignment.BottomRight:
+                    {
+                        rect = new Rectangle(area.Left + area.Width - margins.Right,
+                                             area.Top + area.Height - margins.Bottom,
+                                             margins.Right,
+                                             margins.Bottom);
+                        break;
+                    }
+            }
+
+            return rect;
+        }
+        ////////////////////////////////////////////////////////////////////////////    
+
+        ////////////////////////////////////////////////////////////////////////////
+        public void DrawGlyph(Glyph glyph, Rectangle rect)
+        {
+            Size imageSize = new Size(glyph.Image.Width, glyph.Image.Height);
+
+            if (!glyph.SourceRect.IsEmpty)
+            {
+                imageSize = new Size(glyph.SourceRect.Width, glyph.SourceRect.Height);
+            }
+
+            if (glyph.SizeMode == SizeMode.Centered)
+            {
+                rect = new Rectangle((rect.X + (rect.Width - imageSize.Width) / 2) + glyph.Offset.X,
+                                     (rect.Y + (rect.Height - imageSize.Height) / 2) + glyph.Offset.Y,
+                                     imageSize.Width,
+                                     imageSize.Height);
+            }
+            else if (glyph.SizeMode == SizeMode.Normal)
+            {
+                rect = new Rectangle(rect.X + glyph.Offset.X, rect.Y + glyph.Offset.Y, imageSize.Width, imageSize.Height);
+            }
+            else if (glyph.SizeMode == SizeMode.Auto)
+            {
+                rect = new Rectangle(rect.X + glyph.Offset.X, rect.Y + glyph.Offset.Y, imageSize.Width, imageSize.Height);
+            }
+
+            if (glyph.SourceRect.IsEmpty)
+            {
+                Draw(glyph.Image, rect, glyph.Color);
+            }
+            else
+            {
+                Draw(glyph.Image, rect, glyph.SourceRect, glyph.Color);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////
+        public virtual void DrawLayer(Control control, SkinLayer layer, Rectangle rect)
+        {
+            DrawLayer(control, layer, rect, control.ControlState);
+        }
+        ////////////////////////////////////////////////////////////////////////////   
+
+        ////////////////////////////////////////////////////////////////////////////    
+        public virtual void DrawLayer(Control control, SkinLayer layer, Rectangle rect, ControlState state)
+        {
+            Color c = Color.White;
+            Color oc = Color.White;
+            int i = 0;
+            int oi = -1;
+            SkinLayer l = layer;
+
+            if (state == ControlState.Hovered && (layer.States.Hovered.Index != -1))
+            {
+                c = l.States.Hovered.Color;
+                i = l.States.Hovered.Index;
+
+                if (l.States.Hovered.Overlay)
+                {
+                    oc = l.Overlays.Hovered.Color;
+                    oi = l.Overlays.Hovered.Index;
+                }
+            }
+            else if (state == ControlState.Focused || (control.Focused && state == ControlState.Hovered && layer.States.Hovered.Index == -1))
+            {
+                c = l.States.Focused.Color;
+                i = l.States.Focused.Index;
+
+                if (l.States.Focused.Overlay)
+                {
+                    oc = l.Overlays.Focused.Color;
+                    oi = l.Overlays.Focused.Index;
+                }
+            }
+            else if (state == ControlState.Pressed)
+            {
+                c = l.States.Pressed.Color;
+                i = l.States.Pressed.Index;
+
+                if (l.States.Pressed.Overlay)
+                {
+                    oc = l.Overlays.Pressed.Color;
+                    oi = l.Overlays.Pressed.Index;
+                }
+            }
+            else if (state == ControlState.Disabled)
+            {
+                c = l.States.Disabled.Color;
+                i = l.States.Disabled.Index;
+
+                if (l.States.Disabled.Overlay)
+                {
+                    oc = l.Overlays.Disabled.Color;
+                    oi = l.Overlays.Disabled.Index;
+                }
+            }
+            else
+            {
+                c = l.States.Enabled.Color;
+                i = l.States.Enabled.Index;
+
+                if (l.States.Enabled.Overlay)
+                {
+                    oc = l.Overlays.Enabled.Color;
+                    oi = l.Overlays.Enabled.Index;
+                }
+            }
+
+            if (control.Color != Control.UndefinedColor) c = control.Color * (control.Color.A / 255f);
+            DrawLayer(l, rect, c, i);
+
+            if (oi != -1)
+            {
+                DrawLayer(l, rect, oc, oi);
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////   
+
+        #endregion
+
+    }
+}

Neoforce/ScrollBar.cs

@@ -0,0 +1,493 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ScrollBar.cs                                 //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public class ScrollBar: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////          
+    private int range = 100;
+    private int value = 0;
+    private int pageSize = 50;
+    private int stepSize = 1;   
+    private Orientation orientation = Orientation.Vertical;   
+    ////////////////////////////////////////////////////////////////////////////          
+
+    ////////////////////////////////////////////////////////////////////////////          
+    private Button btnMinus = null;
+    private Button btnPlus = null;
+    private Button btnSlider = null;
+
+    private string strButton = "ScrollBar.ButtonVert";
+    private string strRail = "ScrollBar.RailVert";
+    private string strSlider = "ScrollBar.SliderVert";
+    private string strGlyph = "ScrollBar.GlyphVert";
+    private string strMinus = "ScrollBar.ArrowUp";
+    private string strPlus = "ScrollBar.ArrowDown";    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+  
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual int Value
+    {
+      get { return this.value; }
+      set 
+      { 
+        if (this.value != value)
+        {
+          this.value = value;  
+          if (this.value < 0) this.value = 0;
+          if (this.value > range - pageSize) this.value = range - pageSize;
+          Invalidate();
+          if (!Suspended) OnValueChanged(new EventArgs());
+        }  
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual int Range
+    {
+      get { return range; }
+      set 
+      { 
+        if (range != value)
+        {
+          range = value;
+          if (pageSize > range) pageSize = range;
+          RecalcParams();
+          if (!Suspended) OnRangeChanged(new EventArgs());
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual int PageSize
+    {
+      get { return pageSize; }
+      set 
+      { 
+        if (pageSize !=  value)
+        {
+          pageSize = value;        
+          if (pageSize > range) pageSize = range;
+          RecalcParams();
+          if (!Suspended) OnPageSizeChanged(new EventArgs());                   
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual int StepSize
+    {
+      get { return stepSize; }
+      set
+      { 
+        if (stepSize != value)
+        {
+          stepSize = value;
+          if (!Suspended) OnStepSizeChanged(new EventArgs());                   
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////            
+    public event EventHandler ValueChanged;
+    public event EventHandler RangeChanged;
+    public event EventHandler StepSizeChanged;
+    public event EventHandler PageSizeChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ScrollBar(Manager manager, Orientation orientation): base(manager)
+    {
+      this.orientation = orientation;
+      CanFocus = false;     
+           
+
+      if (orientation == Orientation.Horizontal)
+      {
+        strButton = "ScrollBar.ButtonHorz";
+        strRail = "ScrollBar.RailHorz";
+        strSlider = "ScrollBar.SliderHorz";
+        strGlyph = "ScrollBar.GlyphHorz";
+        strMinus = "ScrollBar.ArrowLeft";
+        strPlus = "ScrollBar.ArrowRight";
+
+        MinimumHeight = 16;
+        MinimumWidth = 46;
+        Width = 64;
+        Height = 16;        
+      }
+      else
+      {
+        strButton = "ScrollBar.ButtonVert";
+        strRail = "ScrollBar.RailVert";
+        strSlider = "ScrollBar.SliderVert";
+        strGlyph = "ScrollBar.GlyphVert";
+        strMinus = "ScrollBar.ArrowUp";
+        strPlus = "ScrollBar.ArrowDown";
+
+        MinimumHeight = 46;
+        MinimumWidth = 16;
+        Width = 16;
+        Height = 64;        
+      }
+
+      btnMinus = new Button(Manager);
+      btnMinus.Init();
+      btnMinus.Text = "";
+      btnMinus.MousePress += new MouseEventHandler(ArrowPress);
+      btnMinus.CanFocus = false;
+
+      btnSlider = new Button(Manager);
+      btnSlider.Init();
+      btnSlider.Text = "";
+      btnSlider.CanFocus = false;
+      btnSlider.MinimumHeight = 16;
+      btnSlider.MinimumWidth = 16;      
+
+      btnPlus = new Button(Manager);
+      btnPlus.Init();
+      btnPlus.Text = "";
+      btnPlus.MousePress += new MouseEventHandler(ArrowPress);
+      btnPlus.CanFocus = false;
+
+      btnSlider.Move += new MoveEventHandler(btnSlider_Move);
+
+      Add(btnMinus);
+      Add(btnSlider);
+      Add(btnPlus);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+        
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public void ScrollUp()
+    {
+        Value -= stepSize;
+        if (Value < 0) Value = 0;
+    }
+ 
+    public void ScrollDown()
+    {
+        Value += stepSize;
+        if (Value > range - pageSize) Value = range - pageSize - 1;
+    }
+ 
+    public void ScrollUp(bool alot)
+    {
+        if (alot)
+        {
+            Value -= pageSize;
+            if (Value < 0) Value = 0;
+        }
+        else
+            ScrollUp();
+    }
+ 
+    public void ScrollDown(bool alot)
+    {
+        if (alot)
+        {
+            Value += pageSize;
+            if (Value > range - pageSize) Value = range - pageSize - 1;
+        }
+        else
+            ScrollDown();
+    }
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public override void Init()
+    {
+      base.Init();    
+   
+      SkinControl sc = new SkinControl(btnPlus.Skin);
+      sc.Layers["Control"] = new SkinLayer(Skin.Layers[strButton]);
+      sc.Layers[strButton].Name = "Control";
+      btnPlus.Skin = btnMinus.Skin = sc;   
+
+      SkinControl ss = new SkinControl(btnSlider.Skin);
+      ss.Layers["Control"] = new SkinLayer(Skin.Layers[strSlider]);
+      ss.Layers[strSlider].Name = "Control";      
+      btnSlider.Skin = ss;      
+   
+      btnMinus.Glyph = new Glyph(Skin.Layers[strMinus].Image.Resource);
+      btnMinus.Glyph.SizeMode = SizeMode.Centered;
+      btnMinus.Glyph.Color = Manager.Skin.Controls["Button"].Layers["Control"].Text.Colors.Enabled;
+   
+      btnPlus.Glyph = new Glyph(Skin.Layers[strPlus].Image.Resource);
+      btnPlus.Glyph.SizeMode = SizeMode.Centered;
+      btnPlus.Glyph.Color = Manager.Skin.Controls["Button"].Layers["Control"].Text.Colors.Enabled;
+   
+      btnSlider.Glyph = new Glyph(Skin.Layers[strGlyph].Image.Resource);
+      btnSlider.Glyph.SizeMode = SizeMode.Centered;      
+   
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+    
+    ////////////////////////////////////////////////////////////////////////////   
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["ScrollBar"]);
+    }      
+    ////////////////////////////////////////////////////////////////////////////       
+           
+    ////////////////////////////////////////////////////////////////////////////   
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {      
+      RecalcParams();                        
+     
+      SkinLayer bg = Skin.Layers[strRail];      
+      renderer.DrawLayer(bg, rect, Color.White, bg.States.Enabled.Index);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////
+    void ArrowPress(object sender, MouseEventArgs e)
+    {
+      if (e.Button == MouseButton.Left)
+      {
+        if (sender == btnMinus)
+        {
+            ScrollUp();
+        }
+        else if (sender == btnPlus)
+        {
+            ScrollDown();
+        }       
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnResize(ResizeEventArgs e)
+    {
+      base.OnResize(e);     
+      RecalcParams();
+      if (Value + PageSize > Range) Value = Range - PageSize;              
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    private void RecalcParams()
+    {      
+      if (btnMinus != null && btnPlus != null && btnSlider != null)
+      {    
+        if (orientation == Orientation.Horizontal)
+        {
+          btnMinus.Width = Height;
+          btnMinus.Height = Height;        
+
+          btnPlus.Width = Height;
+          btnPlus.Height = Height;
+          btnPlus.Left = Width - Height;        
+          btnPlus.Top = 0;        
+                  
+          btnSlider.Movable = true;        
+          int size = btnMinus.Width + Skin.Layers[strSlider].OffsetX;
+
+          btnSlider.MinimumWidth = Height;
+          int w = (Width - 2 * size);
+          btnSlider.Width = (int)Math.Ceiling((pageSize * w) / (float)range);
+          btnSlider.Height = Height;
+
+
+          float px = (float)(Range - PageSize) / (float)(w - btnSlider.Width);
+          int pos = (int)(Math.Ceiling(Value / (float)px));
+          btnSlider.SetPosition(size + pos, 0);
+          if (btnSlider.Left < size) btnSlider.SetPosition(size, 0);
+          if (btnSlider.Left + btnSlider.Width + size > Width) btnSlider.SetPosition(Width - size - btnSlider.Width, 0);                    
+        }
+        else
+        {        
+          btnMinus.Width = Width;
+          btnMinus.Height = Width;                
+
+          btnPlus.Width = Width;
+          btnPlus.Height = Width;
+          btnPlus.Top = Height - Width;
+
+          btnSlider.Movable = true;
+          int size = btnMinus.Height + Skin.Layers[strSlider].OffsetY;
+
+          btnSlider.MinimumHeight = Width;
+          int h = (Height - 2 * size);
+          btnSlider.Height = (int)Math.Ceiling((pageSize * h) / (float)range);
+          btnSlider.Width = Width;               
+
+          float px = (float)(Range - PageSize) / (float)(h - btnSlider.Height);
+          int pos = (int)(Math.Ceiling(Value / (float)px));          
+          btnSlider.SetPosition(0, size + pos);          
+          if (btnSlider.Top < size) btnSlider.SetPosition(0, size);
+          if (btnSlider.Top + btnSlider.Height + size > Height) btnSlider.SetPosition(0, Height - size - btnSlider.Height);
+        }                
+      }      
+    }       
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    void btnSlider_Move(object sender, MoveEventArgs e)
+    {
+      if (orientation == Orientation.Horizontal)
+      {
+        int size = btnMinus.Width + Skin.Layers[strSlider].OffsetX;
+        btnSlider.SetPosition(e.Left, 0);
+        if (btnSlider.Left < size) btnSlider.SetPosition(size, 0);
+        if (btnSlider.Left + btnSlider.Width + size > Width) btnSlider.SetPosition(Width - size - btnSlider.Width, 0);
+      }
+      else
+      {                                    
+        int size = btnMinus.Height + Skin.Layers[strSlider].OffsetY;         
+        btnSlider.SetPosition(0, e.Top);
+        if (btnSlider.Top < size) btnSlider.SetPosition(0, size);         
+        if (btnSlider.Top + btnSlider.Height + size > Height) btnSlider.SetPosition(0, Height - size - btnSlider.Height);                
+      }
+
+      if (orientation == Orientation.Horizontal)
+      {
+        int size = btnMinus.Width + Skin.Layers[strSlider].OffsetX;
+        int w = (Width - 2 * size) - btnSlider.Width;
+        float px = (float)(Range - PageSize) / (float)w;
+        Value = (int)(Math.Ceiling((btnSlider.Left - size) * px));                                        
+      }
+      else
+      {
+        int size = btnMinus.Height + Skin.Layers[strSlider].OffsetY;
+        int h = (Height - 2 * size) - btnSlider.Height;        
+        float px = (float)(Range - PageSize) / (float)h;
+        Value = (int)(Math.Ceiling((btnSlider.Top - size) * px));
+      } 
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+    
+    ////////////////////////////////////////////////////////////////////////////        
+    protected override void OnMouseUp(MouseEventArgs e)
+    {
+      btnSlider.Passive = false;  
+      base.OnMouseUp(e);       
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+    
+    ////////////////////////////////////////////////////////////////////////////        
+    protected override void OnMouseDown(MouseEventArgs e)
+    {      
+      base.OnMouseDown(e);            
+      
+      btnSlider.Passive = true;            
+      
+      if (e.Button == MouseButton.Left)
+      {
+        if (orientation == Orientation.Horizontal)
+        {
+          int pos = e.Position.X;
+          
+          if (pos < btnSlider.Left)
+          {
+              ScrollUp(true);      
+          }
+          else if (pos >= btnSlider.Left + btnSlider.Width)
+          {
+              ScrollDown(true);
+          } 
+        }
+        else
+        {
+          int pos = e.Position.Y;
+
+          if (pos < btnSlider.Top)
+          {
+              ScrollUp(true);
+          }
+          else if (pos >= btnSlider.Top + btnSlider.Height)
+          {
+              ScrollDown(true);
+          }       
+        }                               
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected virtual void OnValueChanged(EventArgs e)
+    {
+      if (ValueChanged != null) ValueChanged.Invoke(this, e);            
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected virtual void OnRangeChanged(EventArgs e)
+    {
+      if (RangeChanged != null) RangeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected virtual void OnPageSizeChanged(EventArgs e)
+    {
+      if (PageSizeChanged != null) PageSizeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected virtual void OnStepSizeChanged(EventArgs e)
+    {
+      if (StepSizeChanged != null) StepSizeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    #endregion
+
+  }
+
+}

Neoforce/Sidebar.cs

@@ -0,0 +1,89 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: SideBar.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{ 
+
+
+  public class SideBar: Panel
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public SideBar(Manager manager): base(manager)
+    {      
+     // CanFocus = true;
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();  
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+    
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["SideBar"]);
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {          
+      base.DrawControl(renderer, rect, gameTime);       
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    #endregion  
+
+  }
+
+}

Neoforce/SidebarPanel.cs

@@ -0,0 +1,77 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: SideBarPanel.cs                              //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public class SideBarPanel: Container
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////           
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////    
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public SideBarPanel(Manager manager): base(manager)
+    {     
+      CanFocus = false;
+      Passive = true;
+      Width = 64;
+      Height = 64;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public override void Init()
+    {
+      base.Init();      
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    #endregion
+
+  }
+
+}

Neoforce/SpinBox.cs

@@ -0,0 +1,391 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: SpinBox.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+using System.Collections.Generic;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Enums /////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public enum SpinBoxMode
+  {
+    Range,
+    List
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion
+  
+  public class SpinBox: TextBox
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private Button btnUp = null;
+    private Button btnDown = null;
+    private SpinBoxMode mode = SpinBoxMode.List;
+    private List<object> items = new List<object>();
+    private float value = 0;
+    private float minimum = 0;
+    private float maximum = 100;
+    private float step = 0.25f;
+    private int rounding = 2;
+    private int itemIndex = -1;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public new virtual SpinBoxMode Mode
+    {
+      get { return mode; }
+      set { mode = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override bool ReadOnly
+    {
+      get { return base.ReadOnly; }
+      set
+      {
+        base.ReadOnly = value;
+        CaretVisible = !value;
+        if (value)
+        {
+          #if (!XBOX && !XBOX_FAKE)
+            Cursor = Manager.Skin.Cursors["Default"].Resource;
+          #endif
+        }
+        else
+        {
+          #if (!XBOX && !XBOX_FAKE)
+            Cursor = Manager.Skin.Cursors["Text"].Resource;
+          #endif
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual List<object> Items
+    {
+      get { return items; }      
+    } 
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    public float Value
+    {
+      get { return this.value; }
+      set 
+      { 
+        if (this.value != value)
+        {
+          this.value = value; 
+          Invalidate();
+        }          
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public float Minimum
+    {
+      get { return minimum; }
+      set 
+      { 
+        if (minimum != value)
+        {
+          minimum = value; 
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public float Maximum
+    {
+      get { return maximum; }
+      set 
+      { 
+        if (maximum != value)
+        {
+          maximum = value; 
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public float Step
+    {
+      get { return step; }
+      set 
+      { 
+        if (step != value)
+        {
+          step = value; 
+        }          
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public int ItemIndex
+    {
+      get { return itemIndex; }
+      set 
+      { 
+        if (mode == SpinBoxMode.List)
+        {
+          itemIndex = value;
+          Text = items[itemIndex].ToString();         
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public int Rounding
+    {
+      get { return rounding; }
+      set 
+      { 
+        if (rounding != value)
+        {        
+          rounding = value; 
+          Invalidate();
+        }  
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public SpinBox(Manager manager, SpinBoxMode mode): base(manager)
+    {         
+      this.mode = mode;
+      ReadOnly = true;      
+      
+      Height = 20;
+      Width = 64;           
+                     
+      btnUp = new Button(Manager);
+      btnUp.Init();    
+      btnUp.CanFocus = false;
+      btnUp.MousePress += new MouseEventHandler(btn_MousePress);
+      Add(btnUp, false);
+
+      btnDown = new Button(Manager);
+      btnDown.Init();            
+      btnDown.CanFocus = false;
+      btnDown.MousePress += new MouseEventHandler(btn_MousePress);
+      Add(btnDown, false);                  
+      
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();      
+
+      SkinControl sc = new SkinControl(btnUp.Skin);
+      sc.Layers["Control"] = new SkinLayer(Skin.Layers["Button"]);
+      sc.Layers["Button"].Name = "Control";
+      btnUp.Skin = btnDown.Skin = sc;
+
+      btnUp.Glyph = new Glyph(Manager.Skin.Images["Shared.ArrowUp"].Resource);
+      btnUp.Glyph.SizeMode = SizeMode.Centered;
+      btnUp.Glyph.Color = Manager.Skin.Controls["Button"].Layers["Control"].Text.Colors.Enabled;
+
+      btnDown.Glyph = new Glyph(Manager.Skin.Images["Shared.ArrowDown"].Resource);
+      btnDown.Glyph.SizeMode = SizeMode.Centered;
+      btnDown.Glyph.Color = Manager.Skin.Controls["Button"].Layers["Control"].Text.Colors.Enabled;
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+    
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["SpinBox"]);
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      base.DrawControl(renderer, rect, gameTime);
+
+      if (ReadOnly && Focused)
+      {
+        SkinLayer lr = Skin.Layers[0];
+        Rectangle rc = new Rectangle(rect.Left + lr.ContentMargins.Left,
+                                     rect.Top + lr.ContentMargins.Top,
+                                     Width - lr.ContentMargins.Horizontal - btnDown.Width - btnUp.Width,
+                                     Height - lr.ContentMargins.Vertical);
+        renderer.Draw(Manager.Skin.Images["ListBox.Selection"].Resource, rc, Color.FromNonPremultiplied(255, 255, 255, 128));
+      }    
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnResize(ResizeEventArgs e)
+    {
+      base.OnResize(e);
+      
+      if (btnUp != null)
+      {
+        btnUp.Width = 16;
+        btnUp.Height = Height - Skin.Layers["Control"].ContentMargins.Vertical;
+        btnUp.Top = Skin.Layers["Control"].ContentMargins.Top;
+        btnUp.Left = Width - 16 - 2 - 16 - 1;
+      }  
+      if (btnDown != null)
+      {
+        btnDown.Width = 16;
+        btnDown.Height = Height - Skin.Layers["Control"].ContentMargins.Vertical;
+        btnDown.Top = Skin.Layers["Control"].ContentMargins.Top; ;
+        btnDown.Left = Width - 16 - 2;            
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void ShiftIndex(bool direction)
+    {
+      if (mode == SpinBoxMode.List)
+      {
+        if (items.Count > 0)
+        {
+          if (direction)
+          {
+            itemIndex += 1;
+          }
+          else
+          {
+            itemIndex -= 1;
+          }
+
+          if (itemIndex < 0) itemIndex = 0;
+          if (itemIndex > items.Count - 1) itemIndex = itemIndex = items.Count - 1;
+
+          Text = items[itemIndex].ToString();
+        }  
+      }
+      else
+      {
+        if (direction)
+        {
+          value += step;
+        }
+        else
+        {
+          value -= step;
+        }
+
+        if (value < minimum) value = minimum;
+        if (value > maximum) value = maximum;
+
+        Text = value.ToString("n" + rounding.ToString());
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void btn_MousePress(object sender, MouseEventArgs e)
+    {
+      Focused = true;
+      if (sender == btnUp) ShiftIndex(true);
+      else if (sender == btnDown) ShiftIndex(false);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnKeyPress(KeyEventArgs e)
+    {            
+      if (e.Key == Keys.Up)
+      {
+        e.Handled = true;
+        ShiftIndex(true);
+      }        
+      else if (e.Key == Keys.Down)
+      {
+        e.Handled = true;
+        ShiftIndex(false);
+      }
+      
+      base.OnKeyPress(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnGamePadPress(GamePadEventArgs e)
+    {
+      if (e.Button == GamePadActions.Up)
+      {
+        e.Handled = true;
+        ShiftIndex(true);
+      }
+      else if (e.Button == GamePadActions.Down)
+      {
+        e.Handled = true;
+        ShiftIndex(false);
+      }
+      
+      base.OnGamePadPress(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnGamePadDown(GamePadEventArgs e)
+    {      
+      base.OnGamePadDown(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    #endregion  
+
+  }
+
+}

Neoforce/StackPanel.cs

@@ -0,0 +1,160 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: StackPanel.cs                                //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+  
+  public class StackPanel: Container
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+      private Orientation orientation;
+      public Orientation Orientation
+      {
+          get { return this.orientation; }
+          set
+          {
+              this.orientation = value;
+              this.CalcLayout();
+          }
+      }
+      private bool autoRefresh;
+
+      /// <summary>
+      /// Should the stack panel refresh itself, when a control is added
+      /// </summary>
+      public bool AutoRefresh
+      {
+          get { return autoRefresh; }
+          set { autoRefresh = value; }
+      }
+    ////////////////////////////////////////////////////////////////////////////
+
+      private TimeSpan refreshTimer;
+      private const int refreshTime = 300; //ms
+    #endregion
+   
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public StackPanel(Manager manager, Orientation orientation): base(manager)
+    {
+      this.orientation = orientation;
+      this.Color = Color.Transparent;
+      this.autoRefresh = true;
+      refreshTimer = new TimeSpan(0, 0, 0, 0, refreshTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion                    
+        
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void CalcLayout()
+    {
+      int top = Top;
+      int left = Left;            
+
+      foreach (Control c in ClientArea.Controls)
+      {
+        Margins m = c.Margins;
+  
+        if (orientation == Orientation.Vertical)
+        {
+          top += m.Top;
+          c.Top = top;
+          top += c.Height;
+          top += m.Bottom;
+          c.Left = left;
+        }
+
+        if (orientation == Orientation.Horizontal)
+        {
+          left += m.Left;
+          c.Left = left;
+          left += c.Width;
+          left += m.Right;
+          c.Top = top;
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {      
+      base.DrawControl(renderer, rect, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnResize(ResizeEventArgs e)
+    {
+      CalcLayout();
+      base.OnResize(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    protected internal override void Update(GameTime gameTime)
+    {
+        base.Update(gameTime);
+
+        if (autoRefresh)
+        {
+            refreshTimer = refreshTimer.Subtract(TimeSpan.FromMilliseconds(gameTime.ElapsedGameTime.TotalMilliseconds));
+            if (refreshTimer.TotalMilliseconds <= 0.00)
+            {
+                Refresh();
+                refreshTimer = new TimeSpan(0, 0, 0, 0, refreshTime);
+            }
+        }
+    }
+
+    public override void Add(Control control)
+    {
+        base.Add(control);
+        if (autoRefresh) Refresh();
+    }
+
+    public override void Add(Control control, bool client)
+    {
+        base.Add(control, client);
+        if (autoRefresh) Refresh();
+    }
+    
+    #endregion
+  
+  }       
+  
+}

Neoforce/StatusBar.cs

@@ -0,0 +1,93 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: StatusBar.cs                                 //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+
+  public class StatusBar: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public StatusBar(Manager manager): base(manager)
+    {
+      Left = 0;
+      Top = 0;
+      Width = 64;
+      Height = 24;
+      CanFocus = false;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["StatusBar"]);
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      base.DrawControl(renderer, rect, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+  }
+
+}

Neoforce/TabControl.cs

@@ -0,0 +1,390 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: TabControl.cs                                //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  ////////////////////////////////////////////////////////////////////////////
+  public class TabControlGamePadActions: GamePadActions
+  {
+    public GamePadButton NextTab = GamePadButton.RightTrigger;
+    public GamePadButton PrevTab = GamePadButton.LeftTrigger;
+  }
+  ////////////////////////////////////////////////////////////////////////////
+  
+  ////////////////////////////////////////////////////////////////////////////
+  public class TabPage: Control
+  {
+  
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private Rectangle headerRect = Rectangle.Empty;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////                     
+    protected internal Rectangle HeaderRect
+    {
+      get { return headerRect; }
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+   
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public TabPage(Manager manager): base(manager)
+    {
+      Color = Color.Transparent;
+      Passive = true;
+      CanFocus = false;      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion      
+
+		#region //// Methods ///////////
+			
+		////////////////////////////////////////////////////////////////////////////
+		protected internal void CalcRect(Rectangle prev, SpriteFont font, Margins margins, Point offset, bool first)
+    {
+      int size = (int)Math.Ceiling(font.MeasureString(Text).X) + margins.Horizontal;
+      
+      if (first) offset.X = 0;
+      
+      headerRect = new Rectangle(prev.Right + offset.X, prev.Top, size, prev.Height);
+    }
+   	////////////////////////////////////////////////////////////////////////////
+			
+		#endregion  
+		
+  }
+  ////////////////////////////////////////////////////////////////////////////
+  
+  ////////////////////////////////////////////////////////////////////////////
+  public class TabControl: Container
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private List<TabPage> tabPages = new List<TabPage>();           
+    private int selectedIndex = 0;
+    private int hoveredIndex = -1;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public TabPage[] TabPages
+    {
+      get { return tabPages.ToArray(); }      
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual int SelectedIndex
+    {
+      get { return selectedIndex; }
+      set
+      {
+        if (selectedIndex >= 0 && selectedIndex < tabPages.Count && value >= 0 && value < tabPages.Count)
+        {
+          TabPages[selectedIndex].Visible = false;
+        }
+        if (value >= 0 && value < tabPages.Count)
+        {
+          TabPages[value].Visible = true;          
+          ControlsList c = TabPages[value].Controls as ControlsList;          
+          if (c.Count > 0) c[0].Focused = true;
+          selectedIndex = value;
+          if (!Suspended) OnPageChanged(new EventArgs());
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual TabPage SelectedPage
+    {
+      get { return tabPages[SelectedIndex]; }
+      set
+      {
+        for (int i = 0; i < tabPages.Count; i++)
+        {
+          if (tabPages[i] == value)
+          {
+            SelectedIndex = i;
+            break;
+          }
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public event EventHandler PageChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public TabControl(Manager manager): base(manager)
+    {
+      GamePadActions = new TabControlGamePadActions();
+      Manager.Input.GamePadDown += new GamePadEventHandler(Input_GamePadDown);
+      this.CanFocus = false;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();  
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {          
+      SkinLayer l1 = Skin.Layers["Control"];
+      SkinLayer l2 = Skin.Layers["Header"];
+      Color col = this.Color != UndefinedColor ? this.Color : Color.White;
+      
+      Rectangle r1 = new Rectangle(rect.Left, rect.Top + l1.OffsetY, rect.Width, rect.Height - l1.OffsetY);
+      if (tabPages.Count <= 0)
+      {
+        r1 = rect;
+      }
+            
+      base.DrawControl(renderer, r1, gameTime);               
+    
+      if (tabPages.Count > 0)
+      {
+
+        Rectangle prev = new Rectangle(rect.Left, rect.Top + l2.OffsetY, 0, l2.Height);
+        for (int i = 0; i < tabPages.Count; i++)
+        {                   
+          SpriteFont font = l2.Text.Font.Resource;
+          Margins margins = l2.ContentMargins;
+          Point offset = new Point(l2.OffsetX, l2.OffsetY);          
+          if (i > 0) prev = tabPages[i - 1].HeaderRect;
+                    
+          tabPages[i].CalcRect(prev, font, margins, offset, i==0);
+        }
+      
+        for (int i = tabPages.Count - 1; i >= 0; i--)
+        {
+          int li = tabPages[i].Enabled ? l2.States.Enabled.Index : l2.States.Disabled.Index;
+          Color lc = tabPages[i].Enabled ? l2.Text.Colors.Enabled : l2.Text.Colors.Disabled;
+          if (i == hoveredIndex)
+          {
+            li = l2.States.Hovered.Index;
+            lc = l2.Text.Colors.Hovered;
+          }
+          
+          
+          Margins m = l2.ContentMargins;
+          Rectangle rx = tabPages[i].HeaderRect;          
+          Rectangle sx = new Rectangle(rx.Left + m.Left, rx.Top + m.Top, rx.Width - m.Horizontal, rx.Height - m.Vertical);
+          if (i != selectedIndex)
+          {
+            renderer.DrawLayer(l2, rx, col, li);   
+            renderer.DrawString(l2.Text.Font.Resource, tabPages[i].Text, sx, lc, l2.Text.Alignment);
+          }  
+        }
+        
+        Margins mi = l2.ContentMargins;
+        Rectangle ri = tabPages[selectedIndex].HeaderRect;
+        Rectangle si = new Rectangle(ri.Left + mi.Left, ri.Top + mi.Top, ri.Width - mi.Horizontal, ri.Height - mi.Vertical);
+        renderer.DrawLayer(l2, ri, col, l2.States.Focused.Index);        
+        renderer.DrawString(l2.Text.Font.Resource, tabPages[selectedIndex].Text, si, l2.Text.Colors.Focused, l2.Text.Alignment, l2.Text.OffsetX, l2.Text.OffsetY, false);
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    public virtual TabPage AddPage(string text)
+    {
+      TabPage p = AddPage();
+      p.Text = text;
+      
+      return p;
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    public virtual TabPage AddPage()
+    {
+      TabPage page = new TabPage(Manager);
+      page.Init();      
+      page.Left = 0;
+      page.Top = 0;
+      page.Width = ClientWidth;
+      page.Height = ClientHeight;
+      page.Anchor = Anchors.All;
+      page.Text = "Tab " + (tabPages.Count + 1).ToString();
+      page.Visible = false;      
+      Add(page, true);
+      tabPages.Add(page);
+      tabPages[0].Visible = true;
+      
+      return page;
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    public virtual void RemovePage(TabPage page, bool dispose)
+    {      
+      tabPages.Remove(page);
+      if (dispose)
+      {
+        page.Dispose();
+        page = null;
+      }
+      SelectedIndex = 0;
+    }
+    ////////////////////////////////////////////////////////////////////////////         
+
+    ////////////////////////////////////////////////////////////////////////////         
+    public virtual void RemovePage(TabPage page)
+    {
+      RemovePage(page, true);
+    }
+    ////////////////////////////////////////////////////////////////////////////         
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnMouseDown(MouseEventArgs e)
+    {
+      base.OnMouseDown(e);
+      
+      if (tabPages.Count > 1)
+      {
+        Point p = new Point(e.State.X - Root.AbsoluteLeft, e.State.Y - Root.AbsoluteTop);
+        for (int i = 0; i < tabPages.Count; i++)
+        {
+          Rectangle r = tabPages[i].HeaderRect;
+          if (p.X >= r.Left && p.X <= r.Right && p.Y >= r.Top && p.Y <= r.Bottom)
+          {
+            SelectedIndex = i;          
+            break;
+          }
+        }        
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+      base.OnMouseMove(e); 
+      if (tabPages.Count > 1)
+      {
+        int index = hoveredIndex;
+        Point p = new Point(e.State.X - Root.AbsoluteLeft, e.State.Y - Root.AbsoluteTop);
+        for (int i = 0; i < tabPages.Count; i++)
+        {
+          Rectangle r = tabPages[i].HeaderRect;
+          if (p.X >= r.Left && p.X <= r.Right && p.Y >= r.Top && p.Y <= r.Bottom && tabPages[i].Enabled)
+          {
+            index = i;
+            break;
+          }
+          else
+          {
+            index = -1;
+          }         
+        }
+        if (index != hoveredIndex)
+        {
+          hoveredIndex = index;
+          Invalidate();
+        }
+      }      
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    void Input_GamePadDown(object sender, GamePadEventArgs e)
+    {
+      if (this.Contains(Manager.FocusedControl, true))
+      {
+        if (e.Button == (GamePadActions as TabControlGamePadActions).NextTab)
+        {
+          e.Handled = true;
+          SelectedIndex += 1;
+        }
+        else if (e.Button == (GamePadActions as TabControlGamePadActions).PrevTab)
+        {
+          e.Handled = true;
+          SelectedIndex -= 1;
+        }
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected virtual void OnPageChanged(EventArgs e)
+    {
+      if (PageChanged != null) PageChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    #endregion  
+
+  }
+
+}

Neoforce/TomShane.Neoforce.Controls.csproj

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{AC5F1CD8-AA8E-4DB5-814F-86C214175841}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>TomShane.Neoforce.Controls</RootNamespace>
+    <AssemblyName>TomShane.Neoforce.Controls</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="MonoGame.Framework, Version=3.1.2.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>C:\Program Files (x86)\MonoGame\v3.0\Assemblies\Windows\MonoGame.Framework.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.XML" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ArchiveManager.cs" />
+    <Compile Include="Bevel.cs" />
+    <Compile Include="Button.cs" />
+    <Compile Include="ButtonBase.cs" />
+    <Compile Include="CheckBox.cs" />
+    <Compile Include="ClipBox.cs" />
+    <Compile Include="ClipControl.cs" />
+    <Compile Include="ComboBox.cs" />
+    <Compile Include="Component.cs" />
+    <Compile Include="Console.cs" />
+    <Compile Include="Container.cs" />
+    <Compile Include="ContentReaders.cs" />
+    <Compile Include="ContextMenu.cs" />
+    <Compile Include="Control.cs" />
+    <Compile Include="Cursor.cs" />
+    <Compile Include="Delegates.cs" />
+    <Compile Include="Dialog.cs" />
+    <Compile Include="Disposable.cs" />
+    <Compile Include="EventArgs.cs" />
+    <Compile Include="EventedList.cs" />
+    <Compile Include="ExitDialog.cs" />
+    <Compile Include="External\Zip\Crc32.cs" />
+    <Compile Include="External\Zip\Shared.cs" />
+    <Compile Include="External\Zip\ZipDirEntry.cs" />
+    <Compile Include="External\Zip\ZipEntry.cs" />
+    <Compile Include="External\Zip\ZipFile.cs" />
+    <Compile Include="GroupBox.cs" />
+    <Compile Include="GroupPanel.cs" />
+    <Compile Include="ImageBox.cs" />
+    <Compile Include="InputSystem.cs" />
+    <Compile Include="KeyboardLayout.cs" />
+    <Compile Include="Label.cs" />
+    <Compile Include="Layout.cs" />
+    <Compile Include="ListBox.cs" />
+    <Compile Include="MainMenu.cs" />
+    <Compile Include="Manager.cs" />
+    <Compile Include="MenuBase.cs" />
+    <Compile Include="ModalContainer.cs" />
+    <Compile Include="NativeMethods.cs" />
+    <Compile Include="Panel.cs" />
+    <Compile Include="ProgressBar.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RadioButton.cs" />
+    <Compile Include="Renderer.cs" />
+    <Compile Include="ScrollBar.cs" />
+    <Compile Include="Sidebar.cs" />
+    <Compile Include="SidebarPanel.cs" />
+    <Compile Include="Skin.cs" />
+    <Compile Include="SpinBox.cs" />
+    <Compile Include="StackPanel.cs" />
+    <Compile Include="StatusBar.cs" />
+    <Compile Include="TabControl.cs" />
+    <Compile Include="TextBox.cs" />
+    <Compile Include="ToolBar.cs" />
+    <Compile Include="ToolBarButton.cs" />
+    <Compile Include="ToolBarPanel.cs" />
+    <Compile Include="ToolTip.cs" />
+    <Compile Include="TrackBar.cs" />
+    <Compile Include="Types.cs" />
+    <Compile Include="Unknown.cs" />
+    <Compile Include="Utilities.cs" />
+    <Compile Include="Window.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

Neoforce/ToolBar.cs

@@ -0,0 +1,113 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ToolBar.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+
+  public class ToolBar: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    private int row = 0;
+    private bool fullRow = false;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual int Row
+    {
+      get { return row; }
+      set 
+      { 
+        row = value; 
+        if (row < 0) row = 0;
+        if (row > 7) row = 7;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual bool FullRow
+    {
+      get { return fullRow; }
+      set { fullRow = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ToolBar(Manager manager): base(manager)
+    {    
+      Left = 0;
+      Top = 0;
+      Width = 64;
+      Height = 24;
+      CanFocus = false;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["ToolBar"]);
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      base.DrawControl(renderer, rect, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    #endregion
+
+  }
+
+}

Neoforce/ToolBarButton.cs

@@ -0,0 +1,90 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ToolBarButton.cs                             //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+
+  public class ToolBarButton: Button
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ToolBarButton(Manager manager): base(manager)
+    {
+      CanFocus = false;
+      Text = "";      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["ToolBarButton"]);      
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      base.DrawControl(renderer, rect, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    #endregion
+
+  }
+
+}

Neoforce/ToolBarPanel.cs

@@ -0,0 +1,135 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ToolBarPanel.cs                              //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+
+  public class ToolBarPanel: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                 
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ToolBarPanel(Manager manager): base(manager)
+    {
+      Width = 64;
+      Height = 25;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["ToolBarPanel"]);
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      base.DrawControl(renderer, rect, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    ////////////////////////////////////////////////////////////////////////////     
+    protected override void OnResize(ResizeEventArgs e)
+    {
+      base.OnResize(e);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void Update(GameTime gameTime)
+    {
+      base.Update(gameTime);      
+      AlignBars();      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void AlignBars()
+    {
+      int[] rx = new int[8];
+      int h = 0; 
+      int rm = -1;     
+      
+      foreach (Control c in Controls)
+      {
+        if (c is ToolBar)
+        {
+          ToolBar t = c as ToolBar;
+          if (t.FullRow) t.Width = Width;
+          t.Left = rx[t.Row];
+          t.Top = (t.Row * t.Height) + (t.Row > 0 ? 1 : 0);
+          rx[t.Row] += t.Width + 1;                    
+          
+          if (t.Row > rm)
+          {
+            rm = t.Row;
+            h = t.Top + t.Height + 1;
+          }
+        }
+      }
+      
+      Height = h;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+
+    #endregion
+
+  }
+
+}

Neoforce/ToolTip.cs

@@ -0,0 +1,110 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: ToolTip.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{  
+  public class ToolTip: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////                     
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override bool Visible
+    {
+      set
+      {
+        if (value && Text != null && Text != "" && Skin != null && Skin.Layers[0] != null)
+        {
+          Vector2 size = Skin.Layers[0].Text.Font.Resource.MeasureString(Text);
+          Width = (int)size.X + Skin.Layers[0].ContentMargins.Horizontal;
+          Height = (int)size.Y + Skin.Layers[0].ContentMargins.Vertical;
+          Left = Mouse.GetState().X;
+          Top = Mouse.GetState().Y + 24;
+          base.Visible = value;
+        }
+        else
+        {
+          base.Visible = false;
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public ToolTip(Manager manager): base(manager)
+    {  
+      Text = "";          
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+    
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {      
+      base.Init();
+      CanFocus = false;
+      Passive = true;          
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+
+    ////////////////////////////////////////////////////////////////////////////                          
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = Manager.Skin.Controls["ToolTip"];
+    }
+    ////////////////////////////////////////////////////////////////////////////                          
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {                      
+      renderer.DrawLayer(this, Skin.Layers[0], rect);
+      renderer.DrawString(this, Skin.Layers[0], Text, rect, true);
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+
+    #endregion  
+
+  }
+
+}

Neoforce/TrackBar.cs

@@ -0,0 +1,341 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: TrackBar.cs                                  //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework.Graphics;
+using System;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  public class TrackBar: Control
+  {
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////           
+    private int range = 100;
+    private int value = 0; 
+    private int stepSize = 1;
+    private int pageSize = 5;
+    private bool scale = true;    
+    private Button btnSlider;    
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual int Value
+    {
+      get { return this.value; }
+      set
+      {
+        if (this.value != value)
+        {
+          this.value = value;
+          if (this.value < 0) this.value = 0;
+          if (this.value > range) this.value = range;
+          Invalidate();
+          if (!Suspended) OnValueChanged(new EventArgs());
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual int Range
+    {
+      get { return range; }
+      set
+      {
+        if (range != value)
+        {                    
+          range = value;
+          range = value;
+          if (pageSize > range) pageSize = range;                
+          RecalcParams();          
+          if (!Suspended) OnRangeChanged(new EventArgs());
+        }        
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual int PageSize
+    {
+      get { return pageSize; }
+      set
+      {
+        if (pageSize != value)
+        {
+          pageSize = value;
+          if (pageSize > range) pageSize = range;
+          RecalcParams();
+          if (!Suspended) OnPageSizeChanged(new EventArgs());
+        }
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    ////////////////////////////////////////////////////////////////////////////    
+    public virtual int StepSize
+    {
+      get { return stepSize; }
+      set
+      {
+        if (stepSize != value)
+        {
+          stepSize = value;
+          if (stepSize > range) stepSize = range;
+          if (!Suspended) OnStepSizeChanged(new EventArgs());
+        }
+      }
+    }
+    //////////////////////////////////////////////////////////////////////////// 
+    
+    //////////////////////////////////////////////////////////////////////////// 
+    public virtual bool Scale
+    {
+      get { return scale; }
+      set { scale = value; }
+    }
+    //////////////////////////////////////////////////////////////////////////// 
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////            
+    public event EventHandler ValueChanged;
+    public event EventHandler RangeChanged;
+    public event EventHandler StepSizeChanged;
+    public event EventHandler PageSizeChanged;
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Construstors //////
+
+    ////////////////////////////////////////////////////////////////////////////       
+    public TrackBar(Manager manager): base(manager)
+    {     
+      Width = 64;
+      Height = 20;      
+      CanFocus = false;
+
+      btnSlider = new Button(Manager);
+      btnSlider.Init();
+      btnSlider.Text = "";
+      btnSlider.CanFocus = true;
+      btnSlider.Parent = this;
+      btnSlider.Anchor = Anchors.Left | Anchors.Top | Anchors.Bottom;
+      btnSlider.Detached = true;
+      btnSlider.Movable = true;
+      btnSlider.Move += new MoveEventHandler(btnSlider_Move);
+      btnSlider.KeyPress += new KeyEventHandler(btnSlider_KeyPress);
+      btnSlider.GamePadPress += new GamePadEventHandler(btnSlider_GamePadPress);
+    }    
+    ////////////////////////////////////////////////////////////////////////////
+    
+    #endregion
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public override void Init()
+    {
+      base.Init();
+      btnSlider.Skin = new SkinControl(Manager.Skin.Controls["TrackBar.Button"]);      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls["TrackBar"]);      
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////   
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      RecalcParams();
+      
+      SkinLayer p = Skin.Layers["Control"];
+      SkinLayer l = Skin.Layers["Scale"];            
+      
+      float ratio = 0.66f;
+      int h = (int)(ratio * rect.Height);
+      int t = rect.Top + (Height - h) / 2;      
+            
+      float px = ((float)value / (float)range);
+      int w = (int)Math.Ceiling(px * (rect.Width - p.ContentMargins.Horizontal - btnSlider.Width)) + 2;
+            
+      if (w < l.SizingMargins.Vertical) w = l.SizingMargins.Vertical;
+      if (w > rect.Width - p.ContentMargins.Horizontal) w = rect.Width - p.ContentMargins.Horizontal;
+      
+      Rectangle r1 = new Rectangle(rect.Left + p.ContentMargins.Left, t + p.ContentMargins.Top, w, h - p.ContentMargins.Vertical);
+            
+      base.DrawControl(renderer, new Rectangle(rect.Left, t, rect.Width, h), gameTime);      
+      if (scale) renderer.DrawLayer(this, l, r1);      
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////     
+    void btnSlider_Move(object sender, MoveEventArgs e)
+    {      
+      SkinLayer p = Skin.Layers["Control"];
+      int size = btnSlider.Width;
+      int w = Width - p.ContentMargins.Horizontal - size;
+      int pos = e.Left;
+
+      if (pos < p.ContentMargins.Left) pos = p.ContentMargins.Left;
+      if (pos > w + p.ContentMargins.Left) pos = w + p.ContentMargins.Left;
+      
+      btnSlider.SetPosition(pos, 0);      
+            
+      float px = (float)range / (float)w;
+      Value = (int)(Math.Ceiling((pos - p.ContentMargins.Left) * px));
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////     
+    private void RecalcParams()
+    {
+      if (btnSlider != null)
+      {
+        if (btnSlider.Width > 12)
+        {        
+          btnSlider.Glyph = new Glyph(Manager.Skin.Images["Shared.Glyph"].Resource);
+          btnSlider.Glyph.SizeMode = SizeMode.Centered;      
+        }
+        else
+        {
+          btnSlider.Glyph = null;
+        }
+      
+        SkinLayer p = Skin.Layers["Control"];
+        btnSlider.Width = (int)(Height * 0.8);
+        btnSlider.Height = Height;
+        int size = btnSlider.Width;
+        int w = Width - p.ContentMargins.Horizontal - size;
+
+        float px = (float)range / (float)w;
+        int pos = p.ContentMargins.Left + (int)(Math.Ceiling(Value / (float)px));                                
+        
+        if (pos < p.ContentMargins.Left) pos = p.ContentMargins.Left;
+        if (pos > w + p.ContentMargins.Left) pos = w + p.ContentMargins.Left;
+        
+        btnSlider.SetPosition(pos, 0);                
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected override void OnMousePress(MouseEventArgs e)
+    {
+      base.OnMouseDown(e);  
+      
+      if (e.Button == MouseButton.Left)
+      {        
+        int pos = e.Position.X;
+          
+        if (pos < btnSlider.Left)
+        {
+          Value -= pageSize;         
+        }
+        else if (pos >= btnSlider.Left + btnSlider.Width)
+        {
+          Value += pageSize;          
+        } 
+      }         
+    }
+    ////////////////////////////////////////////////////////////////////////////           
+
+    ////////////////////////////////////////////////////////////////////////////
+    void btnSlider_GamePadPress(object sender, GamePadEventArgs e)
+    {
+      if (e.Button == GamePadActions.Left || e.Button == GamePadActions.Down) Value -= stepSize;
+      if (e.Button == GamePadActions.Right || e.Button == GamePadActions.Up) Value += stepSize;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    void btnSlider_KeyPress(object sender, KeyEventArgs e)
+    {
+      if (e.Key == Microsoft.Xna.Framework.Input.Keys.Left || e.Key == Microsoft.Xna.Framework.Input.Keys.Down) Value -= stepSize;
+      else if (e.Key == Microsoft.Xna.Framework.Input.Keys.Right || e.Key == Microsoft.Xna.Framework.Input.Keys.Up) Value += stepSize;
+      else if (e.Key == Microsoft.Xna.Framework.Input.Keys.PageDown) Value -= pageSize;
+      else if (e.Key == Microsoft.Xna.Framework.Input.Keys.PageUp) Value += pageSize;
+      else if (e.Key == Microsoft.Xna.Framework.Input.Keys.Home) Value = 0;
+      else if (e.Key == Microsoft.Xna.Framework.Input.Keys.End) Value = Range;
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////   
+    protected override void OnResize(ResizeEventArgs e)
+    {
+      base.OnResize(e);
+      RecalcParams();      
+    }
+    ////////////////////////////////////////////////////////////////////////////          
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected virtual void OnValueChanged(EventArgs e)
+    {
+      if (ValueChanged != null) ValueChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected virtual void OnRangeChanged(EventArgs e)
+    {
+      if (RangeChanged != null) RangeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////         
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected virtual void OnPageSizeChanged(EventArgs e)
+    {
+      if (PageSizeChanged != null) PageSizeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    ////////////////////////////////////////////////////////////////////////////        
+    protected virtual void OnStepSizeChanged(EventArgs e)
+    {
+      if (StepSizeChanged != null) StepSizeChanged.Invoke(this, e);
+    }
+    ////////////////////////////////////////////////////////////////////////////        
+
+    #endregion
+
+  }
+
+}

Neoforce/Types.cs

@@ -0,0 +1,178 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Types.cs                                     //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Enums /////////////
+
+  ////////////////////////////////////////////////////////////////////////////  
+  public enum Message
+  {
+    Click,    
+    MouseDown,
+    MouseUp,
+    MousePress,
+    MouseMove,
+    MouseOver,
+    MouseOut,
+    MouseScroll,
+    KeyDown,
+    KeyUp,
+    KeyPress,
+    GamePadDown,
+    GamePadUp,
+    GamePadPress    
+  }
+  ////////////////////////////////////////////////////////////////////////////        
+
+  ////////////////////////////////////////////////////////////////////////////
+  public enum ControlState
+  {    
+    Enabled,
+    Hovered,
+    Pressed,
+    Focused,
+    Disabled
+  }
+  ////////////////////////////////////////////////////////////////////////////  
+  
+  ////////////////////////////////////////////////////////////////////////////
+  public enum Alignment
+  {
+    None,
+    TopLeft,
+    TopCenter,
+    TopRight,
+    MiddleLeft,
+    MiddleCenter,
+    MiddleRight,
+    BottomLeft,
+    BottomCenter,
+    BottomRight
+  }
+  ////////////////////////////////////////////////////////////////////////////    
+  
+  ////////////////////////////////////////////////////////////////////////////  
+  public enum ModalResult
+  {
+    None,
+    Ok,
+    Cancel,
+    Yes,
+    No,
+    Abort,
+    Retry,
+    Ignore
+  }
+  ////////////////////////////////////////////////////////////////////////////   
+
+  ////////////////////////////////////////////////////////////////////////////   
+  public enum Orientation
+  {
+    Horizontal,
+    Vertical
+  }
+  ////////////////////////////////////////////////////////////////////////////  
+
+  ////////////////////////////////////////////////////////////////////////////
+  public enum ScrollBars
+  {
+    None,
+    Vertical,
+    Horizontal,
+    Both
+  }
+  //////////////////////////////////////////////////////////////////////////// 
+  
+  ////////////////////////////////////////////////////////////////////////////  
+  [Flags]
+  public enum Anchors
+  {    
+    None = 0x00,
+    Left = 0x01,
+    Top = 0x02,
+    Right = 0x04,
+    Bottom = 0x08,
+    Horizontal = Left | Right,
+    Vertical = Top | Bottom,
+    All = Left | Top | Right | Bottom
+  }
+  ////////////////////////////////////////////////////////////////////////////  
+  
+  #endregion
+
+  #region //// Structs ///////////
+  
+  ////////////////////////////////////////////////////////////////////////////
+  public struct Margins
+  {
+    public int Left;
+    public int Top;
+    public int Right;
+    public int Bottom;   
+    
+    public int Vertical { get { return (Top + Bottom); } }
+    public int Horizontal { get { return (Left + Right); } }
+    
+    public Margins(int left, int top, int right, int bottom)
+    {
+      Left = left;
+      Top = top;
+      Right = right;
+      Bottom = bottom;
+    }         
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  ////////////////////////////////////////////////////////////////////////////
+  public struct Size
+  {
+    public int Width;
+    public int Height;
+    
+    public Size(int width, int height)
+    {
+      Width = width;
+      Height = height;
+    }
+    
+    public static Size Zero
+    {
+      get 
+      {
+        return new Size(0, 0);
+      }
+    }
+  }
+  //////////////////////////////////////////////////////////////////////////// 
+  
+  #endregion    
+  
+}
+  

Neoforce/Unknown.cs

@@ -0,0 +1,61 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Unknown.cs                                   //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+        
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{     
+		
+	public abstract class Unknown
+	{    
+        
+    #region //// Fields ////////////
+                
+    //////////////////////////////////////////////////////////////////////////            
+    //////////////////////////////////////////////////////////////////////////    
+   
+    #endregion                
+    
+    #region //// Properties ////////
+	  
+	  //////////////////////////////////////////////////////////////////////////	  
+	  //////////////////////////////////////////////////////////////////////////
+	  
+	  #endregion        
+	  
+    #region //// Constructors //////
+        
+	  //////////////////////////////////////////////////////////////////////////
+    protected Unknown()
+    {    
+    }
+    //////////////////////////////////////////////////////////////////////////
+    
+    #endregion      	  
+	  
+  }			    
+		
+}
+

Neoforce/Utilities.cs

@@ -0,0 +1,85 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Utilities.cs                                 //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using System;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+  static class Utilities
+  {
+  
+    #region //// Methods ///////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public static string DeriveControlName(Control control)
+    {
+      if (control != null)
+      {
+        try
+        {
+          string str = control.ToString();
+          int i = str.LastIndexOf(".");
+          return str.Remove(0, i + 1);
+        }
+        catch
+        {
+          return control.ToString();
+        }
+      }
+      return control.ToString();
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public static Color ParseColor(string str)
+    {
+
+      string[] val = str.Split(';');
+      byte r = 255, g = 255, b = 255, a = 255;
+
+      if (val.Length >= 1) r = byte.Parse(val[0]);
+      if (val.Length >= 2) g = byte.Parse(val[1]);
+      if (val.Length >= 3) b = byte.Parse(val[2]);
+      if (val.Length >= 4) a = byte.Parse(val[3]);
+
+      return Color.FromNonPremultiplied(r, g, b, a);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public static BevelStyle ParseBevelStyle(string str)
+    {
+      return (BevelStyle)Enum.Parse(typeof(BevelStyle), str, true);
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    #endregion    
+    
+  }
+}

Neoforce/Window.cs

@@ -0,0 +1,491 @@
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Neoforce Controls                                         //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//         File: Window.cs                                    //
+//                                                            //
+//      Version: 0.7                                          //
+//                                                            //
+//         Date: 11/09/2010                                   //
+//                                                            //
+//       Author: Tom Shane                                    //
+//                                                            //
+////////////////////////////////////////////////////////////////
+//                                                            //
+//  Copyright (c) by Tom Shane                                //
+//                                                            //
+////////////////////////////////////////////////////////////////
+
+#region //// Using /////////////
+
+////////////////////////////////////////////////////////////////////////////
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+////////////////////////////////////////////////////////////////////////////
+
+#endregion
+
+namespace TomShane.Neoforce.Controls
+{
+
+  #region //// Classes ///////////
+  
+  ////////////////////////////////////////////////////////////////////////////
+  public class WindowGamePadActions: GamePadActions
+  {
+    public GamePadButton Accept = GamePadButton.Start;
+    public GamePadButton Cancel = GamePadButton.Back;
+  }
+  ////////////////////////////////////////////////////////////////////////////
+  
+  ////////////////////////////////////////////////////////////////////////////
+  ///  <include file='Documents/Window.xml' path='Window/Class[@name="Window"]/*' />          
+  public class Window: ModalContainer
+  {
+
+    #region //// Consts ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private const string skWindow       = "Window";
+    private const string lrWindow       = "Control";
+    private const string lrCaption      = "Caption";        
+    private const string lrFrameTop     = "FrameTop";    
+    private const string lrFrameLeft    = "FrameLeft";
+    private const string lrFrameRight   = "FrameRight";
+    private const string lrFrameBottom  = "FrameBottom";
+    private const string lrIcon         = "Icon";  
+      
+    private const string skButton       = "Window.CloseButton";
+    private const string lrButton       = "Control";
+    
+    private const string skShadow       = "Window.Shadow";
+    private const string lrShadow       = "Control";        
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Fields ////////////
+
+    ////////////////////////////////////////////////////////////////////////////    
+    private Button btnClose;
+    private bool closeButtonVisible = true;
+    private bool iconVisible = true;
+    private Texture2D icon = null;
+    private bool shadow = true;
+    private bool captionVisible = true;    
+    private bool borderVisible = true;
+    private byte oldAlpha = 255;
+    private byte dragAlpha = 200;  
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Events ////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+
+    #region //// Properties ////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual Texture2D Icon
+    {
+      get { return icon; }
+      set { icon = value; }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual bool Shadow 
+    { 
+      get { return shadow; } 
+      set { shadow = value; } 
+    }
+    ////////////////////////////////////////////////////////////////////////////      
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual bool CloseButtonVisible
+    {
+      get
+      {
+        return closeButtonVisible;
+      }
+      set
+      {
+        closeButtonVisible = value;
+        if (btnClose != null) btnClose.Visible = value;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public virtual bool IconVisible
+    {
+      get
+      {
+        return iconVisible;
+      }
+      set
+      {
+        iconVisible = value;
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public virtual bool CaptionVisible
+    {
+      get { return captionVisible; }
+      set 
+      { 
+        captionVisible = value; 
+        AdjustMargins();        
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////   
+
+    ////////////////////////////////////////////////////////////////////////////   
+    public virtual bool BorderVisible
+    {
+      get { return borderVisible; }
+      set
+      {
+        borderVisible = value;
+        AdjustMargins();
+      }
+    }
+    //////////////////////////////////////////////////////////////////////////// 
+    
+    //////////////////////////////////////////////////////////////////////////// 
+    public virtual byte DragAlpha
+    {
+      get { return dragAlpha; }
+      set { dragAlpha = value; }
+    }
+    //////////////////////////////////////////////////////////////////////////// 
+
+    #endregion
+
+    #region //// Constructors //////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public Window(Manager manager): base(manager)
+    {
+      CheckLayer(Skin, lrWindow);
+      CheckLayer(Skin, lrCaption);      
+      CheckLayer(Skin, lrFrameTop);      
+      CheckLayer(Skin, lrFrameLeft);
+      CheckLayer(Skin, lrFrameRight);
+      CheckLayer(Skin, lrFrameBottom);
+      CheckLayer(Manager.Skin.Controls[skButton], lrButton);
+      CheckLayer(Manager.Skin.Controls[skShadow], lrShadow);
+      
+      SetDefaultSize(640, 480);
+      SetMinimumSize(100, 75);
+
+      btnClose = new Button(manager);
+      btnClose.Skin = new SkinControl(Manager.Skin.Controls[skButton]);
+      btnClose.Init();
+      btnClose.Detached = true;
+      btnClose.CanFocus = false;      
+      btnClose.Text = null;
+      btnClose.Click += new EventHandler(btnClose_Click);
+      btnClose.SkinChanged += new EventHandler(btnClose_SkinChanged);
+
+      AdjustMargins();      
+      
+      AutoScroll = true;
+      Movable = true;
+      Resizable = true;
+      Center();
+     
+      Add(btnClose, false);   
+      
+      oldAlpha = Alpha;               
+    }   
+    ////////////////////////////////////////////////////////////////////////////             
+
+    #endregion
+    
+    ////////////////////////////////////////////////////////////////////////////             
+    protected override void Dispose(bool disposing)
+    {
+      if (disposing)
+      {       
+      }
+      base.Dispose(disposing);
+    }
+    ////////////////////////////////////////////////////////////////////////////             
+
+    #region //// Methods ///////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    public override void Init()
+    {
+      base.Init();
+
+      SkinLayer l = btnClose.Skin.Layers[lrButton];            
+      btnClose.Width = l.Width - btnClose.Skin.OriginMargins.Horizontal;
+      btnClose.Height = l.Height - btnClose.Skin.OriginMargins.Vertical;
+      btnClose.Left = OriginWidth - Skin.OriginMargins.Right - btnClose.Width + l.OffsetX;                  
+      btnClose.Top = Skin.OriginMargins.Top + l.OffsetY;
+      btnClose.Anchor = Anchors.Top | Anchors.Right;
+
+      //SkinControl sc = new SkinControl(ClientArea.Skin);
+      //sc.Layers[0] = Skin.Layers[lrWindow];
+      //ClientArea.Color = Color.Transparent;
+      //ClientArea.BackColor = Color.Transparent;
+      //ClientArea.Skin = sc;                     
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected internal override void InitSkin()
+    {
+      base.InitSkin();
+      Skin = new SkinControl(Manager.Skin.Controls[skWindow]);
+      AdjustMargins();
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    void btnClose_SkinChanged(object sender, EventArgs e)
+    {
+      btnClose.Skin = new SkinControl(Manager.Skin.Controls[skButton]);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////
+    internal override void Render(Renderer renderer, GameTime gameTime)
+    {      
+      if (Visible && Shadow)
+      {        
+        SkinControl c = Manager.Skin.Controls[skShadow];
+        SkinLayer l = c.Layers[lrShadow];
+
+        Color cl = Color.FromNonPremultiplied(l.States.Enabled.Color.R, l.States.Enabled.Color.G, l.States.Enabled.Color.B, Alpha);
+
+        renderer.Begin(BlendingMode.Default);
+        renderer.DrawLayer(l, new Rectangle(Left - c.OriginMargins.Left, Top - c.OriginMargins.Top, Width + c.OriginMargins.Horizontal, Height + c.OriginMargins.Vertical), cl, 0);
+        renderer.End();
+      }
+      base.Render(renderer, gameTime);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+   
+    ////////////////////////////////////////////////////////////////////////////
+    private Rectangle GetIconRect()
+    {     
+      SkinLayer l1 = Skin.Layers[lrCaption];
+      SkinLayer l5 = Skin.Layers[lrIcon];             
+      
+      int s = l1.Height - l1.ContentMargins.Vertical;
+      return new Rectangle(DrawingRect.Left + l1.ContentMargins.Left + l5.OffsetX,
+                           DrawingRect.Top + l1.ContentMargins.Top + l5.OffsetY,
+                           s, s);
+                                       
+    }
+    ////////////////////////////////////////////////////////////////////////////    
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
+    {
+      SkinLayer l1 = captionVisible ? Skin.Layers[lrCaption] : Skin.Layers[lrFrameTop];      
+      SkinLayer l2 = Skin.Layers[lrFrameLeft];
+      SkinLayer l3 = Skin.Layers[lrFrameRight];
+      SkinLayer l4 = Skin.Layers[lrFrameBottom];      
+      SkinLayer l5 = Skin.Layers[lrIcon];      
+      LayerStates s1, s2, s3, s4;
+      SpriteFont f1 = l1.Text.Font.Resource;
+      Color c1 = l1.Text.Colors.Enabled;                                                              
+                              
+      if ((Focused || (Manager.FocusedControl != null && Manager.FocusedControl.Root == this.Root)) && ControlState != ControlState.Disabled)
+      {
+        s1 = l1.States.Focused;
+        s2 = l2.States.Focused;
+        s3 = l3.States.Focused;
+        s4 = l4.States.Focused;        
+        c1 = l1.Text.Colors.Focused;        
+      }
+      else if (ControlState == ControlState.Disabled)
+      {
+        s1 = l1.States.Disabled;
+        s2 = l2.States.Disabled;
+        s3 = l3.States.Disabled;
+        s4 = l4.States.Disabled;
+        c1 = l1.Text.Colors.Disabled;
+      }
+      else
+      {
+        s1 = l1.States.Enabled;
+        s2 = l2.States.Enabled;
+        s3 = l3.States.Enabled;
+        s4 = l4.States.Enabled;
+        c1 = l1.Text.Colors.Enabled;
+      }
+
+      renderer.DrawLayer(Skin.Layers[lrWindow], rect, Skin.Layers[lrWindow].States.Enabled.Color, Skin.Layers[lrWindow].States.Enabled.Index);
+      
+      if (borderVisible)
+      {
+        renderer.DrawLayer(l1, new Rectangle(rect.Left, rect.Top, rect.Width, l1.Height), s1.Color, s1.Index);
+        renderer.DrawLayer(l2, new Rectangle(rect.Left, rect.Top + l1.Height, l2.Width, rect.Height - l1.Height - l4.Height), s2.Color, s2.Index);      
+        renderer.DrawLayer(l3, new Rectangle(rect.Right - l3.Width, rect.Top + l1.Height, l3.Width, rect.Height - l1.Height - l4.Height), s3.Color, s3.Index);
+        renderer.DrawLayer(l4, new Rectangle(rect.Left, rect.Bottom - l4.Height, rect.Width, l4.Height),  s4.Color, s4.Index);
+     
+        if (iconVisible && (icon != null || l5 != null) && captionVisible)
+        {       
+          Texture2D i = (icon != null) ? icon : l5.Image.Resource;        
+          renderer.Draw(i, GetIconRect(), Color.White);        
+        }
+
+        int icosize = 0;
+        if (l5 != null && iconVisible && captionVisible)
+        {
+          icosize = l1.Height - l1.ContentMargins.Vertical + 4 + l5.OffsetX;
+        }
+        int closesize = 0;
+        if (btnClose.Visible)
+        {
+          closesize = btnClose.Width - (btnClose.Skin.Layers[lrButton].OffsetX);
+        }
+
+        Rectangle r = new Rectangle(rect.Left + l1.ContentMargins.Left + icosize,
+                                    rect.Top + l1.ContentMargins.Top,
+                                    rect.Width - l1.ContentMargins.Horizontal - closesize - icosize,
+                                    l1.Height - l1.ContentMargins.Top - l1.ContentMargins.Bottom);
+        int ox = l1.Text.OffsetX;
+        int oy = l1.Text.OffsetY;
+        renderer.DrawString(f1, Text, r, c1, l1.Text.Alignment, ox, oy, true);
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////                               
+
+    ////////////////////////////////////////////////////////////////////////////
+    void btnClose_Click(object sender, EventArgs e)
+    {      
+      Close(ModalResult = ModalResult.Cancel);
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////           
+    public virtual void Center()
+    {
+      Left = (Manager.ScreenWidth / 2) - (Width / 2);
+      Top = (Manager.ScreenHeight - Height) / 2;
+    }
+    ////////////////////////////////////////////////////////////////////////////           
+
+
+    ////////////////////////////////////////////////////////////////////////////           
+    protected override void OnResize(ResizeEventArgs e)
+    {
+      SetMovableArea();
+      base.OnResize(e);
+    }
+    //////////////////////////////////////////////////////////////////////////// 
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnMoveBegin(EventArgs e)
+    {
+      base.OnMoveBegin(e);
+     
+      try
+      {     
+        oldAlpha = Alpha;   
+        Alpha = dragAlpha;
+      }
+      catch
+      {
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    protected override void OnMoveEnd(EventArgs e)
+    {
+      base.OnMoveEnd(e);
+      try
+      {
+        Alpha = oldAlpha;
+      }
+      catch
+      {
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+    
+    ////////////////////////////////////////////////////////////////////////////  
+    protected override void OnDoubleClick(EventArgs e)
+    {
+      base.OnDoubleClick(e);
+                  
+      MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs) e : new MouseEventArgs();
+      
+      if (IconVisible && ex.Button == MouseButton.Left)
+      {
+        Rectangle r = GetIconRect();
+        r.Offset(AbsoluteLeft, AbsoluteTop);
+        if (r.Contains(ex.Position))
+        {
+          Close();
+        }
+      }  
+    }
+    ////////////////////////////////////////////////////////////////////////////     
+    
+    ////////////////////////////////////////////////////////////////////////////    
+    protected override void AdjustMargins()
+    {                  
+       
+      if (captionVisible && borderVisible)
+      {
+        ClientMargins = new Margins(Skin.ClientMargins.Left, Skin.Layers[lrCaption].Height, Skin.ClientMargins.Right, Skin.ClientMargins.Bottom);                
+      }
+      else if (!captionVisible && borderVisible)     
+      {
+        ClientMargins = new Margins(Skin.ClientMargins.Left, Skin.ClientMargins.Top, Skin.ClientMargins.Right, Skin.ClientMargins.Bottom);        
+      }
+      else if (!borderVisible)
+      {
+        ClientMargins = new Margins(0, 0, 0, 0);        
+      }
+      
+      if (btnClose != null)
+      {
+        btnClose.Visible = closeButtonVisible && captionVisible && borderVisible;
+      }              
+                
+      SetMovableArea();
+      
+      base.AdjustMargins();
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////
+    private void SetMovableArea()
+    {
+      if (captionVisible && borderVisible)
+      {
+        MovableArea = new Rectangle(Skin.OriginMargins.Left, Skin.OriginMargins.Top, Width, Skin.Layers[lrCaption].Height - Skin.OriginMargins.Top);
+      }
+      else if (!captionVisible)
+      {
+        MovableArea = new Rectangle(0, 0, Width, Height);
+      }
+    }
+    ////////////////////////////////////////////////////////////////////////////
+
+    #endregion
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+
+  #endregion
+  
+}