Changeset 77

Timestamp:

07/31/08 19:06:18 (4 months ago)

Author:

kaarna

Message:

Button shadow. Aspectratio animation. Stuff.

Files:

• trunk/pihlaja/src/pihlaja/PihlajaMain.d (modified) (1 diff)
• trunk/pihlaja/src/shiraz/av/VideoViewer.d (modified) (5 diffs)
• trunk/pihlaja/src/shiraz/canvas/Image.d (modified) (2 diffs)
• trunk/pihlaja/src/shiraz/canvas/Rectangle.d (modified) (2 diffs)
• trunk/pihlaja/src/shiraz/core/Theme.d (modified) (8 diffs)
• trunk/pihlaja/src/shiraz/ui/Menu.d (modified) (2 diffs)
• trunk/pihlaja/src/shiraz/ui/Scrollbar.d (modified) (1 diff)

trunk/pihlaja/src/pihlaja/PihlajaMain.d

@@ -390 +390 @@
-        //
-        
+        //Window in window test
+            SubWindow winwin3 = new SubWindow("Scene 2", WindowHeaderType.SMALL, WindowHeaderType.SMALL);
+            winwin3.defaultSize( 0.4f, 0.2f );
+            winwin3.move(0.5, 0.2);
+            
+            auto emptyButton129 = new Button("Crazy Button 1");
+            emptyButton129.signalActivate.attach(&clickHandler3);
+            winwin3.add( emptyButton129 );      
+            auto emptyButton229 = new Button("Crazy Button 2");
+            emptyButton229.signalActivate.attach(&clickHandler3);
+            winwin3.add( emptyButton229 );
+            
+            awin28.add( winwin3 );
+        
+        //
+        
-        hpaned.add( awin28 );
-        

trunk/pihlaja/src/shiraz/av/VideoViewer.d

@@ -175 +175 @@
-    protected int64_t m_seekPosition = 0;
-    
+    void aspectRatioAnim( float to_set_x, float to_set_y, void delegate() set_when_finished = null )
+    {
+        Animator to_anim = new Animator(this, &xAspect, &xAspect, &yAspect, &yAspect, null, null, set_when_finished );
+        to_anim.animateTo( to_set_x, to_set_y, 0.0f );
+        add(to_anim);
+    }
+    
-    public float xAspect() { return m_xAspect; }
-    public float xAspect(float set)
@@ -183 +190 @@
-        return m_xAspect;
-    }
+    void xAspectAnim( float to_set, void delegate() set_when_finished = null )
+    {
+        Animator to_anim = new Animator(this, &xAspect, &xAspect, null, null, null, null, set_when_finished );
+        to_anim.animateTo( to_set, 0.0f, 0.0f );
+        add(to_anim);
+    }
-    protected float m_xAspect = 1.78f;
-    
@@ -192 +205 @@
-        invalidate();
-        return m_yAspect;
+    }
+    void yAspectAnim( float to_set, void delegate() set_when_finished = null )
+    {
+        Animator to_anim = new Animator(this, &yAspect, &yAspect, null, null, null, null, set_when_finished );
+        to_anim.animateTo( to_set, 0.0f, 0.0f );
+        add(to_anim);
-    }
-    protected float m_yAspect = 1.0f;
@@ -525 +544 @@
-        {
-            is16by9 = true;
-
-
+
+
+
-        }
-        else
-        {
-            is16by9 = false;
-
-
+
+
+
-        }
-    }
@@ -835 +856 @@
-                break;
-                case GDK_1:
-
-
+
+
+
-                break;
-                case GDK_2:
-
-
+
+
+
-                break;
-                case GDK_3:
-
-
+
+
+
-                break;
-                case GDK_4:
+                    aspectRatioAnim(2.35f, 1.0f);
+                break;
+                case GDK_5:
-                    toggleScalingMode();
-                break;

trunk/pihlaja/src/shiraz/canvas/Image.d

@@ -982 +982 @@
-    }
-    
+    void blur(float blur_amount)
+    {
+        fast_blur(this, this, blur_amount, blur_amount );
+    }
+    
+    /*
+    void blur(float blur_amount_todo)
+    {
+        float blur_amount = 30.0f;
+        
+        //We don't want it to be negative:
+        if( blur_amount < 0.0f )
+            blur_amount = blur_amount * -1.0f;
+            
+        if( blur_amount == 0.0f )
+            return;
+    
+        if( imageData !is null )
+        {
+            float[] grad_result;
+            int red_val = 0;
+            int green_val = 0;
+            int blue_val = 0;
+            int alpha_val = 0;
+            
+            float[] gm = new float[(cast(uint)blur_amount)+1];//[0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.4f, 0.3f, 0.2f, 0.1f];
+            float half_len = (cast(float)gm.length)/2.0f;
+            for( uint i = 0; i < gm.length; i++ )
+            {
+                gm[i] = ((cast(float)i) - half_len) / (half_len);//translate from 0...10 range to -5...5 and then to -1...1 range.
+                //(and actually smaller because of half_len*3.0f)
+                if( gm[i] < 0.0f )//swap negative to be positive. Now we got 1...0...1 range. kind of.
+                    gm[i] = gm[i] * -1.0f;
+                gm[i] = (1.0f - gm[i]) * 0.4;//to 0...1...0 range. And then to 0...0.4...0 range.
+                //This propably could be done earlier, but I'm no mathematician!
+                
+                Trace.formatln("gm: i:{} val: {}", i, cast(double)gm[i] );
+            }
+            int ind = 0;
+            
+            //assert(0);
+            
+            float val1 = 0;
+            float val2 = 0;
+            float val3 = 0;
+            
+            scope GLubyte[] imageDataCopy = imageData.dup;
+            
+            
+            //Horizontal blur:
+            for( uint i = 0; i < height; i++ )
+            {
+                for( uint j = 0; j < width; j++ )
+                {
+                    for( uint c = 0; c < gm.length; c++ )
+                    {
+                        //ind = (cast(int)j - (cast(int)half_len)) + cast(int)c;
+                        ind = (cast(int)j - (cast(int)(half_len/2))) + cast(int)c;
+                    
+                        for( uint chan = 0; chan < channels; chan++ )
+                        {
+                            if( ind >= 0 && ind < width )
+                            {
+                                val1 = gm[c] * imageData[(i*width*channels) + (j*channels) + chan] ;//our source pixel with weight gm[c].
+                                val2 = (1.0f-gm[c]) * imageDataCopy[(i*width*channels) + (ind*channels) + chan];//our target pixels current value
+                                //weighed so that the sum of the weights becomes 1.0.
+                                val3 = val1 + val2;//The result.
+                                
+                                imageDataCopy[(i*width*channels) + (ind*channels) + chan] = cast(uint) val3;
+                            }
+                        }
+                    }
+                }
+            }
+            
+            
+            //Vertical blur:
+            
+            scope GLubyte[] imageDataCopy2 = imageData.dup;
+            
+            for( uint j = 0; j < width; j++ )
+            {
+                for( uint i = 0; i < height; i++ )
+                {
+                    for( uint c = 0; c < gm.length; c++ )
+                    {
+                        ind = (cast(int)i - (cast(int)(half_len/2))) + cast(int)c;
+                    
+                        for( uint chan = 0; chan < channels; chan++ )
+                        {
+                            if( ind >= 0 && ind < height )
+                            {
+                                val1 = gm[c] * imageData[(i*width*channels) + (j*channels) + chan] ;//our source pixel with weight gm[c].
+                                val2 = (1.0f-gm[c]) * imageDataCopy2[(ind*width*channels) + (j*channels) + chan];//our target pixels current value
+                                //weighed so that the sum of the weights becomes 1.0.
+                                val3 = val1 + val2;//The result.
+                                
+                                imageDataCopy2[(ind*width*channels) + (j*channels) + chan] = cast(uint) val3;
+                            }
+                        }
+                    }
+                }
+            }
+            
+            
+            //And now an additional pass to combine the two buffers.
+            
+            for( uint i = 0; i < height; i++ )
+            {
+                for( uint j = 0; j < width; j++ )
+                {
+                    for( uint chan = 0; chan < channels; chan++ )
+                    {
+                        val1 = imageDataCopy[(i*width*channels) + (j*channels) + chan];
+                        val2 = imageDataCopy2[(i*width*channels) + (j*channels) + chan];
+                        val3 = (val1 + val2) * 0.5f;//average.
+                        //val3 = val1;
+                        imageData[(i*width*channels) + (j*channels) + chan] = cast(uint) val3;
+                    }
+                }
+            }
+            
+        }
+    }
+    */
+    
+//The following two functions were taken from librsvg-2.15.90.
+//And modified to fit this class.
+//Here's the licence:
+
+/*
+   rsvg-filter.c: Provides filters
+
+   Copyright (C) 2004 Caleb Moore
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with this program; if not, write to the
+   Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+
+   Author: Caleb Moore <c.moore@student.unsw.edu.au>
+*/
+
+
+static void
+box_blur (Image input, Image output, GLubyte[] intermediate, int kw,
+          int kh )//, RsvgIRect boundarys, RsvgFilterPrimitiveOutput op)
+{
+    int ch;
+    int x, y;
+    //int rowstride;//, 
+    int height = input.height;
+    int width = input.width;
+    int channels = input.channels;
+
+    //GLubyte* in_pixels;
+    //GLubyte* output_pixels;
+
+    int sum;
+
+    //height = gdk_pixbuf_get_height (in);
+    //width = gdk_pixbuf_get_width (in);
+
+    GLubyte[] in_pixels = input.imageData;//gdk_pixbuf_get_pixels (in);
+    GLubyte[] output_pixels = output.imageData;//gdk_pixbuf_get_pixels (output);
+
+    int rowstride = input.width * input.channels;//gdk_pixbuf_get_rowstride (in);
+
+    //if (kw > boundarys.x1 - boundarys.x0)
+    //  kw = boundarys.x1 - boundarys.x0;
+
+    //if (kh > boundarys.y1 - boundarys.y0)
+    //  kh = boundarys.y1 - boundarys.y0;
+
+    if (kw > width)
+        kw = width;
+
+    if (kh > height)
+        kh = height;
+
+
+    if (kw >= 1)
+    {
+        for (ch = 0; ch < channels; ch++)
+        {
+                    /*
+                    switch (ch)
+                        {
+                        case 0:
+                            if (!op.Rused)
+                                continue;
+                        case 1:
+                            if (!op.Gused)
+                                continue;
+                        case 2:
+                            if (!op.Bused)
+                                continue;
+                        case 3:
+                            if (!op.Aused)
+                                continue;
+                        }
+                        */
+                    //for (y = boundarys.y0; y < boundarys.y1; y++)
+                    for (y = 0; y < height; y++)
+                    {
+                            sum = 0;
+                            //for (x = boundarys.x0; x < boundarys.x0 + kw; x++)
+                            for (x = 0; x < 0 + kw; x++)
+                            {
+                                    sum += (intermediate[x % kw] = in_pixels[channels * x + y * rowstride + ch]);
+
+                                    //if (x - kw / 2 >= 0 && x - kw / 2 < boundarys.x1)
+                                    if (x - kw / 2 >= 0 && x - kw / 2 < width)
+                                        output_pixels[channels * (x - kw / 2) + y * rowstride + ch] = sum / kw;
+                            }
+                            //for (x = boundarys.x0 + kw; x < boundarys.x1; x++)
+                            for (x = 0 + kw; x < width; x++)
+                            {
+                                    sum -= intermediate[x % kw];
+                                    sum += (intermediate[x % kw] = in_pixels[channels * x + y * rowstride + ch]);
+                                    output_pixels[channels * (x - kw / 2) + y * rowstride + ch] = sum / kw;
+                            }
+                            //for (x = boundarys.x1; x < boundarys.x1 + kw; x++)
+                            for (x = width; x < width + kw; x++)
+                            {
+                                    sum -= intermediate[x % kw];
+
+                                    //if (x - kw / 2 >= 0 && x - kw / 2 < boundarys.x1)
+                                    if (x - kw / 2 >= 0 && x - kw / 2 < width)
+                                        output_pixels[channels * (x - kw / 2) + y * rowstride + ch] = sum / kw;
+                            }
+                    }
+        }
+        in_pixels = output_pixels;
+    }
+
+        if (kh >= 1)
+        {
+            for (ch = 0; ch < channels; ch++)
+                {
+                    /*
+                    switch (ch)
+                        {
+                        case 0:
+                            if (!op.Rused)
+                                continue;
+                        case 1:
+                            if (!op.Gused)
+                                continue;
+                        case 2:
+                            if (!op.Bused)
+                                continue;
+                        case 3:
+                            if (!op.Aused)
+                                continue;
+                        }
+                    */
+
+                    //for (x = boundarys.x0; x < boundarys.x1; x++)
+                    for (x = 0; x < width; x++)
+                        {
+                            sum = 0;
+
+                            //for (y = boundarys.y0; y < boundarys.y0 + kh; y++)
+                            for (y = 0; y < 0 + kh; y++)
+                                {
+                                    sum += (intermediate[y % kh] = in_pixels[channels * x + y * rowstride + ch]);
+
+                                    //if (y - kh / 2 >= 0 && y - kh / 2 < boundarys.y1)
+                                    if (y - kh / 2 >= 0 && y - kh / 2 < height)
+                                        output_pixels[channels * x + (y - kh / 2) * rowstride + ch] = sum / kh;
+                                }
+                            //for (; y < boundarys.y1; y++)
+                            for (; y < height; y++)
+                                {
+                                    sum -= intermediate[y % kh];
+                                    sum += (intermediate[y % kh] = in_pixels[channels * x + y * rowstride + ch]);
+                                    output_pixels[channels * x + (y - kh / 2) * rowstride + ch] = sum / kh;
+                                }
+                            //for (; y < boundarys.y1 + kh; y++)
+                            for (; y < height + kh; y++)
+                                {
+                                    sum -= intermediate[y % kh];
+
+                                    //if (y - kh / 2 >= 0 && y - kh / 2 < boundarys.y1)
+                                    if (y - kh / 2 >= 0 && y - kh / 2 < height)
+                                        output_pixels[channels * x + (y - kh / 2) * rowstride + ch] = sum / kh;
+                                }
+                        }
+                }
+        }
+}
+
+static void fast_blur(Image input, Image output, float blur_amount_x,
+           float blur_amount_y )//, RsvgIRect boundarys, RsvgFilterPrimitiveOutput op)
+{
+    int kx, ky;
+    
+    kx = cast(int) floor(blur_amount_x * 3.0f * sqrt(2.0f*PI) / 4.0f + 0.5f);
+    ky = cast(int) floor(blur_amount_y * 3.0f * sqrt(2.0f*PI) / 4.0f + 0.5f);
+
+    if (kx < 1 && ky < 1)
+        return;
+
+    scope GLubyte[] intermediate = new GLubyte[max(kx, ky)];
+
+    box_blur (input, output, intermediate, kx,
+              ky );//, boundarys, op);
+    box_blur (output, output, intermediate, kx,
+              ky );//, boundarys, op);
+    box_blur (output, output, intermediate, kx,
+              ky );//, boundarys, op);
+
+}
+
+
+
+    
-    void swapAR()
-    {
@@ -1008 +1336 @@
-    }
-    
-
+
+
+
+
+
+
+
-    {
-        cairo_format_t form = cairo_format_t.ARGB32;

trunk/pihlaja/src/shiraz/canvas/Rectangle.d

@@ -2889 +2889 @@
-            if( set == ScrollbarSetting.ALWAYS )
-                hasVerticalScrollbar = true;
+            else if( set == ScrollbarSetting.NEVER )
+                hasVerticalScrollbar = false;
-                
-            m_verticalScrollbarSetting = set;
@@ -2903 +2905 @@
-            if( set == ScrollbarSetting.ALWAYS )
-                hasHorizontalScrollbar = true;
+            else if( set == ScrollbarSetting.NEVER )
+                hasHorizontalScrollbar = false;
-                
-            m_horizontalScrollbarSetting = set;

trunk/pihlaja/src/shiraz/core/Theme.d

@@ -111 +111 @@
-        createButtonImage();
-        createTopWindowHeaderImage();
+        createBottomWindowHeaderImage();
-    }
-    
@@ -126 +127 @@
-        Image my_image = new Image(256, 64, 4);
-        my_image.name = "Shiraz.Button";
+        drawButton(my_image, true );
+        my_image.blur(2.0f);
-        drawButton(my_image);
+        my_image.writeToPng("/home/joonaz/testi/Button.png");
-        my_image.createTexture();
-        addImage( "Shiraz.Button", my_image );
-    }
-    
-
+, bool is_shadow = false
-    {
-        cairo_format_t form = cairo_format_t.ARGB32;
@@ -198 +202 @@
-            }
-    
-
+
+
+
+
+
+
+
+
+
-    
-            cr.moveTo(xRender, yRender + curve_size);//up-left, lowerpoint
@@ -231 +243 @@
-        */
-        
-
+//
-        
-        cr.destroy();
@@ -244 +256 @@
-        Image my_image = new Image(256, 64, 4);
-        my_image.name = "Shiraz.WindowHeader.Top";
-
-
+
-        my_image.createTexture();
-        addImage( "Shiraz.WindowHeader.Top", my_image );
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-    {
-        cairo_format_t form = cairo_format_t.ARGB32;
@@ -268 +287 @@
-        scope(exit) delete cr;
-    
-
+   //TODO theme the SMALL and NORMAL window sizes...
-        float hei = g_shiraz.getValueFromTheme("Shiraz.WindowHeader.SMALL.defaultHeight") / g_shiraz.pixel;
-    
@@ -291 +310 @@
-                    
-            scope Pattern linear = Pattern.createLinear( xRender, yRender, xRender, yRender + hei );//(0.0, 0.0, 0.0, 20.0) );
+            ColourStop last_colourstop;
-            foreach( ColourStop colstop; gradient )
-            {
+                //We store the last colourstop:
+                last_colourstop = colstop;
+            
-                //BGRA
-                //I checked, and with the current settings the cairo images
@@ -302 +325 @@
-            }
-    
-
+
+
+
+
+
+
+
+
+
-    
-            cr.moveTo(xRender, yRender + curve_size);//up-left, lowerpoint

trunk/pihlaja/src/shiraz/ui/Menu.d

@@ -364 +364 @@
-        followsChildHeight = true;
-        
+        container.followsChildWidth = true;
+        container.followsChildHeight = true;
+        
-        xPackOptions = PackOptions.BYPASS;
-        yPackOptions = PackOptions.BYPASS;
-        
-        arrangeType = ArrangeType.VBOX;
+        container.arrangeType = ArrangeType.VBOX;
+        
+        //A test to see if this helps with the arrange problems
+        //with followsChildWidth:
+        verticalScrollbarSetting = ScrollbarSetting.NEVER;
+        horizontalScrollbarSetting = ScrollbarSetting.NEVER;
+        
+        container.verticalScrollbarSetting = ScrollbarSetting.NEVER;
+        container.horizontalScrollbarSetting = ScrollbarSetting.NEVER;
-        
-        /*
@@ -385 +397 @@
-    }
-
-
+
+
+
+
+
+
+
+
+
-
-    /*

trunk/pihlaja/src/shiraz/ui/Scrollbar.d

@@ -209 +209 @@
-    public void valueMinus()
-    {
+        Trace.formatln("ScrollbarControlRect.valueMinus() CALLED. {}", fullName );
-        value = value - 0.01f;//TODO decide the increment...
-        updateControlRectFromValue();