Changeset 37

Timestamp:

12/05/06 20:00:24 (2 years ago)

Author:

baxissimo

Message:

Improvements to dxut mostly (adding scrollbar)

Files:

• trunk/luigi/arranger.d (modified) (7 diffs)
• trunk/luigi/base.d (modified) (2 diffs)
• trunk/luigi/example1.d (modified) (4 diffs)
• trunk/luigi/example1_sdl.d (modified) (1 diff)
• trunk/luigi/gui.d (modified) (5 diffs)
• trunk/luigi/themes/dxut.d (modified) (9 diffs)

trunk/luigi/arranger.d

@@ -306 +306 @@
-        FlowRow currentRow = new FlowRow(xgap);
-        foreach(Arrangeable c ; m_items) 
+        {
+            Size s = c.preferred_size(rect.size);
+            currentWidth += s.width + xgap;
+            if(currentWidth > rect.width)
-            {
-
-
-
-
-
-
-
-
-
+
+
+
-            }
+            currentRow.add(c);
+        }
-        rows ~= currentRow;
-        float totalHeight = 0;
-        foreach(FlowRow r ; rows)
-    
-    
-    
+
+
+
-        totalHeight += ygap*(rows.length - 1);
-
@@ -346 +346 @@
-        case A.Left:
-            foreach(FlowRow r; rows) 
-    
-    
-    
-    
-    
+
+
+
+
+
-            break;
-        case A.Right:
-            foreach(FlowRow r; rows)
-    
-    
-    
-    
-    
-    
+
+
+
+
+
+
-            break;
-
@@ -365 +365 @@
-        default:
-            foreach(FlowRow r; rows)
-    
-    
-    
-    
-    
-    
+
+
+
+
+
+
-            break;
-        }
-        foreach(Arrangeable item ; m_items)
-           
-               
-           
+        
+            
+        
-    }
-
@@ -428 +428 @@
-        float y = y0 + (rect.height / 2);
-        foreach(Arrangeable item ; m_items)
-           
-               
-               
-               
-           
+        
+            
+            
+            
+        
-    }
-
@@ -440 +440 @@
-        float width = 0;
-        foreach(Arrangeable item ; m_items)
-           
-               
-               
-           
+        
+            
+            
+        
-        width += xgap * (m_items.length - 1);
-        m_rect.width = width;
@@ -453 +453 @@
-        float maxHeight = 0;
-        foreach(Arrangeable item ; m_items)
-           
-               
-           
+        
+            
+        
-        return maxHeight;
-    }
@@ -637 +637 @@
-        heights[] = 0;
-
-
-
+
+
+
+
-                int i = r * grid.cols + c;
-                if(i < m_items.length)

trunk/luigi/base.d

@@ -105 +105 @@
-
-    /** Intersection of two rects. */
-
-
-
+
+
+
+
-    /** Grow rect to enclose other rect (union of rects.) */
-    void enclose(Rect o) {
@@ -153 +154 @@
-    void opSubAssign(Size o) { w-=o.w; h-=o.h; }
-
+    /** Allows Sizes to be multiplied by a scalar */
+    void opMulAssign(float d) { w*=d; h*=d; }
+
-    /** Return a printable representation of the Size */
-    char[] toString() {
-        return string.format("(%0.1f,%0.1f)",w,h);
-    }
+
-}
-

trunk/luigi/example1.d

@@ -97 +97 @@
-            auto b29 = add_arranged(new Button("Tool9"));
-
-
+multi
-            rgrp.value = 0;
-            rgrp.selection_changed ~= (int t) {
@@ -103 +103 @@
-            };
-
-("Thingy")
-("Thingy")
+
+
-            s02.vertical = true;
-            s01.precision = 0.1;
@@ -113 +113 @@
-            s02.value_changed.connect2nd(&s01.value);
-            s01.value_changed.connect2nd(&s02.value);
+
+/*
+            auto sb01 = add_arranged(new ScrollBar);
+            auto sb02 = add_arranged(new ScrollBar);
+            sb02.vertical = true;
+            sb01.precision = 1;
+            sb02.precision = 1;
+*/
-        }
-
@@ -129 +137 @@
-                b.get_root.arrange();
-            };
+
+            auto onoff = new RadioGroup;
+            auto r0 = add_widget(new RadioButton("On"));
+            auto r1 = add_widget(new RadioButton("Off"));
+            onoff.multiadd(r0,1, r1,0);
+            onoff.value = 1;
-        }
-

trunk/luigi/example1_sdl.d

@@ -434 +434 @@
-    SDL_WM_SetCaption("Gears", "gears");
-    SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
+    SDL_EnableUNICODE(1);
-
-    init(args);

trunk/luigi/gui.d

@@ -698 +698 @@
-    }
-
- 
+
-        if (arranger) { return arranger.minimum_size(bounds); }
-        return super.minimum_size(bounds);
@@ -1608 +1608 @@
-    override double value() { return m_value; }
-
-char[] label_
+
-        super();
-        label = label_;
-        value_changed = new ValueChangedSignal;
-        m_focusable = true;
@@ -1664 +1663 @@
-    bool vertical() { return m_orientation != Orientation.Horizontal; }
-
-    char[] label;
-
-    alias FlexSignal!(Widget, double) ValueChangedSignal;
-    ValueChangedSignal value_changed;
@@ -1707 +1704 @@
-}
-
+class ScrollBar : Panel, Valuator
+{
+    mixin WidgetMixin;
+    // don't use panel mixin because we shouldn't be able to add things to this panel
+
+    class ScrollButton : Button
+    {
+        // use labels: 'up' 'down' 'left' 'right' to indicate which direction to point
+        this(char[] label_) {
+            super(label_);
+            focusable = false;
+        }
+    }
+    class ScrollTrack : Slider
+    {
+        this() { 
+            super(); 
+            focusable = false;
+        }
+        
+    }
+
+    this() {
+        super();
+        m_track = new ScrollTrack;
+        m_upButton = new ScrollButton("left");
+        m_downButton = new ScrollButton("right");
+        // value_changed = new ValueChangedSignal;
+        m_focusable = false;
+        add(m_upButton);
+        add(m_track);
+        add(m_downButton);
+        _set_button_labels();
+        writefln("%s(%s): trace!", __FILE__, __LINE__);
+    }
+
+    // Panel-related overrides
+
+    // Don't allow adding children
+    private override void add(Widget child) { super.add(child); }
+    // Don't allow setting an arranger
+    private override Arranger arranger(Arranger a) { return null; }
+    private override Arranger arranger() { return null; }
+
+    override Size minimum_size(Size bounds)   {
+        Size sz = m_track.minimum_size(bounds);
+        Size szup = m_upButton.minimum_size(bounds);
+        Size szdn = m_downButton.minimum_size(bounds);
+        if (vertical) {
+            sz.width = max(sz.width, szup.width);
+            sz.width = max(sz.width, szdn.width);
+            sz.height +=  szup.height + szdn.height;
+        }
+        else {
+            sz.height = max(sz.height, szup.height);
+            sz.height = max(sz.height, szdn.height);
+            sz.width +=  szup.width + szdn.width;
+        }
+        return sz;
+    }
+    override Size preferred_size(Size bounds) {
+        Size sz = m_track.preferred_size(bounds);
+        Size szup = m_upButton.preferred_size(bounds);
+        Size szdn = m_downButton.preferred_size(bounds);
+        if (vertical) {
+            sz.width = max(sz.width, szup.width);
+            sz.width = max(sz.width, szdn.width);
+            sz.height +=  szup.height + szdn.height;
+        }
+        else {
+            sz.height = max(sz.height, szup.height);
+            sz.height = max(sz.height, szdn.height);
+            sz.width +=  szup.width + szdn.width;
+        }
+        return sz;
+    }
+    override void arrange() {
+        Rect urect = Rect(0,0,0,0);
+        Rect drect = Rect(0,0,0,0);
+        urect.size = m_upButton.preferred_size(rect.size);
+        drect.size = m_downButton.preferred_size(rect.size);
+        if (vertical) {
+            m_upButton.set_rect(urect);
+            drect.y = rect.h - drect.h;
+            m_downButton.set_rect(drect);
+            m_track.set_rect(
+                Rect( urect.x, urect.y2, urect.w, rect.h-urect.h-drect.h));
+        } else {
+            m_downButton.set_rect(drect);
+            urect.x = rect.x2 - urect.w;
+            m_upButton.set_rect(urect);
+            m_track.set_rect(
+                Rect( drect.x2, drect.y, rect.w-urect.w-drect.w, drect.h));
+        }
+    }
+
+    // Slider related overrides
+
+    override double value(double v) { return m_track.value(v); }
+    override double value() { return m_track.value(); }
+
+    double value_max(double v) { return m_track.value_max(v); }
+    double value_min(double v) { return m_track.value_min(v); }
+    double increment(double v) { return m_track.increment(v); }
+    double page_increment(double v) { return m_track.page_increment(v); }
+    double precision(double prec) { return m_track.precision(prec); }
+
+    double value_max() { return m_track.value_max(); }
+    double value_min() { return m_track.value_min(); }
+    double increment() { return m_track.increment(); }
+    double page_increment() { return m_track.page_increment(); }
+    double precision() { return m_track.precision(); }
+
+    bool horizontal(bool tf) { 
+        if (horizontal == tf) return tf;
+        m_track.horizontal(tf);
+        _set_button_labels();
+        return tf;
+    }
+    bool vertical(bool tf) { 
+        if (vertical == tf) return tf;
+        m_track.vertical(tf);
+        _set_button_labels();
+        return tf;
+    }
+    bool horizontal() { return m_track.horizontal(); }
+    bool vertical() { return m_track.vertical(); }
+        
+    private void _set_button_labels() {
+        if (m_track.vertical) {
+            m_downButton.label = "down";
+            m_upButton.label = "up";
+        }
+        else {
+            m_downButton.label = "left";
+            m_upButton.label = "right";
+        }
+    }
+
+    double page_size(double v) { return m_page_size = v; }
+    double page_size() { return m_page_size; }
+
+
+    alias m_track.ValueChangedSignal ValueChangedSignal;
+
+    double m_page_size = 1;
+    ScrollTrack  m_track;
+    ScrollButton m_downButton; // (or left)
+    ScrollButton m_upButton; // (or right)
+}
+
-/** A radio button is just a Button with an alternate appearance 
-    determined by the theme.
@@ -1758 +1906 @@
-    }
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-     */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    /** Have button b leave this group */

trunk/luigi/themes/dxut.d

@@ -72 +72 @@
-        button_register();
-        checkbox_register();
+        radiobutton_register();
-        textfield_register();
+        optionmenu_register();
-        slider_register();
+        scrollbar_register();
-        panel_register();
-        spinner_register();
-        radiogroup_register();
-        radiobutton_register();
-
-        sel_text_color.set(255,255,255);
@@ -314 +315 @@
-            }
-            else if( !enabled ) {
- 
+
-            }
-            else if( depressed )
@@ -331 +332 @@
-
-            if ( depressed ^ chk ) {
+                iState = WidgetState.Depressed;
-                dx = dy = 1;
+            }
+            if (!depressed && chk && rollover) {
+                iState = WidgetState.Rollover;
-            }
-            if ( rollover ) {
@@ -377 +382 @@
-    }
-    Size checkbox_min_size(Widget widget, Size bounds) {
-Checkbox
+Button
-        Element[] elem = get_widget_elements(w);
-        Point p0 = Point(elem[0].texRect[0], elem[0].texRect[1]);
@@ -388 +393 @@
-    }
-    Size checkbox_best_size(Widget widget, Size bounds) {
-Checkbox
+Button
-        Size minsz = checkbox_min_size(w,bounds);
-        return Size(max(50.,minsz.w), max(22.,minsz.h));
-    }
-    void checkbox_draw(Widget widget) {
-Checkbox
+Button
-        with (w) {
-            WidgetState iState = WidgetState.Normal;
@@ -430 +435 @@
-            draw_elem_texture( elem[1], btn_rect );
-        }
+    }
+    //----RADIOBUTTON-------------------------------------------------------
+    void radiobutton_register() {
+        // radiobutton is identical to checkbox, except the textures it uses to draw.
+        addHandlers!(RadioButton)(&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);
+    
+        // radio button border
+        e.set_texture( m_texid, [54, 54, 81, 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;
+
+        // selection indicator
+        e.set_texture( m_texid, [81, 54, 108, 81] );
+        elems[1] = e;
+
+        m_elements[RadioButton.classinfo] = elems;
-    }
-    //----TEXTFIELD---------------------------------------------------------
@@ -856 +886 @@
-        }
-    }
+    //----SCROLLBAR---------------------------------------------------------
+    enum ScrollArrow{ Up, Down, Right, Left }
+
+    void scrollbar_register() {
+        addHandlers!(ScrollBar.ScrollButton)(
+            &scrollbutton_draw, &scrollbutton_best_size, &scrollbutton_min_size);
+        //addEventHandlers!(ScrollBar.ScrollButton)(
+        //    &scrollbutton_mouse_button, &scrollbutton_mouse_move);
+        addHandlers!(ScrollBar.ScrollTrack)(
+            &scrolltrack_draw, &scrolltrack_best_size, &scrolltrack_min_size);
+        //addEventHandlers!(ScrollBar.ScrollTrack)(
+        //    &scrolltrack_mouse_button, &scrolltrack_mouse_move);
+        
+        Element[] telems = new Element[2];
+        Element e;
+        
+
+        e.texColor.states[ WidgetState.Rollover ] =  Color(255, 255, 255, 160);
+        e.texColor.states[ WidgetState.Normal ] =    Color(255, 255, 255, 150);
+        e.texColor.states[ WidgetState.Depressed ] = Color(150, 150, 150, 255);
+        e.texColor.states[ WidgetState.Normal ] =    Color(255, 255, 255, 150);
+        e.texColor.states[ WidgetState.Focus ] =     Color(255, 255, 255, 200);
+
+        // track
+        e.set_texture( m_texid, [243, 144, 265, 155]);
+        e.texColor.states[ WidgetState.Disabled ] = Color(200, 200, 200, 255);
+        telems[0] = e;
+    
+        // thumb
+        e.set_texture( 0, [266, 123, 286, 167] );
+        telems[1] = e;
+
+        m_elements[ScrollBar.ScrollTrack.classinfo] = telems;
+
+        Element[] belems = new Element[4];
+        // uparrow
+        e.set_texture( m_texid, [243, 124, 265, 144] );
+        e.texColor.states[ WidgetState.Disabled ] = Color(200, 200, 200, 255);
+        belems[ScrollArrow.Up] = e;
+    
+        // downarrow
+        e.set_texture( m_texid, [243, 155, 265, 176] );
+        e.texColor.states[ WidgetState.Disabled ] = Color(200, 200, 200, 255);
+        belems[ScrollArrow.Down] = e;
+
+        // rightarrow
+        e.set_texture( m_texid, [243, 180, 265, 200] );
+        e.texColor.states[ WidgetState.Disabled ] = Color(200, 200, 200, 255);
+        belems[ScrollArrow.Right] = e;
+    
+        // leftarrow
+        e.set_texture( m_texid, [243, 211, 265, 232] );
+        e.texColor.states[ WidgetState.Disabled ] = Color(200, 200, 200, 255);
+        belems[ScrollArrow.Left] = e;
+
+        m_elements[ScrollBar.ScrollButton.classinfo] = belems;
+
+    }
+    Size scrollbutton_min_size(Widget widget, Size bounds) {
+        auto w = cast(Button)widget; assert(w);
+        Element[] elem = get_widget_elements(w);
+        Size sz = Size(elem[0].texRect[2]-elem[0].texRect[0],
+                       elem[0].texRect[3]-elem[0].texRect[1]);
+        sz *= 0.5;
+        return sz;
+    }
+    Size scrollbutton_best_size(Widget widget, Size bounds) {
+        return scrollbutton_min_size(widget,bounds);
+    }
+    Size scrolltrack_min_size(Widget widget, Size bounds) {
+        return slider_min_size(widget,bounds);
+    }
+    Size scrolltrack_best_size(Widget widget, Size bounds) {
+        return slider_best_size(widget,bounds);
+    }
+    void scrollbutton_draw(Widget widget) {
+        auto w = cast(Button)widget; assert(w);
+        Element[] elem = get_widget_elements(w);
+        with(w) {
+            WidgetState iState = WidgetState.Normal;
+            if( !enabled ) {
+                iState = WidgetState.Disabled;
+            }
+            Rect r = rect;
+            ScrollArrow dirn;
+            switch(w.label) {
+            case "up":     dirn = ScrollArrow.Up; break;
+            case "down":   dirn = ScrollArrow.Down; break;
+            case "right":  dirn = ScrollArrow.Right; break;
+            default:       dirn = ScrollArrow.Left;
+            }
+            elem[dirn].texColor.blend( iState, m_elapsedTime, 0.8);
+            draw_elem_texture(elem[dirn], r);
+        }
+    }
+    void scrolltrack_draw(Widget widget) {
+        auto w = cast(ScrollBar.ScrollTrack)widget; assert(w);
+        Element[] elem = get_widget_elements(w);
+        with(w) {
+            WidgetState iState = WidgetState.Normal;
+            if( !enabled ) {
+                iState = WidgetState.Disabled;
+            }
+
+            Rect track_rect = rect;
+            elem[0].texColor.blend( iState, m_elapsedTime, 0.8 );
+            if (horizontal) {
+                draw_elem_texture( elem[0], track_rect );
+            }
+            else {
+                glPushMatrix();
+                // Rotate rectangle
+                Rect r = Rect(0,0,track_rect.h,track_rect.w);
+                r.x = -r.w/2;
+                r.y = -r.h/2;
+                glTranslatef(rect.x+rect.w/2, rect.y+rect.h/2, 0);
+                glRotatef(90,0,0,1);
+                draw_elem_texture( elem[0], r );
+                glPopMatrix();
+            }
+
+            Rect thumb_rect = rect;
+            int thumb_w = (elem[1].texRect[2] - elem[1].texRect[0])/2;
+            int thumb_h = (elem[1].texRect[3] - elem[1].texRect[1])/2;
+            thumb_rect.size = Size(thumb_w,thumb_h);
+            if (thumb_rect.w > rect.w) {
+                float shrinkby = rect.w/thumb_rect.w;
+                thumb_rect.h *= shrinkby;
+                thumb_rect.w = rect.w;
+            }
+            if (thumb_rect.h > rect.h) {
+                float shrinkby = rect.h/thumb_rect.h;
+                thumb_rect.w *= shrinkby;
+                thumb_rect.h = rect.h;
+            }
+            elem[1].texColor.blend( iState, m_elapsedTime, 0.8 );
+            if ( horizontal ) {
+                float t = (value-value_min)/(value_max-value_min);
+                float v = rect.x + thumb_rect.w/2 + t*(rect.w-thumb_rect.w);
+                thumb_rect.x = v-thumb_rect.w/2;
+                thumb_rect.y = track_rect.y + (track_rect.h-thumb_rect.h)/2;
+                draw_elem_texture( elem[1], thumb_rect );
+            } else {
+                float t = (value-value_min)/(value_max-value_min);
+                float v = rect.y2 - thumb_rect.w/2 - t*(rect.h-thumb_rect.h);
+                thumb_rect = Rect(-thumb_rect.h/2,-thumb_rect.w/2, 
+                                  thumb_rect.h,   thumb_rect.w);
+                glPushMatrix();
+                glTranslatef(rect.x+rect.w/2, v, 0);
+                glRotatef(90,0,0,1);
+                draw_elem_texture( elem[1], thumb_rect );
+                glPopMatrix();
+            }
+        }
+    }
-    //----PANEL-------------------------------------------------------------
-    void panel_register() {
@@ -862 +1047 @@
-    void spinner_register() {
-    }
-
-
-
-
-
+
+
-    }
-
@@ -883 +1065 @@
-    float m_elapsedTime = 0;
-}
+
+
-
-