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;
using Microsoft.DirectX.Direct3D;
using Takaku.Simulation;

namespace Takaku.UI3D
{
   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(Device dev);
   }

   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 Microsoft.DirectX.Direct3D.Font D3DXFont;

       public Core(int dx, int dy, bool allowDragging, Device dev)
       {
           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;
               });

           D3DXFont = new Microsoft.DirectX.Direct3D.Font(dev, new System.Drawing.Font("Arial", 10.0f));
       }

       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(Device dev)
       {
           foreach (Element e in Root)
           {
               if (e.TrueVisible)
                   e.Render(dev);

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

       public struct MyVertex
       {
           public Vector4 X;
           public int Color;
           public MyVertex(float x, float y, int color)
           {
               X = new Vector4(x, y, 0.0f, 1.0f);
               Color = color;
           }

           public static readonly VertexFormats Format = VertexFormats.Transformed /*PositionWではなく!*/ | VertexFormats.Diffuse;
       }

       public static void DrawRect(Device dev, int x1, int y1, int x2, int y2, Color color)
       {
           VertexBuffer vb = new VertexBuffer(typeof(MyVertex), 8, dev, Usage.None, MyVertex.Format, Pool.Managed);
           MyVertex[] vert = (MyVertex[])vb.Lock(0, LockFlags.None);

           vert[0] = new MyVertex((float)x1, (float)y1, color.ToArgb());
           vert[1] = new MyVertex((float)x2, (float)y1, color.ToArgb());

           vert[2] = new MyVertex((float)x1, (float)y2, color.ToArgb());
           vert[3] = new MyVertex((float)x2, (float)y2, color.ToArgb());

           vert[4] = new MyVertex((float)x1, (float)y1, color.ToArgb());
           vert[5] = new MyVertex((float)x1, (float)y2, color.ToArgb());

           vert[6] = new MyVertex((float)x2, (float)y1, color.ToArgb());
           vert[7] = new MyVertex((float)x2, (float)y2, color.ToArgb());

           vb.Unlock();

           dev.TextureState[0].ColorArgument1 = TextureArgument.Diffuse;
           dev.TextureState[0].ColorOperation = TextureOperation.SelectArg1;
           dev.SetStreamSource(0, vb, 0);
           dev.VertexFormat = MyVertex.Format;
           dev.DrawPrimitives(PrimitiveType.LineList, 0, 4);
       }

       public static void FillRect(Device dev, int x1, int y1, int x2, int y2, Color color)
       {
           VertexBuffer vb = new VertexBuffer(typeof(MyVertex), 6, dev, Usage.None, MyVertex.Format, Pool.Managed);
           MyVertex[] vert = (MyVertex[])vb.Lock(0, LockFlags.None);

           vert[0] = new MyVertex((float)x1, (float)y1, color.ToArgb());
           vert[1] = new MyVertex((float)x2, (float)y1, color.ToArgb());
           vert[2] = new MyVertex((float)x1, (float)y2, color.ToArgb());

           vert[3] = new MyVertex((float)x2, (float)y2, color.ToArgb());
           vert[4] = new MyVertex((float)x1, (float)y2, color.ToArgb());
           vert[5] = new MyVertex((float)x2, (float)y1, color.ToArgb());

           vb.Unlock();

           dev.TextureState[0].ColorArgument1 = TextureArgument.Diffuse;
           dev.TextureState[0].ColorOperation = TextureOperation.SelectArg1;
           dev.SetStreamSource(0, vb, 0);
           dev.VertexFormat = MyVertex.Format;
           dev.DrawPrimitives(PrimitiveType.TriangleList, 0, 2);
       }
   }

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

       public bool IsDragging;
       private int OldMouseX, OldMouseY;

       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));
       }

       public override void RemoveSimulation()
       {
           base.RemoveSimulation();
       }

       public override Element Update() // returns a form to be bringed to the top
       {
           if (Core.TheCore.AllowDragging)
           {
               if (OnMouseButtonDown)
               {
                   IsDragging = true;
                   OldMouseX = MouseX;
                   OldMouseY = MouseY;
               }
               if (Core.TheCore.MouseButtonUp)
               {
                   IsDragging = false;
               }

               if (IsDragging)
               {
                   X += MouseX - OldMouseX;
                   Y += MouseY - OldMouseY;
                   
                   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;
               }
           }

           if (OnMouseButtonDownTmp)
               return this;
           return null;
       }

       public override void Render(Device dev)
       {
           Core.FillRect(dev, X, Y, X + DX, Y + DY, FillColor);
           Core.DrawRect(dev, X, Y, X + DX, Y + DY, BorderColor);
       }
   }

   public enum ButtonState
   {
       Normal,
       Hovered,
       Pressed,

       PressedToHovered,
   }

   public class Button : Element
   {
       public string Text;
       //public int TextX, TextY, TextDX, TextDY;
       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";

           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(Device dev)        
       {
           Color foreColor = new Color(), fillColor = new Color();
           if (State == ButtonState.Normal)
           {
               foreColor = BorderColor;
               fillColor = FillColor;
           }
           else if (State == ButtonState.Hovered)
           {
               foreColor = HoveredBorderColor;
               fillColor = HoveredFillColor;
           }
           else if (State == ButtonState.Pressed)
           {
               foreColor = PressedBorderColor;
               fillColor = PressedFillColor;
           }
           Core.FillRect(dev, FullX, FullY, FullX + DX, FullY + DY, fillColor);
           Core.DrawRect(dev, FullX, FullY, FullX + DX, FullY + DY, foreColor);

           Color textColor = new Color();
           if (State == ButtonState.Normal)
               textColor = TextColor;
           else if (State == ButtonState.Hovered)
               textColor = HoveredTextColor;
           else if (State == ButtonState.Pressed)
               textColor = PressedTextColor;

           Core.TheCore.D3DXFont.DrawText(null,
               Text,
               new Rectangle(FullX, FullY, DX, DY),
               DrawTextFormat.Center | DrawTextFormat.VerticalCenter,
               textColor);
       }
   }

   public class TextBox : Element
   {
       public Bind<string> Text;
       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;

           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(Device dev)
       {
           if (!Transparent)
           {
               Core.FillRect(dev, FullX, FullY, FullX + DX, FullY + DY, FillColor);
               Core.DrawRect(dev, FullX, FullY, FullX + DX, FullY + DY, BorderColor);
           }

           Core.TheCore.D3DXFont.DrawText(null,
               Text(),
               new Rectangle(FullX + 5, FullY + 5, DX - 10, DY - 10),
               DrawTextFormat.WordBreak,
               TextColor);
       }
   }

   public class ListBox : Element
   {
       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;

           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(Device dev)
       {
           if (!Transparent)
           {
               Core.FillRect(dev, FullX, FullY, FullX + DX, FullY + DY, FillColor);
               Core.DrawRect(dev, FullX, FullY, FullX + DX, FullY + DY, BorderColor);
           }

           for (int i = 0; i < Items.Count; i++) // line
           {
               if (SelectedIndex != null && SelectedIndex == i)
               {
                   Core.FillRect(dev,
                       FullX,
                       FullY + SelectedIndex.Value * LineDY,
                       FullX + DX,
                       FullY + SelectedIndex.Value * LineDY + LineDY,
                       SelectedFillColor);
                   Core.DrawRect(dev,
                       FullX,
                       FullY + SelectedIndex.Value * LineDY,
                       FullX + DX,
                       FullY + SelectedIndex.Value * LineDY + LineDY,
                       SelectedBorderColor);
               }
               for (int j = 0; j < Items[i].Count; j++) // column
               {                    
                   Core.TheCore.D3DXFont.DrawText(null,
                       Items[i][j],
                       new Rectangle(FullX + ColumnsX[j], FullY + LineDY * i, ((j < ColumnsX.Count - 1) ? ColumnsX[j + 1] : DX) - ColumnsX[j], LineDY),
                       DrawTextFormat.None,
                       (SelectedIndex == null || SelectedIndex != i) ? TextColor : SelectedTextColor);
               }
           }
       }
   }

   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(Device dev)
       {
           Core.FillRect(dev, FullX, FullY, FullX + DX, FullY + DY, BackColor);
           Core.FillRect(dev, FullX, FullY, FullX + (int)(Progress() * DX), FullY + DY, ForeColor);
           Core.DrawRect(dev, FullX, FullY, FullX + DX, FullY + DY, BorderColor);
       }

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