root/trunk/luigi/gui.d

//---------------------------------------------------------------------
/**
   Luigi is an OpenGL based GUI library.
   
   The goal is to provide a simple but flexible way to add a simple
   GUI to an OpenGL program.

   Luigi supports themes and input adaptors.  Themes give you a way
   to customize the look of GUI.  Input adaptors do the work of
   taking events from the OS or from a windowing toolkit like GLD, and
   turning them into something Luigi can use.
*/ 
//---------------------------------------------------------------------
/*
  luigi/gui.d -- main import file for 'luigi' user interface library.
  version 0.5, December 3, 2006

  Copyright (C) 2006 William V. Baxter III

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any
  damages arising from the use of this software.

  Permission is granted to anyone to use this software for any
  purpose, including commercial applications, and to alter it and
  redistribute it freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must
     not claim that you wrote the original software. If you use this
     software in a product, an acknowledgment in the product
     documentation would be appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must
     not be misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.

  William Baxter wbaxter@gmail.com
*/
//----------------------------------------------------------------------------
/*
  WARNING: Because of how overloading works in D (at least as of DMD 0.176),
           *******************************************
           ** ALL SETTERS MUST COME BEFORE GETTERS  **
           *******************************************
  I.e.

          int value(int newval)

   should always appear before 

          int value()

   Otherwise, signal.connect(value) will silently connect to the
   getter rather than the setter.
 */
module luigi.gui;

import luigi.opengl;
import luigi.base;
import luigi.event;
import luigi.font;
import luigi.theme;
static import luigi.themes.std;
import luigi.arranger;
import luigi.adapter;
//import sslot.signal;
import luigi.signalobj;

//import adapter = luigi.adapter.glfw;

import drawsys = luigi.gldraw;

import math = std.math;
import string = std.string;
import std.ctype : isprint;
import std.uni : isUniAlpha;
static import std.path;
static import std.file;

// Just for debug?
import std.stdio : writefln;


/** 
 * The singleton master object.  
 * Holds GUI globals including the theme, the input adapter, and keeps track
 * of all the top-level Frames and Overlays.
 */
class Luigi
{
    /// Return the singleton instance
    static Luigi opCall() 
    {
        static Luigi instance = null;
        if (!instance) instance = new Luigi;
        return instance;
    }

    /// Return the singleton instance
    static Luigi inst() {
        return Luigi();
    }

    /// Set the theme
    Theme theme(Theme th) { return m_theme=th; }
    /// Get the current theme
    Theme theme() { 
        if (!m_theme) {
            m_theme = new luigi.themes.std.StdTheme();
        }
        return m_theme; 
    }

    /// Add a location where themes should look for resource files
    /// (e.g. images, textures, etc.  The built-in themes look for some files 
    /// relative to the luigi base directory, so you may need to add it to
    /// your path.)  The current directory '.' is the only thing on the resource path
    /// by default.
    void add_resource_location(char[] path) {
        char[] workp = path.dup;
        if (workp[$-1..$] != std.path.sep) { workp ~= std.path.sep; }
        m_resource_path ~= workp;
    }
    /// Add a location where themes should look for resource files to the beginning of
    /// the resource path.
    /// (e.g. images, textures, etc.  The built-in themes look for some files 
    /// relative to the luigi base directory, so you may need to add it to
    /// your path.)  The current directory '.' is the only thing on the resource path
    /// by default.
    void prepend_resource_location(char[] path) {
        char[] workp = path.dup;
        if (workp[$-1..$] != std.path.sep) { workp ~= std.path.sep; }
        m_resource_path = workp ~ m_resource_path;
    }
    /// Get the current resource path.  This is a list of paths where Luigi 
    /// should look for resource files like images.
    char[][] resource_path() {
        return m_resource_path;
    }
    /// Finds the specified resource file on the resource path.  This could be 
    /// an image or anything else.  Used to find theme textures internally.
    /// A list of names passed in will treated as alternative names for the same
    /// resource file and searched for in the order provided.
    /// Returns null if the resource could not be located on the resource path.
    char[] find_resource_location(char[][] name...) {
        foreach(char[] aname; name) {
            foreach(char[] p; m_resource_path) {
                char[] fullpath = p ~ aname;
                if (std.file.exists(fullpath)) {
                    return fullpath;
                }
            }
        }
        return null;
    }

    /** Add a top level overlay.  
        This is called automatically by Overlay, so typically there is no 
        reason for users to call it themselves.
    */
    void add_overlay(Overlay ov) {
        m_guis ~= ov;

        if (!m_inputsys) {
            throw new GUIException("Must set Luigi().adapter before creating Overlays");
        }

        // add in top-level input hooks
        with (m_inputsys) {
            addSysKeyCallback(&ov.on_sys_key);
            addSysMouseButtonCallback(&ov.on_sys_mouse_button) ;
            addMouseMoveCallback(&ov.on_sys_mouse_move);
            addMouseWheelCallback(&ov.on_sys_mouse_wheel);
            addWindowSizeCallback(&ov.on_sys_window_size);
            addWindowCloseCallback(&ov.on_sys_window_close);
        }
    }

    /** Returns the size of the specified window */
    Size get_window_size(WindowHandle win) {
        return m_inputsys.get_window_size(win);
    }

    /** Set the current input adapter */
    void adapter(InputAdapter inputsys) {
        m_inputsys = inputsys;
    }
    /** Get the current input adapter */
    InputAdapter adapter() {
        return m_inputsys;
    }



private:

    this() {
        add_resource_location(".");
    }

    ~this() {
    }

    Overlay[] m_guis;
    InputAdapter m_inputsys;
    Theme m_theme;
    char[][] m_resource_path;
}


/// Add a user-level input callback functions and delegates
void add_key_callback(KeyEventFn cb)                  {Luigi().adapter.addKeyCallback(cb);}
void add_key_callback(KeyEventDg cb)                  {Luigi().adapter.addKeyCallback(cb);}
void add_mouse_button_callback(MouseButtonEventFn cb) {Luigi().adapter.addMouseButtonCallback(cb); }
void add_mouse_button_callback(MouseButtonEventDg cb) {Luigi().adapter.addMouseButtonCallback(cb);}
void add_mouse_move_callback(MouseMoveEventFn cb)     {Luigi().adapter.addMouseMoveCallback(cb);}
void add_mouse_move_callback(MouseMoveEventDg cb)     {Luigi().adapter.addMouseMoveCallback(cb);}
void add_mouse_wheel_callback(MouseWheelEventFn cb)   {Luigi().adapter.addMouseWheelCallback(cb);}
void add_mouse_wheel_callback(MouseWheelEventDg cb)   {Luigi().adapter.addMouseWheelCallback(cb);}
void add_window_size_callback(WindowSizeEventFn cb)   {Luigi().adapter.addWindowSizeCallback(cb);}
void add_window_size_callback(WindowSizeEventDg cb)   {Luigi().adapter.addWindowSizeCallback(cb);}
void add_window_close_callback(WindowCloseEventFn cb) {Luigi().adapter.addWindowCloseCallback(cb);}
void add_window_close_callback(WindowCloseEventDg cb) {Luigi().adapter.addWindowCloseCallback(cb);}
/// Add a system-level input callback function or delegate -- Use with caution!
void add_sys_key_callback(KeyEventFn cb)                  {Luigi().adapter.addSysKeyCallback(cb);}
void add_sys_key_callback(KeyEventDg cb)                  {Luigi().adapter.addSysKeyCallback(cb);}
void add_sys_mouse_button_callback(MouseButtonEventFn cb) {Luigi().adapter.addSysMouseButtonCallback(cb); }
void add_sys_mouse_button_callback(MouseButtonEventDg cb) {Luigi().adapter.addSysMouseButtonCallback(cb); }


/// Remove installed callbacks
void remove_key_callback(KeyEventFn cb)                  {Luigi().adapter.removeKeyCallback(cb);}
void remove_key_callback(KeyEventDg cb)                  {Luigi().adapter.removeKeyCallback(cb);}
void remove_mouse_button_callback(MouseButtonEventFn cb) {Luigi().adapter.removeMouseButtonCallback(cb); }
void remove_mouse_button_callback(MouseButtonEventDg cb) {Luigi().adapter.removeMouseButtonCallback(cb); }
void remove_mouse_move_callback(MouseMoveEventFn cb)     {Luigi().adapter.removeMouseMoveCallback(cb);}
void remove_mouse_move_callback(MouseMoveEventDg cb)     {Luigi().adapter.removeMouseMoveCallback(cb);}
void remove_mouse_wheel_callback(MouseWheelEventFn cb)   {Luigi().adapter.removeMouseWheelCallback(cb);}
void remove_mouse_wheel_callback(MouseWheelEventDg cb)   {Luigi().adapter.removeMouseWheelCallback(cb);}
void remove_window_size_callback(WindowSizeEventFn cb)   {Luigi().adapter.removeWindowSizeCallback(cb);}
void remove_window_size_callback(WindowSizeEventDg cb)   {Luigi().adapter.removeWindowSizeCallback(cb);}
void remove_window_close_callback(WindowCloseEventFn cb) {Luigi().adapter.removeWindowCloseCallback(cb);}
void remove_window_close_callback(WindowCloseEventDg cb) {Luigi().adapter.removeWindowCloseCallback(cb);}
void remove_sys_key_callback(KeyEventFn cb)                  {Luigi().adapter.removeSysKeyCallback(cb);}
void remove_sys_key_callback(KeyEventDg cb)                  {Luigi().adapter.removeSysKeyCallback(cb);}
void remove_sys_mouse_button_callback(MouseButtonEventFn cb) {Luigi().adapter.removeSysMouseButtonCallback(cb); }
void remove_sys_mouse_button_callback(MouseButtonEventDg cb) {Luigi().adapter.removeSysMouseButtonCallback(cb); }




/** 
 * Represents a real OS window used exclusively by Luigi. 
 * If the GUI is drawn on top of the app's GL window, use Overlay instead. 
 */
class Frame
{
    // maybe later -- GLFW doesn't have a way to make more than one windowframe.
    // SDL doesn't either.
    // And maybe this should just be Window, because e.g. GLUT has sub-windows that can be
    // treated basically as top level windows.

    private:
    WindowHandle m_winhandle;
}

template WidgetMixin()
{
    alias typeof(this) WidgetType;
    static assert(is(WidgetType:luigi.gui.Widget), 
                  "WidgetMixin should be derived from Widget");
        
    /** 
    This function is a convenient way to add a newly constructed widget
    to an arranger while passing along extra necessary arguments.

    It is always possible to add the widget directy to the parent's arranger using
    the arranger.add(), but this way lets you construct the widget, add it to the 
    arranger with arguments, and assign it to a variable of the derived type all 
    in one line.

    For example:
      Button b = arranger_add(new Button(parent, "Name"), Arranger.Left, Arranger.Top);
    
    Returns: A pointer to 'this', with the proper derived type.
    */
    WidgetType arranged_(VArg...)(VArg varg)
    {
        //static assert(is(T:Widget), "arranger_add requires a Widget as argument 0");
        if (parent && parent.arranger && !parent.arranger.auto_add) {
            parent.arranger.add(this, varg);
        }
        return this;
    }
}

template PanelMixin()
{
    alias typeof(this) PanelType;
    static assert(is(PanelType:luigi.gui.Panel), 
                  "PanelMixin should be derived from Panel");
        
    /** Add the widget to this panel.
     *
     * This method returns the widget passed in with its full derived type,
     * so add_widget can be used like:
     * ---------
     *   auto b = border_panel.add_widget(new Button("Clicky"));
     * ---------
     * and the resulting b will have type Button.
     *
     * See_Also: add_arranged, Panel.add, Arranger.add
     */
    W add_widget(W)(W widget)
    {
        static assert(is(W:luigi.gui.Widget), "add_widget requires a Widget as argument");
        add(widget);
        return widget;
    }

    /** Add the widget to this panel and also to the panel's arranger
     *  with arguments.
     *
     * This method returns the widget passed in with its full derived type,
     * so add_arranged can be used like:
     * ---------
     *   auto b = border_panel.add_arranged(new Button("Clicky"), Region.East);
     * ---------
     * and the resulting b will have type Button.
     *
     * See_Also: add_widget, Panel.add, Arranger.add
     */
    W add_arranged(W, Varg...)(W widget, Varg args)
    {
        static assert(is(W:luigi.gui.Widget),
                      "add_arranged requires a Widget as argument");
        add(widget);
        assert(arranger, "add_arranged called with no arranger set");
        if (arranger && !arranger.auto_add) arranger.add(widget, args);
        return widget;
    }
}

/**
 * The base class for any GUI entity that occupies space on the screen.
 */
class Widget : Arrangeable
{
    mixin WidgetMixin;

    // Some handy aliases everyone should have
    // This makes it so you can refer to these inside a Widget subclass
    // without worry
    alias luigi.base.Size Size;
    alias luigi.base.Rect Rect;
    alias luigi.base.Point Point;


    this() {}
    
    void add(Widget child) {
        throw new GUIException("Attempt to add child to a Widget");  
    }
    
    void draw() {
        // Default is to let the theme draw it.
        if (shown)
            Luigi().theme.draw(this);
    }

    //------------------------------------------------------------------------
    // Default implementation of Arrangeable interface
    override Size minimum_size(Size bounds) {
        return Luigi().theme.minimum_size(this, bounds); 
    }
    override Size preferred_size(Size bounds) { 
        return Luigi().theme.preferred_size(this, bounds);
    }
    override void set_rect(Rect s) { m_rect = s; }
    override void set_position(Point p) { m_rect.x = p.x; m_rect.y = p.y; }
    override void set_size(Size sz) { m_rect.width = sz.width; m_rect.height = sz.height; }
    override void arrange() { /* nothing to do */ }


    /** Return the arranger used to arrange this widget's chilrend */
    Arranger arranger() { return m_arranger; }

    /** Set the arranger used to arrange this widget's chilren */
    Arranger arranger(Arranger a)
    {
        if (a==m_arranger) return m_arranger;
        m_arranger = a;
        m_arranger.set_rect(m_rect);
        return m_arranger;
    }

    /** Return the arranger used to arrange this widget */
    Arranger arranged_by() {
        if (parent) return parent.arranger;
        return null;
    }

    /** Return the items rectangle.  
        The rectangle coordinates are relative to the upper left corner of this
        widget's parent.
    */
    Rect rect() { return m_rect; }
    // Rect rect(Rect r) { return m_rect; }  // use set rect!


    void enable(bool isEnabled=true) { return m_enabled = isEnabled; }
    void disable() { m_enabled = false; }
    bool enabled() { return m_enabled; }
    bool disabled() { return !m_enabled; }
    
    void show() { m_shown = true; }
    void hide() { m_shown = false; }
    bool shown(bool show_) { return m_shown = show_; }
    bool shown() { return m_shown; }
    void toggle_shown() { m_shown = !m_shown; }

    /** Return the parent of this item or null if it has no parent.
    */
    Widget parent() { return m_parent; }

    /** Return the list of items that are parented to this one.
        Panels are the base type for all items with children.
    */
    Widget[] children() { return null; }

    /** Transforms the given point from window coordinates into 
        the widget's coordinates.  In widget coordinates, 
        (rect.x,rect.y) is the upper left corner of the widget.
    */
    void transform_window_to_widget(inout Point winp)
    {
        Widget w = this.parent;
        while( w )
        {
            winp.x -= w.m_rect.x;
            winp.y -= w.m_rect.y;
            w = w.parent;
        }
    }

    /** Return the item after this one in the tab traversal order */
    Widget next_item() { 
        Panel p = cast(Panel)parent;
        if (p) { return p.sibling_after(this); }
        return null;
    }
    /** Return the item before this one in the tab traversal order */
    Widget prev_item() {
        Panel p = cast(Panel)parent;
        if (p) { return p.sibling_before(this); }
        return null;
    }

    /** Find the widget at the root of this item's hierarchy */
    Widget get_root() {
        Widget r = this;
        while ( r.parent ) r = r.parent;
        return r;
    }

    bool is_grabbing_mouse() {
        Widget R = get_root();
        return R._get_mouse_grabber() is this;
    }
    bool grab_mouse() {
        Widget R = get_root();
        return R._set_mouse_grabber(this);
    }
    bool release_mouse() {
        Widget R = get_root();
        return R._release_mouse_grabber(this);
    }
        

    protected bool _set_mouse_grabber(Widget w)
    {
        assert(0, "Widgets don't grab the mouse");
        return false;
    }
    protected bool _release_mouse_grabber(Widget w)
    {
        assert(0, "Widgets don't grab the mouse");
        return false;
    }
    protected Widget _get_mouse_grabber()
    {
        assert(0, "Widgets don't grab the mouse");
        return null;
    }

    //----------------- FOCUS METHODS --------------------------

    /** Returns whether this item has the keyboard focus.
    */
    bool focused()
    in {  get_root()._focus_sanity_check(); } body
    {
        return m_focused;
    }

    bool focusable(bool onOff) 
    in {  get_root()._focus_sanity_check(); } body
    { 
        if (m_focusable == onOff) 
            // no change
            return m_focusable;

        if (!onOff && m_focused) {
            // we were focused but we're being made non-focusable
            // Try to focus the next guy before turning our focus off.
            focus_next();
            if (m_focused) // it didn't work! maybe we're the only item!
                _unfocus_rup();
        }
        m_focusable = onOff;
        return m_focusable;
    }

    bool focusable() 
    in {  get_root()._focus_sanity_check(); } body
    { 
        return m_focusable && m_enabled;
    }

    /** Finds the keyboard focus of this widget's hierarchy. */
    Widget get_focus()
    in {  get_root()._focus_sanity_check(); } body
    {
        Widget R = get_root();
        Widget w = R._find_focus_rdown();
        return w;
    }

    protected Widget _find_focus_rdown()
    {
        writefln("Focus rdown widget");
        // Shouldn't usually get here, unless we have no parent
        assert(parent==null, "I shouldn't even *be* here today.");
        return this;
    }

    /** Sets the keyboard focus of this widget's hierarchy to newfocus.
     *  If newfocus is null any current focus item in this widget tree 
     *  will be unfocused.
     */
    bool set_focus(Widget newfocus)
    in {  get_root()._focus_sanity_check(); } body
    {
        if (newfocus) {
            if (!newfocus.focusable) return false;
            if (newfocus.m_focused) return true;
        }

        // unfocus the current guy first
        Widget oldFocus = get_focus();
        if (oldFocus && !oldFocus._can_lose_focus()) {
            return false;
        }
        else if (oldFocus) {
            oldFocus._unfocus_rup();
        }
        
        // Stop here if there's no new focus item
        if (!newfocus) return true;

        // now give focus to the new guy.
        // Set his m_focused flag and percolate m_childFocused flags up the chain.
        _FocusEvent ev;
        ev.previous = oldFocus;
        newfocus.on_focus(&ev);
        if (!ev.alive) {
            newfocus.m_focused = true;
            if (newfocus.parent) newfocus.parent._set_child_focused_rup();
        }
        return newfocus.m_focused;
    }


    /** Set the keyboard focus to this item.
        Returns true if successful, false otherwise.
    */
    bool focus()
    in {  get_root()._focus_sanity_check(); } body
    {
        return set_focus(this);
    }

    protected void _set_child_focused_rup() {
        // recursively set child focus on all parents
        assert(false, "recursive focus only for Panel-derived classes.");
    }

    protected void _unfocus_rup() {
        // recursively unfocus this item and all parents
        m_focused = false;
        if (parent) parent._unfocus_rup();
    }

    protected Widget _find_first_focusable_rdown() {
        if (focusable) {
            return this;
        }
        return null;
    }
    protected Widget _find_last_focusable_rdown() {
        if (focusable) {
            return this;
        }
        return null;
    }
    protected Widget _find_next_focusable_rdown(inout bool found_focus)
    {
        if (m_focused) { found_focus = true; }
        return null;
    }
    protected Widget _find_prev_focusable_rdown(inout bool found_focus)
    {
        if (m_focused) { found_focus = true; }
        return null;
    }

    protected int _focus_sanity_check(int c=0) {
        return c + (m_focused?1:0);
    }


    /** Moves focus to the next item in this widget's hierarchy, or 
        to the first item if nothing is currently focused. 
        Return the newly focused item.
    */
    Widget focus_next()
    {
        Widget w = get_focus();
        Widget R = get_root();
        if (!w) {
            w = R._find_first_focusable_rdown();
        }
        else {
            bool code = false;
            w = R._find_next_focusable_rdown(code);
            if (!w) {
                w = R._find_first_focusable_rdown();
            }
        }