Download source files:
http://www.jkofsp.net/files/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using Microsoft.DirectX.DirectDraw;
using Takaku.Simulation;

namespace Takaku.UI
{
   public abstract class Element : ISimulationRemovable
   {
       public int X, Y, DX, DY;
       public Cached<int> FullX, FullY;
       public Cached<int> MouseX, MouseY;
       public Cached<bool> MouseInside, MouseInsideTmp;
       public bool Visible, Enabled;
       public Cached<bool> TrueVisible, TrueEnabled;

       public Element Parent; // controls
       public List<Element> Children = new List<Element>(); // forms

       public Cached<bool> OnMouseButtonDown, OnMouseButtonUp, OnMouseButtonDownTmp;

       public Element(int x, int y, int dx, int dy)
       {
           X = x;
           Y = y;
           DX = dx;
           DY = dy;

           FullX = new Cached<int>(() => Parent == null ? X : Parent.X + X);
           FullY = new Cached<int>(() => Parent == null ? Y : Parent.Y + Y);

           MouseX = new Cached<int>(() => Core.TheCore.MouseX - (Parent == null ? 0 : Parent.X) - X);
           MouseY = new Cached<int>(() => Core.TheCore.MouseY - (Parent == null ? 0 : Parent.Y) - Y);

           MouseInside = new Cached<bool>(() =>
               {
                   if (MouseX < 0 || MouseX >= DX || MouseY < 0 || MouseY >= DY
                       || (!TrueVisible))
                       return false;
                   // truely visible:
                   if (Parent == null) // a form
                   {
                       for (int i = Core.TheCore.Root.Count - 1; i >= 0; i--)
                       {
                           Element e = Core.TheCore.Root[i];
                           if (e == this)
                               break;
                           else
                               if (e.MouseX >= 0 && e.MouseX < e.DX && e.MouseY >= 0 && e.MouseY < e.DY
                                   && e.TrueVisible)
                                   return false;
                       }
                       for (int i = Children.Count - 1; i >= 0; i--)
                       {
                           Element e = Children[i];
                           if (e.MouseX >= 0 && e.MouseX < e.DX && e.MouseY >= 0 && e.MouseY < e.DY
                               && e.TrueVisible)
                               return false;
                       }
                       return MouseX >= 0 && MouseX < DX && MouseY >= 0 && MouseY < DY;
                   }
                   else // a control
                   {
                       for (int i = Core.TheCore.Root.Count - 1; i >= 0; i--)
                       {
                           Element e = Core.TheCore.Root[i];
                           if (e == Parent)
                               break;
                           else
                               if (e.MouseX >= 0 && e.MouseX < e.DX && e.MouseY >= 0 && e.MouseY < e.DY
                                   && e.TrueVisible)
                                   return false;
                       }
                       return MouseX >= 0 && MouseX < DX && MouseY >= 0 && MouseY < DY;                        
                   }
               });

           MouseInsideTmp = new Cached<bool>(() =>
               {
                   if (MouseX < 0 || MouseX >= DX || MouseY < 0 || MouseY >= DY
                          || (!TrueVisible))
                       return false;
                   // truely visible:
                   if (Parent == null) // a form
                   {
                       for (int i = Core.TheCore.Root.Count - 1; i >= 0; i--)
                       {
                           Element e = Core.TheCore.Root[i];
                           if (e == this)
                               return MouseX >= 0 && MouseX < DX && MouseY >= 0 && MouseY < DY;
                           else
                               if (e.MouseX >= 0 && e.MouseX < e.DX && e.MouseY >= 0 && e.MouseY < e.DY
                                   && e.TrueVisible)
                                   return false;
                       }
                       return false;
                   }
                   else // a control
                       return MouseInside;
               });

           Visible = true;
           Enabled = true;

           TrueVisible = new Cached<bool>(() => (Parent == null ? true : Parent.Visible) && Visible);
           TrueEnabled = new Cached<bool>(() => (Parent == null ? true : Parent.Enabled) && Enabled);
           
           OnMouseButtonDown = new Cached<bool>(() => (TrueEnabled && MouseInside) ? Core.TheCore.MouseButtonDown : false);
           OnMouseButtonUp = new Cached<bool>(() => (TrueEnabled && MouseInside) ? Core.TheCore.MouseButtonUp : false);
           OnMouseButtonDownTmp = new Cached<bool>(() => (TrueEnabled && MouseInsideTmp) ? Core.TheCore.MouseButtonDown : false);
       }

       public virtual void RemoveSimulation()
       {
           FullX.Remove();
           FullY.Remove();
           MouseX.Remove();
           MouseY.Remove();
           MouseInside.Remove();
           MouseInsideTmp.Remove();
           TrueVisible.Remove();
           TrueEnabled.Remove();
           OnMouseButtonDown.Remove();
           OnMouseButtonUp.Remove();
           OnMouseButtonDownTmp.Remove();
       }

       public abstract Element Update(); // returns a form to be bringed to the top
       public abstract void Render(Surface backSurface);
   }

   public class Core
   {
       public static Core TheCore;

       public bool AllowDragging;

       public int DX, DY;

       public int MouseDX, MouseDY, MouseDZ, MouseX, MouseY;
       public bool MouseLeftButton, MouseRightButton, MouseMiddleButton;
       public bool MouseButtonDown, MouseButtonUp;

       public Cached<bool> MouseOutside;

       public List<Element> Root = new List<Element>();

       public Core(int dx, int dy, bool allowDragging)
       {
           AllowDragging = allowDragging;

           DX = dx;
           DY = dy;

           MouseOutside = new Cached<bool>(() =>
               {
                   foreach (Element e in Root)
                       if (e.MouseInsideTmp || ((Form)e).IsDragging)
                           return false;

                   return true;
               });
       }

       public void Update()
       {
           List<Element> tmps = new List<Element>();
           foreach (Element e in Root)
           {
               Element tmp = e.Update();
               if (tmp != null)
                   tmps.Add(tmp);

               foreach (Element f in e.Children)
                   f.Update();
           }
           foreach (Element tmp in tmps)
           {
               Root.Remove(tmp);
               Root.Add(tmp);
           }
       }

       public void Render(Surface backSurface)
       {
           foreach (Element e in Root)
           {
               if (e.TrueVisible)
                   e.Render(backSurface);

               foreach (Element f in e.Children)
                   if (f.TrueVisible)
                       f.Render(backSurface);
           }
       }
   }

   public class Form : Element
   {
       public Color BorderColor, FillColor;

       public State<bool> IsDragging;

       public Form(int x, int y, int dx, int dy)
           : base(x, y, dx, dy)
       {
           Core.TheCore.Root.Add(this);

           BorderColor = Color.FromArgb(unchecked((int)0xFF0000ff));
           FillColor = Color.FromArgb(unchecked((int)0xFF000000));

           IsDragging = new State<bool>(false,
               state =>
               {
                   if (!Core.TheCore.AllowDragging)
                       return false;

                   if (OnMouseButtonDown && Core.TheCore.MouseLeftButton)
                       return true;
                   if (OnMouseButtonUp)
                       return false;
                   return state;
               });
       }

       public override void RemoveSimulation()
       {
           IsDragging.Remove();

           base.RemoveSimulation();
       }

       public override Element Update() // returns a form to be bringed to the top
       {
           if (OnMouseButtonDownTmp)
               return this;

           if (IsDragging)
           {
               X += Core.TheCore.MouseDX;
               Y += Core.TheCore.MouseDY;
           }
           
           if (X < 0)
               X = 0;
           if (Y < 0)
               Y = 0;
           if (X + DX >= Core.TheCore.DX)
               X = Core.TheCore.DX - DX;
           if (Y + DY >= Core.TheCore.DY)
               Y = Core.TheCore.DY - DY;
           if (DX > Core.TheCore.DX)
               DX = Core.TheCore.DX;
           if (DY > Core.TheCore.DY)
               DY = Core.TheCore.DY;
           
           return null;
       }

       public override void Render(Surface backSurface)
       {
           backSurface.ForeColor = BorderColor;
           backSurface.FillColor = FillColor;
           backSurface.DrawRoundedBox(X, Y, X + DX, Y + DY, 5, 5);
       }
   }

   public enum ButtonState
   {
       Normal,
       Hovered,
       Pressed,

       PressedToHovered,
   }

   public class Button : Element
   {
       public string Text;
       public Font Font;
       public int TextX, TextY, TextDX, TextDY;
       bool PictureMode;
       public Color BorderColor, FillColor, TextColor;
       public Color HoveredBorderColor, HoveredFillColor, HoveredTextColor;
       public Color PressedBorderColor, PressedFillColor, PressedTextColor;
       public Surface Picture, HoveredPicture, PressedPicture;
       public State<ButtonState> State;

       private Diff<ButtonState> dState;
       public Cached<bool> OnMouseClick;

       public Button(Form form, int x, int y, int dx, int dy)
           : base(x, y, dx, dy)
       {
           form.Children.Add(this);
           Parent = form;
           
           Text = "Button";
           Font = new Font("Arial", 9.0f);
           TextX = 5;
           TextY = 5;
           TextDX = dx - 10;
           TextDY = dy - 10;

           BorderColor = Color.FromArgb(unchecked((int)0xFF0000ff));
           FillColor = Color.FromArgb(unchecked((int)0xFF000000));
           TextColor = Color.FromArgb(unchecked((int)0xFFffff00));

           HoveredBorderColor = Color.FromArgb(unchecked((int)0xFFff0000));
           HoveredFillColor = Color.FromArgb(unchecked((int)0xFFffff00));
           HoveredTextColor = Color.FromArgb(unchecked((int)0xFFff0000));

           PressedBorderColor = Color.FromArgb(unchecked((int)0xFF00ff00));
           PressedFillColor = Color.FromArgb(unchecked((int)0xFFff0000));
           PressedTextColor = Color.FromArgb(unchecked((int)0xFF0000ff));

           State = new State<ButtonState>(ButtonState.Normal,
               state =>
               {
                   if (!TrueEnabled)
                       return ButtonState.Normal;
                   if (state == ButtonState.Normal)
                   {
                       if (MouseInside)
                       {
                           if (Core.TheCore.MouseLeftButton)
                               return ButtonState.Pressed;
                           else
                               return ButtonState.Hovered;
                       }
                       else
                           return ButtonState.Normal;
                   }
                   else if (state == ButtonState.Hovered)
                   {
                       if (MouseInside)
                       {
                           if (Core.TheCore.MouseLeftButton)
                               return ButtonState.Pressed;
                           else
                               return ButtonState.Hovered;
                       }
                       else
                           return ButtonState.Normal;
                   }
                   else if (state == ButtonState.Pressed)
                   {
                       if (Core.TheCore.MouseLeftButton)
                           return ButtonState.Pressed;
                       else
                       {
                           if (MouseInside)
                               return ButtonState.Hovered;
                           else
                               return ButtonState.Normal;
                       }
                   }
                   else
                       return ButtonState.Normal;
               });

           Diff<ButtonState>.FuncSub = new Func<ButtonState, ButtonState, ButtonState>((a, b) => (a == ButtonState.Hovered && b == ButtonState.Pressed) ? ButtonState.PressedToHovered : a);
           dState = new Diff<ButtonState>(ButtonState.Normal, () => State);
           OnMouseClick = new Cached<bool>(() => dState == ButtonState.PressedToHovered ? true : false);
       }

       public override void RemoveSimulation()
       {
           State.Remove();
           dState.Remove();
           OnMouseClick.Remove();

           base.RemoveSimulation();
       }

       public override Element Update() // returns a form to be bringed to the top
       {
           return null;
       }

       public override void Render(Surface backSurface)        
       {
           if (!PictureMode)
           {
               if (State == ButtonState.Normal)
               {
                   backSurface.ForeColor = BorderColor;
                   backSurface.FillColor = FillColor;
               }
               else if (State == ButtonState.Hovered)
               {
                   backSurface.ForeColor = HoveredBorderColor;
                   backSurface.FillColor = HoveredFillColor;
               }
               else if (State == ButtonState.Pressed)
               {
                   backSurface.ForeColor = PressedBorderColor;
                   backSurface.FillColor = PressedFillColor;
               }
               backSurface.DrawRoundedBox(FullX, FullY, FullX + DX, FullY + DY, 5, 5);

               Color textColor = new Color();
               if (State == ButtonState.Normal)
                   textColor = TextColor;
               else if (State == ButtonState.Hovered)
                   textColor = HoveredTextColor;
               else if (State == ButtonState.Pressed)
                   textColor = PressedTextColor;
               
               IntPtr hdc = backSurface.GetDc();
               Graphics g = Graphics.FromHdc(hdc);
               g.DrawString(
                   Text,
                   Font,
                   new SolidBrush(textColor),
                   new RectangleF((float)FullX + TextX, (float)FullY + TextY, (float)TextDX, (float)TextDY));
               backSurface.ReleaseDc(hdc);
           }
           else // PictureMode
           {
               Surface surf = null;
               if (State == ButtonState.Normal)
               {
                   surf = Picture;
               }
               else if (State == ButtonState.Hovered)
               {
                   surf = HoveredPicture;
               }
               else if (State == ButtonState.Pressed)
               {
                   surf = PressedPicture;
               }
               backSurface.Draw(
                   new Rectangle(FullX, FullY, DX, DY),
                   surf,
                   DrawFlags.KeySource | DrawFlags.Wait);
           }
       }
   }

   public class TextBox : Element
   {
       public Bind<string> Text;
       public Font Font;
       public Color BorderColor, FillColor, TextColor;
       public bool Transparent;

       public TextBox(Form form, int x, int y, int dx, int dy)
           : base(x, y, dx, dy)
       {
           form.Children.Add(this);
           Parent = form;

           Font = new Font("Arial", 9.0f);
           BorderColor = Color.FromArgb(unchecked((int)0xFF0000ff));
           FillColor = Color.FromArgb(unchecked((int)0xFF000000));
           TextColor = Color.FromArgb(unchecked((int)0xFFffff00));
           Transparent = false;
       }

       public override Element Update() // returns a form to be bringed to the top
       {
           return null;
       }

       public override void Render(Surface backSurface)
       {
           if (!Transparent)
           {
               backSurface.ForeColor = BorderColor;
               backSurface.FillColor = FillColor;
               backSurface.DrawRoundedBox(FullX, FullY, FullX + DX, FullY + DY, 5, 5);
           }

           IntPtr hdc = backSurface.GetDc();
           Graphics g = Graphics.FromHdc(hdc);
           g.DrawString(
               Text(),
               Font,
               new SolidBrush(TextColor),
               new RectangleF((float)FullX + 5, (float)FullY + 5, (float)DX - 10, (float)DY - 10));
           backSurface.ReleaseDc(hdc);
       }
   }

   public class PictureBox : Element
   {
       public Surface Surface;

       public PictureBox(Form form, int x, int y, int dx, int dy)
           : base(x, y, dx, dy)
       {
           form.Children.Add(this);
           Parent = form;

           Surface = null;
       }

       public override Element Update() // returns a form to be bringed to the top
       {
           return null;
       }

       public override void Render(Surface backSurface)
       {
           backSurface.Draw(
               new Rectangle(FullX, FullY, DX, DY),
               Surface,
               DrawFlags.KeySource | DrawFlags.Wait);
       }
   }

   public class ListBox : Element
   {
       public Font Font;
       public Color BorderColor, FillColor, TextColor;
       public Color SelectedBorderColor, SelectedFillColor, SelectedTextColor;
       public bool Transparent;
       public List<List<string>> Items = new List<List<string>>();
       public int? SelectedIndex;
       public int LineDY;
       public List<int> ColumnsX = new List<int>();

       public ListBox(Form form, int x, int y, int dx, int dy)
           : base(x, y, dx, dy)
       {
           form.Children.Add(this);
           Parent = form;

           Font = new Font("Arial", 9.0f);
           BorderColor = Color.FromArgb(unchecked((int)0xFF0000ff));
           FillColor = Color.FromArgb(unchecked((int)0xFF000000));
           TextColor = Color.FromArgb(unchecked((int)0xFFffff00));
           SelectedBorderColor = Color.FromArgb(unchecked((int)0xFFff0000));
           SelectedFillColor = Color.FromArgb(unchecked((int)0xFFffff00));
           SelectedTextColor = Color.FromArgb(unchecked((int)0xFF000000));
           Transparent = false;
           SelectedIndex = null;
           LineDY = 15;
       }

       public override Element Update() // returns a form to be bringed to the top
       {
           if (Core.TheCore.MouseLeftButton && OnMouseButtonDown)
           {
               SelectedIndex = MouseY / LineDY;
           }

           if (SelectedIndex >= Items.Count)
               SelectedIndex = null;

           return null;
       }

       public override void Render(Surface backSurface)
       {
           if (!Transparent)
           {
               backSurface.ForeColor = BorderColor;
               backSurface.FillColor = FillColor;
               backSurface.DrawBox(FullX, FullY, FullX + DX, FullY + DY);
           }

           for (int i = 0; i < Items.Count; i++) // line
           {
               if (SelectedIndex != null && SelectedIndex == i)
               {
                   backSurface.ForeColor = SelectedBorderColor;
                   backSurface.FillColor = SelectedFillColor;
                   backSurface.DrawBox(
                       FullX,
                       FullY + SelectedIndex.Value * LineDY,
                       FullX + DX,
                       FullY + SelectedIndex.Value * LineDY + LineDY);
               }
               for (int j = 0; j < Items[i].Count; j++) // column
               {
                   IntPtr hdc = backSurface.GetDc();
                   Graphics g = Graphics.FromHdc(hdc);
                   g.DrawString(
                       Items[i][j],
                       Font,
                       new SolidBrush((SelectedIndex == null || SelectedIndex != i) ? TextColor : SelectedTextColor),
                       new RectangleF(
                           (float)(FullX + ColumnsX[j]),
                           (float)(FullY + LineDY * i),
                           (float)(((j < ColumnsX.Count - 1) ? ColumnsX[j + 1] : DX) - ColumnsX[j]),
                           (float)LineDY));
                   backSurface.ReleaseDc(hdc);
               }
           }
       }
   }

   public class ProgressBar : Element
   {
       public Bind<double> Progress;
       public Color BorderColor, BackColor, ForeColor;

       public ProgressBar(Form form, int x, int y, int dx, int dy)
           : base(x, y, dx, dy)
       {
           form.Children.Add(this);
           Parent = form;

           BorderColor = Color.FromArgb(unchecked((int)0xFF0000ff));
           BackColor = Color.FromArgb(unchecked((int)0xFFffffff));
           ForeColor = Color.FromArgb(unchecked((int)0xFF00ff00));
       }

       public override void Render(Surface backSurface)
       {
           backSurface.ForeColor = BorderColor;
           backSurface.FillColor = BackColor;
           backSurface.DrawBox(FullX, FullY, FullX + DX, FullY + DY);

           backSurface.ForeColor = ForeColor;
           backSurface.FillColor = ForeColor;
           backSurface.DrawBox(FullX + 1, FullY + 1, FullX + (int)(Progress() * DX) - 1, FullY + DY - 1);
       }

       public override Element Update() // returns a form to be bringed to the top
       {
           return null;
       }
   }
}