plat4m.bootstrap(function()
{
    var     JS      = tri4m.lib.loader.Javascript,
        JSLoader    = tri4m.lib.loader.Queue,
        Bootstrap   = new JSLoader({ success : tri4m.compstrap  });

    Bootstrap.push(new JS({ src : JQUERY_SRC, success : Bootstrap.next }));

    setTimeout
    (
        function()
        {
            typeof jQuery === 'undefined'
                ? Bootstrap.start()
                : tri4m.compstrap();
        },
        JQUERY_INIT_TIME
    );
});


tri4m.extend
(
    {
        lib :
        {
            exception :
            {
                Throwable : function(name)
                {
                    var name = name;

                    var constructor = function(message)
                    {
                        //Error.apply(this, arguments);
                        if(this == window) return new arguments.callee(message, level);

                        this.message    = message || '';
                        this.name   = name + '.Exception';
                    };

                    constructor.name = name || 'tri4m.lib.exception.Throwable';
                    constructor.prototype.toString = Error.prototype.toString;

                    return constructor;
                }
            },
            loader :
            {
                /**
                 * @param string src
                 * @param object lfo        the expected object
                 * @param function onload
                 * @param function callback
                 */
                Javascript : function(options)
                {
                    this.name = 'tri4m.lib.loader.Javascript';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);

                    var tried   = false;
                    var avail   = false;

                    var __settings = tri4m.extend(
                    {
                        src     : null,
                        lfo     : null,
                        success     : null
                    }, options);

                    this.load = function()
                    {
                        if(true === tried)
                            return this;

                        tried = true;

                        if(null === __settings.src)
                            throw new this.Exception('src is null.');

                        /* NullReferenceError....
                        if(typeof __settings.lfo !== 'undefined' && __settings.lfo !== null)
                        {
                            tri4m.log('lfo is avail: ' + tri4m.objectToString(__settings.lfo));

                            avail = true;
                            __settings.callback(this);
                            return this;
                        }

                        */

                        tri4m.log('Load script ' + __settings.src);

                        try
                        {
                            var head = document.getElementsByTagName('head')[0],
                                script = document.createElement('script');

                            script.setAttribute('src', __settings.src);
                            script.setAttribute('type', 'text/javascript');
                            script.setAttribute('charset', 'utf-8');

                            script.onload = script.onreadstatechange = function()
                            {
                                if(!this.readyState
                                || this.readyState == 'loaded'
                                || this.readyState == 'complete')
                                {
                                    script.onload = script.onreadystatechange = null;

                                    if(tri4m.isFunction(__settings.success))
                                        __settings.success(__settings);

                                }
                            };

                            head.insertBefore(script, head.firstChild);

                        }
                        catch(e)
                        {
                            throw new this.Exception('Unable to append javasript ' + __settings.src)
                        }


                        return this;
                    }
                },
                /**
                 * @param string src
                 * @param object lfo        the expected object
                 * @param function onload
                 * @param function callback
                 */
                Stylesheet : function(options)
                {
                    this.name = 'tri4m.lib.loader.Stylesheet';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);

                    var tried   = false;
                    var avail   = false;

                    var __settings = tri4m.extend(
                    {
                        src     : null,
                        lfo     : null,
                        success     : null
                    }, options);

                    this.load = function()
                    {
                        if(true === tried)
                            return this;

                        tried = true;

                        if(null === __settings.src)
                            throw new this.Exception('src is null.');

                        /* NullReferenceError....
                        if(typeof __settings.lfo !== 'undefined' && __settings.lfo !== null)
                        {
                            tri4m.log('lfo is avail: ' + tri4m.objectToString(__settings.lfo));

                            avail = true;
                            __settings.callback(this);
                            return this;
                        }

                        */

                        tri4m.log('Load script ' + __settings.src);

                        try
                        {
                            var head = document.getElementsByTagName('head')[0],
                                script = document.createElement('link');

                            script.setAttribute('src', __settings.src);
                            script.setAttribute('type', 'text/css');
                            script.setAttribute('media', 'all');

                            script.onload = script.onreadstatechange = function()
                            {
                                if(!this.readyState
                                || this.readyState == 'loaded'
                                || this.readyState == 'complete')
                                {
                                    script.onload = script.onreadystatechange = null;

                                    if(tri4m.isFunction(__settings.success))
                                        __settings.success(__settings);

                                }
                            };

                            head.insertBefore(script, head.firstChild);

                        }
                        catch(e)
                        {
                            throw new this.Exception('Unable to append stylesheet ' + __settings.src)
                        }


                        return this;
                    }
                },
                /**
                 * Queue-Loader based on Automation-Player
                 *
                 *
                 * var Loader = new tri4m.lib.loader.Queue('Javascript');
                 *
                 * var myComplete = function() { Loader.next(); alert('whohoo'); }
                 *
                 * Loader.push(new tri4m.lib.loader.Javascript({src : 'swfobject.js', success : Loader.next}))
                 * Loader.push(new tri4m.lib.loader.Javascript({src : 'whoohooo.js', success : myComplete }));
                 * Loader.push(new tri4m.lib.loader.Javascript({src : 'another.js', success : Loader.next }));
                 * Loader.start();
                 *
                 *
                 * jQuery is ready before we init our plugins:
                 * plat4m.bootstrap(function()
                 * {
                 *  var JS = tri4m.lib.loader.Javascript, JSLoader = tri4m.lib.loader.Queue,
                 *      Compstrap = new JSLoader,
                 *      Bootstrap = new JSLoader({ success: Compstrap.start });
                 *
                 *  Bootstrap.push(new JS({ src : 'http://localfrost/wp-content/plugins/tri4m/jquery.js', success : Bootstrap.next }));
                 *  Compstrap.push(new JS({ src : 'http://localfrost/wp-content/plugins/tri4m/tri4mQtLoader/js/tri4m.QtLoader.js' }));
                 *
                 *  setTimeout
                 *  (
                 *      function()
                 *      {
                 *          typeof jQuery === 'undefined'
                 *              ? Bootstrap.start()
                 *              : Compstrap.start();
                 *      } , 200
                 *  );
                 * });
                 *
                 * @note calling Loader.next() in File-callback is required
                 * @see ri4m.lib.automation.Player
                 */
                Queue : function(options)
                {
                    var __methods = new tri4m.lib.method.Hook,
                        __player = new tri4m.lib.automation.Player(options);

                    /**
                     * @param tri4m.lib.loader.File File
                     */
                    this.push = function(File)
                    {
                        __methods.push(File.load);
                        return this;
                    }

                    /**
                     * start
                     */
                    this.start = function()
                    {
                        __player.setup(__methods).play();
                        return this;
                    }

                    /**
                     * next
                     */
                    this.next = function()
                    {
                        __player.next();
                        return this;
                    }
                }
            },
            property :
            {
                /**
                 * value for value-queue
                 *
                 * overwrite is allowed or not
                 *
                 * @param value mixed
                 * @param protect bool true: can not overwrite existing value
                 */
                Value : function(value, protect)
                {
                    this.name = 'tri4m.lib.property.Value';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);

                    var __value = value || null;
                    var __protect = (protect === true) ? true : false;

                    /**
                     * get value
                     * @return mixed
                     */
                    this.get = function()
                    {
                        return __value;
                    };

                    /**
                     * set value
                     *
                     * this has no effect, if __protect is true
                     * @return tri4m.lib.property.Value
                     */
                    this.set = function(value)
                    {
                        if(__protect === true)
                            throw new this.Exception(value + ' is protected', 3);

                        __value = value;
                        return this;
                    };

                    /**
                     * get variable as object
                     *
                     * @return object
                     */
                    this.toObject = function()
                    {
                        return {
                            value   : __value,
                            protect : __protect
                        };
                    };
                },
                /**
                 * value registry
                 *
                 * store vars with values
                 *
                 * // new value-queue
                 * var foo = new tri4m.lib.property.Registry();
                 *
                 * // var "baz"
                 * foo.register('baz', 'baz: bar'); log.t100(foo.get('baz')); // baz: bar
                 * foo.set('baz', 'baz: bar -> foo'); log.t100(foo.get('baz')); // baz: foo
                 *
                 * // protected var "foo"
                 * foo.register('foo', 'foo: lol', true); log.t100(foo.get('foo')); // foo: lol
                 * foo.set('foo', 'foo: lol -> rofl'); log.t100(foo.get('foo')); // foo: lol
                 */
                Registry : function()
                {
                    this.name = 'tri4m.lib.property.Registry';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);

                    var __data = {};

                    /**
                     * register value-instance
                     *
                     * @param name string instance-name
                     * @param value mixed
                     * @param protect bool true: can not overwrite existing value
                     * @see tri4m.lib.property.Value()
                     * @return tri4m.lib.property.Registry
                     */
                    this.register = function(name, value, protect)
                    {
                        if(this.isset(name) === true)
                            throw new this.Exception('Unable to register existing property ' +  name, 3);

                        __data[name] = new tri4m.lib.property.Value(value, protect);

                        return this;
                    };

                    /**
                     * unregister value-instance
                     *
                     * @param name string instance-name
                     * @return tri4m.lib.property.Registry
                     */
                    this.unregister = function(name)
                    {
                        if(this.isset(name) === false)
                            return this;

                        delete _data[name]

                        return this;
                    };

                    /**
                     * isset instance
                     *
                     * @param name string instance-name
                     * @return bool
                     */
                    this.isset = function(name)
                    {
                        return (!__data[name]) ? false : true;
                    };

                    /**
                     * get value of instance
                     *
                     * @param name string instance-name
                     * @see tri4m.lib.property.Value.get()
                     * @return tri4m.lib.property.Value || null
                     */
                    this.get = function(name)
                    {
                        return ((this.isset(name) === true) ? __data[name].get() : null);
                    };

                    /**
                     * set value of instance
                     *
                     * you must register your variable at first!
                     * you can not use this registry as garbage dump!
                     *
                     * @param name string instance-name
                     * @param value mixed
                     * @see tri4m.lib.property.Value.set()
                     * @return tri4m.lib.property.Registry
                     */
                    this.set = function(name, value)
                    {
                        if(false === this.isset(name))
                            throw new this.Exception('Unable to update value for ' +  name + ': not found', 3);

                        try{ __data[name].set(value); }
                        catch(e){ throw new this.Exception('Unable update value for ' +  name, 3); }

                        return this;
                    };

                    /**
                     * get queue as object
                     *
                     * @return tri4m.lib.property.Registry  as propertyName:propertyValue object
                     */
                    this.toObject = function()
                    {
                        var q = {};
                        for(i in __data)
                            q[i] = __data[i].toObject();
                        return q;
                    };

                    /**
                     * get queue as value object
                     *
                     * @return tri4m.lib.property.Registry.__data as propertyValue object
                     */
                    this.toValueObject = function()
                    {
                        var q = {};
                        for(i in __data)
                            q[i] = __data[i].toObject().value;
                        return q;
                    };

                    /**
                     * get queue as property object
                     *
                     * @return tri4m.lib.property.Registry.__data as propertyName object
                     */
                    this.toPropertyObject = function()
                    {
                        var q = {};
                        var k = 0;
                        for(i in __data)
                        {
                            q[k] = i;
                            k++;
                        }
                        return q;
                    };
                }
            },
            method :
            {
                /**
                 * method FIFO
                 *
                 * @param runonce bool true: terminate queue on exec
                 *
                 * // some stuff
                 * var test11 = function(){log.t100('test1.1')};
                 * var test12 = function(){log.t100('test1.2')};
                 *
                 * // default queue
                 * var bar = new tri4m.lib.method.Hook;
                 * bar.push(test11).push(test12)
                 *  .execute()  // test1.1 test1.2
                 *  .execute(); // test1.1 test1.2
                 *
                 * // run-once queue
                 * var baz = new tri4m.lib.method.Hook(true);
                 * baz.push(test11).push(test12)
                 *  .execute()  // test1.1 test1.2
                 *  .execute(); // nothing
                 */
                Hook : function(runonce)
                {
                    this.name = 'tri4m.lib.method.Hook';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);

                    var __hook = [];
                    var __runonce = (runonce !== true) ? false : true;

                    /**
                     * add function to queue
                     *
                     * @param fn function
                     * @return tri4m.lib.method.Hook
                     */
                    this.push = function(fn)
                    {
                        __hook.push(fn);
                        return this;
                    };

                    /**
                     * execute queue
                     *
                     * @return tri4m.lib.method.Hook
                     */
                    this.execute = function()
                    {
                        if(__hook.length === 0)
                            return this;

                        if(__runonce === false)
                            for(i in __hook) __hook[i]();
                        else
                            while(__hook.length > 0) (__hook.shift())();

                        return this;
                    };

                    /**
                     * terminate queue
                     *
                     * @return tri4m.lib.method.Hook
                     */
                    this.reset = function()
                    {
                        __hook = [];
                        return this;
                    };

                    /**
                     * get queue as array
                     *
                     * @return tri4m.lib.method.Hook.__hook... imho as copy
                     */
                    this.toArray = function()
                    {
                        var a = __hook;
                        return a;
                    };
                },
                /**
                 * method hook registry
                 *
                 * // some stuff
                 * var test11 = function(){log.t100('test1.1')};
                 * var test12 = function(){log.t100('test1.2')};
                 * var test21 = function(){log.t100('test2.1')};
                 * var test22 = function(){log.t100('test2.2')};
                 *
                 * // create registry queue
                 * var foo = new tri4m.lib.method.Registry();
                 *
                 * // default queue
                 * foo.register('test1').push('test1', test11).push('test1', test12)
                 *  .execute('test1')   // test1.1 test1.2
                 *  .execute('test1');  // test1.1 test1.2
                 *
                 * // run-once queue
                 * foo.register('test2', true).push('test2', test11).push('test2', test12)
                 *  .execute('test2')   // test2.1 test2.2
                 *  .execute('test2');  // nothing
                 *
                 *
                 * // shorthand:
                 * // default queue
                 * foo.get('test3').push(test21).push(test22)
                 *  .execute()  // test2.1 test2.2
                 *  .execute(); // test2.1 test2.2
                 *
                 * // run-once queue
                 * foo.get('test4', true).push(test21).push(test22)
                 *  .execute()  // test2.1 test2.2
                 *  .execute(); // nothing
                 */
                Registry : function()
                {
                    this.name = 'tri4m.lib.method.Registry';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);

                    var __hook = new tri4m.lib.property.Registry();

                    /**
                     * register queue instance
                     *
                     * @param name string instance-name
                     * @param runonce bool
                     * @see tri4m.lib.method.Hook()
                     * @see tri4m.lib.property.Registry.register()
                     * @return tri4m.lib.method.Registry
                     */
                    this.register = function(name, runonce)
                    {
                        __hook.register(name, new tri4m.lib.method.Hook(runonce), true);
                        return this;
                    };

                    /**
                     * isset instance
                     *
                     * @param name string instance-name
                     * @see tri4m.lib.property.Registry.isset()
                     * @return bool tri4m.lib.property.Registry.isset()
                     */
                    this.isset = function(name)
                    {
                        return __hook.isset(name);
                    };

                    /**
                     * get/create queue instance
                     *
                     * @param name string instance-name
                     * @param runonce bool
                     * @see tri4m.lib.method.Hook
                     * @return tri4m.lib.method.Hook
                     */
                    this.get = function(name, runonce)
                    {
                        //log.t100(__hook.get(name).className());
                        if(this.isset(name) === false)
                            this.register(name, runonce);
                        return __hook.get(name);
                    };

                    /**
                     * execute queue of instance
                     *
                     * @param name string instance-name
                     * @see tri4m.lib.method.Hook.execute()
                     * @return tri4m.lib.method.Registry
                     */
                    this.execute = function(name)
                    {
                        if(this.isset(name) === true)
                            this.get(name).execute();
                        return this;
                    };

                    /**
                     * terminate queue
                     *
                     * @see tri4m.lib.method.Hook.reset()
                     * @return tri4m.lib.method.Registry
                     */
                    this.reset = function(name)
                    {
                        if(this.isset(name) === true)
                            this.get(name).reset();
                        return this;
                    };

                    /**
                     * add function to queue of instance
                     *
                     * @param name string instance-name
                     * @param fn function
                     * @see tri4m.lib.method.Hook.push()
                     * @return tri4m.lib.method.Registry
                     */
                    this.push = function(name, fn)
                    {
                        if(this.isset(name) === true)
                            this.get(name).push(fn);
                        return this;
                    };

                    /**
                     * get queue as object
                     *
                     * @return tri4m.lib.property.Registry.__hook as copy
                     */
                    this.toObject = function()
                    {
                        return __hook.toObject();
                    };

                    /**
                     * get queue as object
                     *
                     * @return tri4m.lib.property.Registry.__hook as copy
                     */
                    this.getHook = function()
                    {
                        var q = __hook;
                        return q;
                    };
                }
            },
            automation :
            {
                /**
                 * animation playlist player
                 *
                 * split methods from tri4m.lib.method.Hook
                 * to partials
                 *
                 * @example tri4m.lib.loader.Queue
                 *
                 *
                 * step 1:
                 *  create your methods:
                 *
                 * ...
                 * Env :
                 * {
                 *  Playlists : null,
                 *  Animation :
                 *  {
                 *      test10 : function(){
                 *          log.t100('test10');
                 *          tri4m('ul.list li').css({height: 5});
                 *          tri4m.Env.Playlists.next('intro');
                 *      },
                 *      test11 : function(){
                 *          log.t100('test11');
                 *          tri4m('ul.list li').animate({height: 140}, 2200, function()
                 *          {
                 *              log.t100('test11 anim callback');
                 *              tri4m.Env.Playlists.next('intro');
                 *          });
                 *      },
                 *      test12 : function(){
                 *          log.t100('test12');
                 *          tri4m('ul.list li').css({width: 10});
                 *          tri4m.Env.Playlists.next('intro');
                 *      },
                 *      test13 : function(){
                 *          log.t100('test13');
                 *          tri4m('ul.list li').animate({width: 140}, 2200);
                 *          tri4m.Env.Playlists.next('intro');
                 *      }
                 *  }
                 * },
                 * ...
                 *
                 *
                 * step 2:
                 *  init the animation registry and register
                 *  the methods into sections, e.g. "intro" or "button-hover"
                 *
                 * ...
                 * test : function()
                 * {
                 *  tri4m.Env.Playlists =
                 *      new tri4m.lib.automation.Registry();
                 *
                 *  tri4m.Env.Playlists.register('intro')
                 *      .push(tri4m.Env.Animation.test10)
                 *      .push(tri4m.Env.Animation.test11)
                 *      .push(tri4m.Env.Animation.test12)
                 *      .push(tri4m.Env.Animation.test13)
                 *  ;
                 *  tri4m.Env.Playlists.play('intro');
                 * },
                 * ...
                 *
                 *
                 * @todo    lock, pause, start, stop not really implemented
                 */
                Player : function(options)
                {
                    this.name = 'tri4m.lib.automation.Player';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);


                    var __settings = tri4m.extend(
                    {
                        onPlayStart : tri4m.noop,
                        onPlayNext  : tri4m.noop,
                        onPlayPause : tri4m.noop,
                        onPlayStop  : tri4m.noop,
                        success : tri4m.noop
                    }, options);

                    /**
                     * method registry queue
                     */
                    var __registry = null;

                    /**
                     * __isPlaying bool status quo
                     */
                    var __isPlaying = false;

                    /**
                     * translated registry as func-callback-object
                     */
                    var __playlist = [];

                    /**
                     * working-copy of __playlist
                     */
                    var __playqueue = [];

                    /**
                     * counter
                     */
                    var __playedTimes = 0;

                    /**
                     * install method queue
                     *
                     * @param registry tri4m.lib.method.Hook
                     * @return tri4m.lib.automation.Player
                     */
                    this.setup = function(registry)
                    {
                        if(__registry !== null)
                            return this;

                        __registry = registry;

                        var methods = __registry.toArray();

                        for(var i = 0; i < methods.length; i++)
                        {
                            var fn = methods[i];

                            if(typeof fn !== 'function')
                                continue;

                            var cb = function(){};

                            if((next = methods[i+1]))
                            {
                                if(typeof next !== 'function')
                                    continue;

                                cb = next;
                            }

                            var item = {
                                method: fn,
                                callback :
                                {
                                    method : cb
                                }
                            };

                            __playlist.push(item);
                        }

                        return this;
                    };

                    /**
                     * init playing
                     *
                     * @return tri4m.lib.automation.Player
                     */
                    this.play = function()
                    {
                        if(true === this.isPlaying())
                            return false;

                        if(__playqueue.length === 0)
                        {
                            __playedTimes++;
                            __settings.onPlayStart();
                        }


                        __isPlaying = true;
                        __playqueue = __playlist;


                        this.next();
                        return this;
                    };

                    /**
                     * play next method
                     *
                     * test11 : function(){
                     *  log.t100('test11');
                     *  tri4m('ul.list li').animate({height: 140}, 2200, function()
                     *  {
                     *      log.t100('test11 anim callback');
                     *      tri4m.Env.Playlists.next('intro');
                     *  });
                     * },
                     *
                     * @return tri4m.lib.automation.Player
                     */
                    this.next = function()
                    {
                        if(null === __playqueue)
                            return this;

                        var next = null;

                        if(__playqueue.length > 0)
                            next = __playqueue.shift();

                        if(!next)
                        {
                            this.stop();
                            __settings.success();
                            return this;
                        }

                        __settings.onPlayNext();
                        next.method();

                        return this;
                    };

                    /**
                     * pause
                     *
                     * @return tri4m.lib.automation.Player
                     */
                    this.pause = function()
                    {
                        __isPlaying = false;
                        __settings.onPlayPause();
                        return this;
                    };

                    /**
                     * stop/abort playing and delete working copy
                     *
                     * @return tri4m.lib.automation.Player
                     */
                    this.stop = function()
                    {
                        __playqueue = [];
                        __isPlaying = false;
                        __settings.onPlayStop();
                        return this;
                    };

                    /**
                     * is playing status
                     *
                     * @return bool status quo
                     */
                    this.isPlaying = function()
                    {
                        return __isPlaying;
                    };
                },
                /**
                 * playlist class
                 *
                 * holds a methodhook (playlist) and the player
                 *
                 */
                Playlist : function()
                {
                    this.name = 'tri4m.lib.automation.Playlist';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);

                    /**
                     * method queue/playlist
                     */
                    var __playlist  = new tri4m.lib.method.Hook();

                    /**
                     * player
                     */
                    var __player    = new tri4m.lib.automation.Player();

                    /**
                     * push method to __playlist
                     *
                     * @param function
                     * @return tri4m.lib.automation.Playlist
                     */
                    this.push = function(fn)
                    {
                        __playlist.push(fn);
                        return this;
                    };

                    /**
                     * initialize player and start playing
                     *
                     * @return tri4m.lib.automation.Playlist
                     */
                    this.play = function()
                    {
                        __player.setup(__playlist).play();
                        return this;
                    };

                    /**
                     * play next frame
                     *
                     * this is the callback-caller
                     *
                     * test11 : function(){
                     *  log.t100('test11');
                     *  tri4m('ul.list li').animate({height: 140}, 2200, function()
                     *  {
                     *      log.t100('test11 anim callback');
                     *      tri4m.Env.Playlists.next('intro');
                     *  });
                     * },
                     *
                     *
                     * @return tri4m.lib.automation.Playlist
                     */
                    this.next = function()
                    {
                        __player.next();
                        return this;
                    };
                },
                /**
                 * playlist/player registry
                 *
                 * store animation-queues by event-name
                 *
                 */
                Registry : function()
                {
                    this.name = 'tri4m.lib.automation.Registry';
                    this.Exception = new tri4m.lib.exception.Throwable(this.name);

                    var __queue = new tri4m.lib.property.Registry();

                    /**
                     * craete a new playlist-instance
                     *
                     * @param string instance name
                     * @return tri4m.lib.automation.Playlist
                     */
                    this.register = function(name)
                    {
                        __queue.register(name, new tri4m.lib.automation.Playlist(), true);
                        return __queue.get(name);
                    };

                    /**
                     * get playlist-instance
                     *
                     * @param string instance name
                     * @return tri4m.lib.automation.Playlist
                     */
                    this.get = function(name)
                    {
                        return __queue.get(name);
                    };

                    /**
                     * play a playlist-instance
                     *
                     * @param string instance name
                     * @return tri4m.lib.automation.Registry
                     */
                    this.play = function(name)
                    {
                        __queue.get(name).play();
                        return this;
                    };

                    /**
                     * play next callback
                     *
                     * @param string instance name
                     * @return tri4m.lib.automation.Registry
                     */
                    this.next = function(name)
                    {
                        __queue.get(name).next();
                        return this;
                    };
                }
            }
        }
    }
);

tri4m.extend
(
    {
        append :
        {
            /**
             * head:
             *
             * (function(tri4m, undefined)
             * {
             *  tri4m(function()
             *  {
             *      tri4m.append([
             *          'plugin.js',
             *          'another.js'
             *      ],
             *      {
             *          success : function()
             *          {
             *              tri4m.log('-- init my plugin');
             *          }
             *      });
             *  });
             * })(tri4m);
             */
            Javascript : function(src, options, hold)
            {
                var __settings = tri4m.extend
                (
                    {
                        success : tri4m.noop
                    },
                    options
                );

                if(typeof stack === 'undefined')
                     stack = new tri4m.lib.loader.Queue({ success : __settings.success });

                if(typeof src !== 'string')
                {
                    var i = 0, l = src.length;

                    for(var name in src)
                    {
                        i++;
                        tri4m.append.Javascript(src[name], {}, i !== l)
                    }

                    return tri4m.com;
                }

                if(typeof cache === 'undefined')
                    cache = [];

                for(var i in cache)
                    if(src === cache[i])
                        return tri4m.com;

                cache.push(src);

                tri4m.log('append script ' + src);


                var cur = stack;

                stack.push(new tri4m.lib.loader.Javascript(
                {
                    //src : src + '?' + Math.random(0, 100000000),
                    src : src,
                    success : cur.next

                }));

                if(!hold || hold !== true)
                    stack.start();

                return tri4m;
            },
            Stylesheet : function(src, options, hold)
            {
                var __settings = tri4m.extend
                (
                    {
                        success : tri4m.noop
                    },
                    options
                );

                if(typeof stack === 'undefined')
                     stack = new tri4m.lib.loader.Queue({ success : __settings.success });

                if(typeof src !== 'string')
                {
                    var i = 0, l = src.length;

                    for(var name in src)
                    {
                        i++;
                        tri4m.append.Stylesheet(src[name], {}, i !== l)
                    }

                    return tri4m.com;
                }

                if(typeof cache === 'undefined')
                    cache = [];

                for(var i in cache)
                    if(src === cache[i])
                        return tri4m.com;

                cache.push(src);

                tri4m.log('append script ' + src);


                var cur = stack;

                stack.push(new tri4m.lib.loader.Stylesheet(
                {
                    //src : src + '?' + Math.random(0, 100000000),
                    src : src,
                    success : cur.next
                }));

                if(!hold || hold !== true)
                    stack.start();

                return tri4m;
            }
        }