Hello, I made a tool to paint daylight in a specified element`s background in real-time (as you can see within your window - if you have one ). It`s just a funny little hack so use with bless
PHP Code:
/**
 * This is a daylight coloring tool for ExtJS 3 or ExtCore 3.
 *
 * @author prometheus <fejlesztes@php-sparcle.hu>
 */

Ext.namespace('Color');

/**
 * @class Color.HSV
 * A Hue-Saturation-Value coloring tool class.
 * @constructor
 * @param {Number} h Hue 0-255
 * @param {Number} s Saturation 0-100
 * @param {Number} v Value 0-100
 */
Color.HSV = function(hsv)
{
    
this.h;
    
this.s;
    
this.v;
}

/**
 * @class Color.RGB
 * A Red-Green-Blue coloring tool class.
 * @constructor May call without parameters, that`s creating #000000, or only
 * one string parameter with an HTML-formed RGB color ('#001122').
 * @param {Number} r Red 0-255
 * @param {Number} g Green 0-255
 * @param {Number} b Blue 0-255
 */
Color.RGB = function(rgb)
{
    if (
=== undefined)
    {
        
this.0;
        
this.0;
        
this.0;
    }
    else if (
instanceof String)
    {
        
this.fromHex(r);
    }
    else
    {
        
this.r;
        
this.g;
        
this.b;
    }
}

Color.HSV Ext.extend(Color.HSV, {
    
/**
     * Returns this color in a new RGB object.
     * @return {Color.RGB}
     */
    
toRgb: function()
    {
        var 
rgb;
        var 
this.360;
        var 
this.100;
        var 
this.100;
        var 
var_hvar_ivar_1var_2var_3var_rvar_gvar_b;
        
        if (
== 0)
        {
            
255;
            
255;
            
255;
        }
        else
        {
            
var_h 6;
            
var_i Math.floor(var_h);
            
var_1 * (s);
            
var_2 * (* (var_h var_i));
            
var_3 * (* (- (var_h var_i)));

            if (
var_i == 0) {var_r vvar_g var_3var_b var_1}
            else if (
var_i == 1) {var_r var_2var_g vvar_b var_1}
            else if (
var_i == 2) {var_r var_1var_g vvar_b var_3}
            else if (
var_i == 3) {var_r var_1var_g var_2var_b v}
            else if (
var_i == 4) {var_r var_3var_g var_1var_b v}
            else {
var_r vvar_g var_1var_b var_2};

            
var_r 255;
            
var_g 255;
            
var_b 255;
        }

        return new 
Color.RGB(Math.round(r), Math.round(g), Math.round(b));
    }
});

Color.RGB Ext.extend(Color.RGB, {
    
/**
     * Returns this color as HTML formatted RGB String ('#001122').
     * @return {String}
     */
    
toHex: function()
    {
        return 
'#' this.hexify(this.r) + this.hexify(this.g) + this.hexify(this.b);
    },
    
/**
     * Setup this color by HTML formatted RGB color.
     * @param {String} colorString Color in format '#001122'.
     */
    
fromHex: function(colorString)
    {
        
this.decimalize(colorString.substring(1,3));
        
this.decimalize(colorString.substring(3,5));
        
this.decimalize(colorString.substring(5,7));
    },
    
// private - helper
    
hexify: function(number)
    {
        var 
digits '0123456789ABCDEF';
        var 
lsd number 16;
        var 
msd = (number lsd) / 16;
        var 
hexified digits.charAt(msd) + digits.charAt(lsd);
        return 
hexified;
    },
    
// private - helper
    
decimailze: function(hexNumber)
    {
        var 
digits '0123456789ABCDEF';
        return ((
digits.indexOf(hexNumber.charAt(0).toUpperCase()) * 16) + digits.indexOf(hexNumber.charAt(1).toUpperCase()));
    },
    
/**
     * Helping represent this color as HTML formatted RGB String.
     * @return {String}
     */
    
toString: function()
    {
        return 
this.toHex();
    }
});

/**
 * @class Daylight
 * Static manager-class for daylight coloring a specified element. After the
 * {@link #Daylight.init initialization}, the manager sets the specified element`s
 * backgrund color as the actual time of client browser, and registers a task
 * to actualize this color by time to time. Sample init:
 * <code><pre>Ext.onReady(
    function()
    {
        Daylight.init(Ext.getBody());
    }
);</pre></code>
 */
Daylight =
{
    
/**
     * @property {Color.HSV} HSV
     * Before init, you can change this property for your best. Changing the
     * Hue-value effects in another color (default 200 is a sky-blue like).
     */
    
HSV: new Color.HSV(2001000),
    
// private
    
mulS: -1,
    
// private
    
mulV1,
    
// private
    
Elnull,
    
// private
    
ms0,
    
// private
    
initTasknull,
    
// private
    
initRanfalse,
    
// private - handling a tick of coloring task.
    
tick: function()
    {
        
this.HSV.+= this.mulS;
        
this.HSV.+= this.mulV;
        
        if (
this.HSV.0)
        {
            
this.HSV.0;
            
this.mulS 1;
        }
        else if (
this.HSV.100)
        {
            
this.HSV.100;
            
this.mulS = -1;
        }

        if (
this.HSV.0)
        {
            
this.HSV.0;
            
this.mulV 1;
        }
        else if (
Daylight.HSV.100)
        {
            
this.HSV.100;
            
this.mulV = -1;
        }
    },
    
// private - changes the background color of specified element.
    
paint: function()
    {
        
this.El.applyStyles({
            
backgroundColorDaylight.HSV.toRgb().toString()
        });
        
//console.log('paint! - ' + new Date() + ' - ' + Daylight.HSV.toRgb().toString());
    
},
    
/**
     * Initialize the class and specifing the element being daylight colored.
     * @param {Ext.Element} el
     */
    
init: function(el)
    {
        var 
now = new Date();
        var 
today = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0000);
        var 
ttm;
        
        
this.El el;
        
this.ms 432000// = ((24 / 2) * 60 * 60 * 1000ms) / 100 = 7.2 minutes
        
Math.floor(((now.getTime() - today.getTime())) / this.ms);

        
// Calibrate actual daylight color with playing needed ticks.
        
for (var i=0i<ti++)
        {
            
this.tick();
        }

        
this.paint();

        
// On first case, we need to wait for next tick-time.
        
tm = (now.getTime() - today.getTime()) % this.ms;
        
this.initTask = {
            
intervaltm,
            
run: function()
            {
                if (
Daylight.initRan)
                {
                    
Ext.TaskMgr.stop(Daylight.initTask);

                    
// Task runs 100 times within 12 hours.
                    
Ext.TaskMgr.start({
                        
intervalDaylight.ms,
                        
run: function()
                        {
                            
Daylight.tick();
                            
Daylight.paint();
                        }
                    });
                }
                
Daylight.initRan true;
            }
        }
        
Ext.TaskMgr.start(this.initTask);
    }
}; 
Init code sample:
PHP Code:
Ext.onReady(
    function()
    {
        
Daylight.init(Ext.getBody());
    }
); 
Any replies/responds would be welcome - thanks for use Tested on FF3 ONLY, works properly on it for me.