root/trunk/luigi/themes/dxut.d

//---------------------------------------------------------------------
/*
  luigi/themes/dxut.d -- A clone of the DXUT texture-based theme.

  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
*/


module luigi.themes.dxut;

import luigi.base;
import luigi.theme;
import luigi.opengl;
import luigi.gldraw;
import luigi.font;
import luigi.event;
import luigi.gui;

import std.math : pow;
import std.perf;

version (useDerelict) {
import derelict.opengl.extension.arb.texture_compression;
} else {
    private
    {
        PFNGLCOMPRESSEDTEXIMAGE3DARBPROC         glCompressedTexImage3DARB;
        PFNGLCOMPRESSEDTEXIMAGE2DARBPROC         glCompressedTexImage2DARB;
        PFNGLCOMPRESSEDTEXIMAGE1DARBPROC         glCompressedTexImage1DARB;
        PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC      glCompressedTexSubImage3DARB;
        PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC      glCompressedTexSubImage2DARB;
        PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC      glCompressedTexSubImage1DARB;
        PFNGLGETCOMPRESSEDTEXIMAGEARBPROC        glGetCompressedTexImageARB;

        version(Windows)
            import win32.wingdi; // for wgl funcs
        else version(linux)
            version = UsingGLX;
        version(UsingGLX)
            import x11.glx;
        import string=std.string;

        bool glBindExtFunc(void **ptr, char[] funcName)
        {
            version(Windows)
                *ptr = wglGetProcAddress(string.toStringz(funcName));
            else version(UsingGLX)
                *ptr = glXGetProcAddress(string.toStringz(funcName));
            return (*ptr !is null);
        }
    }
}

static const GLint GL_COMPRESSED_RGB_S3TC_DXT1_EXT  = 0x83F0;
static const GLint GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1;
static const GLint GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2;
static const GLint GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3;



void initialize_compressed_texture_extension()
{
    bool allOk = true;
    version(useDerelict) {
        if (!ARBTextureCompression.load("GL_ARB_texture_compression")) 
            allOk=false;
    }
    else {
        if(!glBindExtFunc(cast(void**)&glCompressedTexImage3DARB, "glCompressedTexImage3DARB"))
            allOk = false;
        if(!glBindExtFunc(cast(void**)&glCompressedTexImage2DARB, "glCompressedTexImage2DARB"))
            allOk = false;
        if(!glBindExtFunc(cast(void**)&glCompressedTexImage1DARB, "glCompressedTexImage1DARB"))
            allOk = false;
        if(!glBindExtFunc(cast(void**)&glCompressedTexSubImage3DARB, "glCompressedTexSubImage3DARB"))
            allOk = false;
        if(!glBindExtFunc(cast(void**)&glCompressedTexSubImage2DARB, "glCompressedTexSubImage2DARB"))
            allOk = false;
        if(!glBindExtFunc(cast(void**)&glCompressedTexSubImage1DARB, "glCompressedTexSubImage1DARB"))
            allOk = false;
        if(!glBindExtFunc(cast(void**)&glGetCompressedTexImageARB, "glGetCompressedTexImageARB"))
            allOk = false;
    }
    if (!allOk) {
        throw new Exception("Unable to initialize texture compression extension");
    }
}

alias DXUTTheme Theme;

class DXUTTheme : ThemeBase
{
    this() {
        // Load texture first
        try {
            initialize_compressed_texture_extension();

            char[] filepath = Luigi().find_resource_location(
                "dxutcontrols.dds",
                "themes/dxutcontrols.dds",
                "resource/dxutcontrols.dds"
                );
            if (filepath) {
                loadCompressedTexture(filepath, m_texid);
            } else {
                report_error("Couldn't find, or failed to load dxutcontrols.dds");
                return;
            }

            glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &m_texw);
            glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &m_texh);
        }
        catch (Exception e) {
            report_error(std.string.format("Couldn't load texture: ", e.toString));
        }

        m_default_font = new ASCIIBitmapFont();
        m_timer = new PerformanceCounter;

        // Register all known size and draw functions.
        label_register();
        button_register();
        checkbox_register();
        radiobutton_register();
        textfield_register();
        optionmenu_register();
        slider_register();
        scrollbar_register();
        panel_register();
        spinner_register();

        sel_text_color.set(255,255,255);
        sel_text_bkg_color.set(10,36,106);
        sel_text_unfocus_bkg_color.set(176,176,176);

    }
    ~this() {
        if (m_texid) 
            glDeleteTextures(1, &m_texid);
    }

    //----THEME DATA--------------------------------------------------------
    class ThemeData {
        // per-widget elements needed so we can blend objects independently
        // a little wasteful, though, since most info does not change per-elem
        Element[] elements;
    }
    ThemeData get_theme_data(Widget w) {
        Object td;
        if (w && (td=w.theme_instance_data)!is null) {
            return cast(ThemeData)td;
        }
        else {
            // This means we haven't made it yet
            ThemeData td2 = new ThemeData;
            w.theme_instance_data = td2;
            auto pElements = w.classinfo in m_elements;
            if (pElements!=null) {
                td2.elements = (*pElements).dup;
            }
            else {
                // this is an unknown class 
                // -- find best match up class hierarchy
                auto cinfo = w.classinfo;
                while (cinfo != Widget.classinfo) {
                    pElements = cinfo in m_elements;
                    if (pElements) {
                        td2.elements = (*pElements).dup;
                        break;
                    }
                    cinfo = cinfo.base;
                }
                if (cinfo == Widget.classinfo) {
                    // didn't find it. w is not a subclass of anything
                    // we know how to draw.
                    Element[] empty;
                    m_elements[w.classinfo] = empty;
                }
            }
            return td2;
        }
    }
    Element[] get_widget_elements(Widget w) {
        return get_theme_data(w).elements;
    }

    //----GRPAHICS STATE------------------------------------------------------
    override void begin_drawing(Rect r) {
        m_timer.stop();
        m_elapsedTime = m_timer.milliseconds / 1000.0;
        m_timer.start();
        
        push_graphics_state(r);
        glPushAttrib(GL_TEXTURE_BIT);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glBindTexture(GL_TEXTURE_2D,m_texid);
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);

        glMatrixMode(GL_TEXTURE);
        glPushMatrix();
        glLoadIdentity();
        glScalef(1./m_texw, 1./m_texh,1);
        glMatrixMode(GL_MODELVIEW);

    }
    override void end_drawing() {
        glPopAttrib(); // TEXTURE_BIT
        pop_graphics_state();
        glMatrixMode(GL_TEXTURE);
        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
    }

    //============================================================================
    // Widget drawing and size routines

    //----HELPERS-----------------------------------------------------------------
    Font get_font() { return m_default_font; }
    bool set_color(float g) 
    {
        glColor3f(g,g,g);
        return true;
    }
    bool set_color(Color c) 
    {
        glColor4ubv(c.ptr);
        return c.a!=0;
    }

    enum TextAlign {
        Center = 0x0,
        Top = 0x1,
        Bottom = 0x2,
        Left = 0x4,
        Right = 0x8,
        TopLeft = Top|Left,
        TopRight = Top|Right,
        BottomLeft = Bottom|Left,
        BottomRight = Bottom|Right,
        LRMask = Right | Left,
        TBMask = Top | Bottom,
    }
    /** Draw text so the upper left corner is at (x,y) */
    void draw_text(Font font, char[] label, float x, float y)
    {
        Point trans = font.origin; trans.x+=x; trans.y+=y;
        translate(trans);
        font.draw_string(label);
        untranslate(trans);
    }
    /** Draw text inside the rect with the indicated alignment */
    void draw_text_rect(Font font, char[] txt, Rect r, TextAlign ta)
    {
        Point trans = font.origin; trans.x+=r.x; trans.y+=r.y;
        TextAlign tbflags = ta & TextAlign.TBMask;
        TextAlign lrflags = ta & TextAlign.LRMask;
        if (lrflags != TextAlign.Left) {
            Rect sr = font.string_rect(txt);
            if (lrflags == TextAlign.Right) {
                trans.x += r.w - sr.w;
            } 
            else if (lrflags == TextAlign.Center) {
                trans.x += (r.w - sr.w)/2;
            }
        }
        if (lrflags != TextAlign.Top) {
            float txth = font.height;
            if (lrflags == TextAlign.Bottom) {
                trans.y += r.h - txth;
            } 
            else if (lrflags == TextAlign.Center) {
                trans.y += (r.h - txth)/2;
            }
        }
        translate(trans);
        font.draw_string(txt);
        untranslate(trans);
    }
    /** Draw text centered in the rectangle */
    void draw_text_centered(Font font, char[] label, Rect rect)
    {
        draw_text_rect(font,label,rect,TextAlign.Center);
    }

    void draw_elem_texture(inout Element elem, inout Rect rect) {
        if (elem.texColor.alpha == 0) 
            return;
        glEnable(GL_TEXTURE_2D);
        set_color(elem.texColor.current);
        fill_rect(rect, elem.texRect);
    }
    void draw_elem_texture(inout Element elem, inout Rect rect, int[4] texRect) {
        if (elem.texColor.alpha == 0) 
            return;
        glEnable(GL_TEXTURE_2D);
        set_color(elem.texColor.current);
        fill_rect(rect, texRect);
    }
    void draw_elem_text(inout Element elem, char[] text, Rect rect, 
                        TextAlign al = TextAlign.Center, bool shadow=false)
    {
        if (elem.fontColor.alpha == 0)
            return;
        glDisable(GL_TEXTURE_2D);
        if (shadow) {
            set_color(0);
            rect.x+=1; rect.y+=1;
            draw_text_rect(elem.font, text, rect, al);
            rect.x-=1; rect.y-=1;
        }
        set_color(elem.fontColor.current);
        draw_text_rect(elem.font, text, rect, al);
    }
    //----LABEL---------------------------------------------------------------
    void label_register() {
        addHandlers!(Label)(&label_draw, &label_best_size);

        Element[] elems = new Element[1];
        Element e;
        e.set_font( m_default_font );
        e.fontColor.states[ WidgetState.Disabled ] = Color( 200, 200, 200, 200 );
        elems[0] = e;
        m_elements[Label.classinfo] = elems;
    }
    Size label_best_size(Widget widget, Size bounds) {
        auto w = cast(Label)widget; assert(w);
        Element[] elem = get_widget_elements(w);
        Rect r = elem[0].font.string_rect(w.label);
        return Size(r.width+2,r.height+2);
    }
    void label_draw(Widget widget) {
        auto w = cast(Label)widget; assert(w);
        WidgetState state = WidgetState.Normal;
        if( !w.enabled)
            state = WidgetState.Disabled;
        Element[] elem = get_widget_elements(w);
        elem[0].fontColor.blend( state, m_elapsedTime );
        draw_elem_text( elem[0], w.label, w.rect, TextAlign.Center, true );
    }

    //----BUTTON--------------------------------------------------------------
    void button_register() {
        addHandlers!(Button)(&button_draw, &button_best_size, &button_min_size);
        Element[] elems = new Element[2];
        Element e;
        // button layer
        e.set_texture( m_texid, [0,0,136,54] );
        e.fontColor.states[ WidgetState.Disabled ] = Color(200,200,200,200);
        e.set_font( m_default_font );
        e.texColor.states[ WidgetState.Normal ] = Color(255, 255, 255, 150);
        e.texColor.states[ WidgetState.Depressed ] = Color(255, 255, 255, 200);
        e.fontColor.states[ WidgetState.Rollover ] = Color(0, 0, 0, 255);
        elems[0] = e;
    
        // fill layer
        e.set_texture( m_texid, [136, 0, 272, 54], Color(255, 255, 255, 0) );
        e.texColor.states[ WidgetState.Rollover ] = Color(255, 255, 255, 160);
        e.texColor.states[ WidgetState.Depressed ] = Color(0, 0, 0, 60);
        e.texColor.states[ WidgetState.Focus ] = Color(255, 255, 255, 30);
        elems[1] = e;
    
        m_elements[Button.classinfo] = elems;
    }
    Size button_min_size(Widget widget, Size bounds) {
        auto w = cast(Button)widget; assert(w);
        Element[] elem = get_widget_elements(w);
        Rect r = elem[0].font.string_rect(w.label);
        return Size(r.width+20,r.height+8);
    }
    Size button_best_size(Widget widget, Size bounds) {
        auto w = cast(Button)widget; assert(w);
        Size minsz = button_min_size(w,bounds);
        return Size(max(50.,minsz.w), max(22.,minsz.h));
    }
    void button_draw(Widget widget) {
        auto w = cast(Button)widget; assert(w);
        with (w) {
            int dx = 0;
            int dy = 0;
            WidgetState iState = WidgetState.Normal;
            float blendRate = 0.8f;
            bool chk = is_toggle && checked;
            if( !shown ) {
                iState = WidgetState.Hidden; 
            }
            else if( !enabled ) {
                iState = WidgetState.Disabled;
            }
            else if( depressed )
            {
                iState = WidgetState.Depressed;
                blendRate = 0.6;
            }
            else if( rollover )
            {
                iState = WidgetState.Rollover;
            }
            else if( focused )
            {
                iState = WidgetState.Focus;
            }

            if ( depressed ^ chk ) {
                iState = WidgetState.Depressed;
                dx = dy = 1;
            }
            if (!depressed && chk && rollover) {
                iState = WidgetState.Rollover;
            }
            if ( rollover ) {
                dx -= 1; dy -= 1;
            }

            Element[] elem = get_widget_elements(w);

            Rect r = rect;
            r.inset(1);
            r.x += dx;
            r.y += dy;

            foreach(inout e; elem) {
                e.texColor.blend( iState, m_elapsedTime, blendRate);
                e.fontColor.blend( iState, m_elapsedTime, blendRate);
                draw_elem_texture(e, r);
                draw_elem_text(e, label, r);
            }
        }
    }
    //----CHECKBOX----------------------------------------------------------
    void checkbox_register() {
        addHandlers!(Checkbox)(&checkbox_draw, &checkbox_best_size, &checkbox_min_size);
        Element[] elems = new Element[2];
        Element e;

        e.fontColor.states[ WidgetState.Rollover ] = Color(0, 0, 0, 255);
        e.texColor.states[ WidgetState.Rollover ] = Color(255, 255, 255, 160);
    
        // check box
        e.set_texture( m_texid, [0, 54, 27, 81] );
        e.set_font( m_default_font, Color(255, 255, 255, 255) );
        e.fontColor.states[ WidgetState.Disabled ] = Color( 200, 200, 200, 200 );
        e.texColor.states[ WidgetState.Normal ] = Color(255, 255, 255, 150);
        e.texColor.states[ WidgetState.Focus ] = Color(255, 255, 255, 200);
        e.texColor.states[ WidgetState.Depressed ] = Color(255, 255, 255, 255);
        elems[0] = e;

        // Check
        e.set_texture( m_texid, [27, 54, 54, 81] );
        elems[1] = e;

        m_elements[Checkbox.classinfo] = elems;
    }
    Size checkbox_min_size(Widget widget, Size bounds) {
        auto w = cast(Button)widget; assert(w);
        Element[] elem = get_widget_elements(w);
        Point p0 = Point(elem[0].texRect[0], elem[0].texRect[1]);
        Point p1 = Point(elem[0].texRect[2], elem[0].texRect[3]);
        p1 -= p0;
        Size btn = Size(lrint(p1.x/2),lrint(p1.y/2));
        Size txt = elem[0].font.string_rect(w.label).size;

        return Size(btn.width+3+txt.width+4,max(btn.height,txt.height));
    }
    Size checkbox_best_size(Widget widget, Size bounds) {
        auto w = cast(Button)widget; assert(w);
        Size minsz = checkbox_min_size(w,bounds);
        return Size(max(50.,minsz.w), max(22.,minsz.h));
    }
    void checkbox_draw(Widget widget) {
        auto w = cast(Button)widget; assert(w);
        with (w) {
            WidgetState iState = WidgetState.Normal;
            if( !shown )
                iState = WidgetState.Hidden;
            else if( !enabled )
                iState = WidgetState.Disabled;
            else if( depressed )
                iState = WidgetState.Depressed;
            else if( rollover )
                iState = WidgetState.Rollover;
            else if( focused )
                iState = WidgetState.Focus;

            float fBlendRate = ( iState == WidgetState.Depressed ) ? 0.0f : 0.8f;

            Element[] elem = get_widget_elements(w);
            elem[0].texColor.blend( iState, m_elapsedTime, fBlendRate );
            elem[0].fontColor.blend( iState, m_elapsedTime, fBlendRate );

            Rect