function Director() {

    // Defining states for StateAutomaton:
    var stIntro = new State("Intro");
    var stPlayerStopped = new State("PlayerStopped");
    var stPlayerPaused = new State("PlayerPaused");
    var stPlayerMuted = new State("PlayerMuted");
    var stPlaysStream = new State("PlaysStream");
    var stPlaysItem = new State("PlaysItem");
    var stMenuShown = new State("MenuShown");
    var stMenuItemSelected = new State("MenuItemSelected");
    
    this.radio = new Menu("radio");
    this.menu = new Menu('menu');
    
    this.onlinePlayerFrame;
    this.stopButton;
    
    var meDirector = this;
    
    this.animUtil = new AnimationUtil(this);
    this.sndPlayer;
    this.lastStateToGoBackTo = stPlayerStopped;
    this.stateAutomat;
    
    function initStateAutomat() {
    
        // allowed to go to which state:
        stIntro.setAllowedFollowing([stPlayerStopped.name]);
        stIntro.setSelfActivationAllowed(true);
        
        stPlayerStopped.setAllowedFollowing([stPlaysStream.name, stMenuShown.name, stMenuItemSelected.name]);
        stPlaysStream.setAllowedFollowing([stPlayerStopped.name, stPlayerPaused.name, stPlayerMuted.name, stMenuShown.name]);
        stPlaysItem.setAllowedFollowing([stPlayerStopped.name, stPlayerPaused.name, stPlayerMuted.name, stMenuShown.name, stPlaysStream.name]);
        
        stPlayerPaused.setAllowedFollowing([stPlaysStream.name, stPlaysItem.name, stMenuShown.name]);
        stPlayerMuted.setAllowedFollowing([stPlaysStream.name, stPlaysItem.name, stMenuShown.name]);
        
        stMenuShown.setAllowedFollowing([stMenuItemSelected.name, stPlayerStopped.name, stPlaysStream.name, stPlayerPaused.name, stPlayerMuted.name, stPlaysItem.name])
        stMenuItemSelected.setAllowedFollowing([stPlaysItem.name]);
        
        // what to do if state becomes active:
        stIntro.setActivationBehaviour(meDirector._stIntroActions);
        stPlayerStopped.setActivationBehaviour(meDirector._stPlayerStoppedActions);
        stPlayerPaused.setActivationBehaviour(meDirector._stPlayerPausedActions);
        stPlayerMuted.setActivationBehaviour(meDirector._stPlayerMutedActions);
        stPlaysStream.setActivationBehaviour(meDirector._stPlaysStreamActions);
        stPlaysItem.setActivationBehaviour(meDirector._stPlaysItemActions);
        stMenuShown.setActivationBehaviour(meDirector._stMenuShownActions);
        stMenuItemSelected.setActivationBehaviour(meDirector._stItemSelectedActions);
        
        
        meDirector.stateAutomat = new StateAutomaton();
        
        // set state automatons states:
        meDirector.stateAutomat.addState(stIntro);
        meDirector.stateAutomat.addState(stPlayerStopped);
        meDirector.stateAutomat.addState(stPlayerPaused);
        meDirector.stateAutomat.addState(stPlayerMuted);
        meDirector.stateAutomat.addState(stPlaysStream);
        meDirector.stateAutomat.addState(stPlaysItem);
        meDirector.stateAutomat.addState(stMenuShown);
        meDirector.stateAutomat.addState(stMenuItemSelected);
    }
    
    // -------------------------------------------------------------------------
    // 								STATE: Intro
    // -------------------------------------------------------------------------
    this.doStart = function() {
    
        // we wanna start with rotation animation in every case
        var startState = meDirector.stateAutomat.currentState;
        
        if (startState.name != stIntro.name) {
            meDirector.animUtil.startLogoAnimation();
            meDirector.animUtil.makeItemsVisible();
            meDirector.animUtil.runCurrentStrategyWithAllItems();
            meDirector.animUtil.showUIElements();
            meDirector.animUtil.showUIControls();
            meDirector.menu.hide();
        }
        this.stateAutomat.goToState(startState);
    }
    
    this._stIntroActions = function() {
    
        if (DEBUG) {
            console.debug("STATE: Init with intro");
        }
        var timeline = new Timeline(self);
        
        // logo animation:
        if (DEBUG) {
            timeline.addEvent(1, function() {
                console.debug("logo animation INIT");
            });
        }
        timeline.addEvent(logoAnimationStartMs, meDirector.animUtil.startLogoAnimation);
        if (DEBUG) {
            timeline.addEvent(1, function() {
                console.debug("logo animation DONE.");
            });
        }
        
        if (!skipIntro) {
            // intro:
            if (DEBUG) {
                timeline.addEvent(1, function() {
                    console.debug("intro INIT");
                });
            }
            meDirector.animUtil.doIntro(timeline);
            if (DEBUG) {
                timeline.addEvent(1, function() {
                    console.debug("intro DONE.");
                });
            }
        }
        
        // show actors:
        if (DEBUG) {
            timeline.addEvent(1, function() {
                console.debug("show actors INIT");
            });
        }
        timeline.addEvent(initActorsAnimationMs, meDirector.animUtil.makeItemsVisible);
        if (DEBUG) {
            timeline.addEvent(1, function() {
                console.debug("show actors DONE.");
            });
        }
        
        
        // interface
        if (DEBUG) {
            timeline.addEvent(1, function() {
                console.log("show interface INIT");
            });
        }
        meDirector.animUtil.showInterface(timeline);
        if (DEBUG) {
            timeline.addEvent(1, function() {
                console.log("show interface DONE.");
            });
        }
        
        timeline.addEvent(1, meDirector.goToPlayerStop);
        timeline.play();
    }
    
    // -------------------------------------------------------------------------
    // 								STATE: PlayerMuted
    // -------------------------------------------------------------------------
    this.togglePlayerMute = function() {
        if (meDirector.getState() == stPlayerMuted) {
            meDirector.sndPlayer.unmute();
            meDirector.stateAutomat.goToState(lastStateToGoBackTo);
        }
        else {
            lastStateToGoBackTo = meDirector.getState();
            meDirector.stateAutomat.goToState(stPlayerMuted);
        }
    }
    this._stPlayerMutedActions = function() {
        if (DEBUG) {
            console.log("STATE: PlayerMuted");
        }
        if (!meDirector.sndPlayer.isMuted()) {
            meDirector.sndPlayer.mute();
        }
    }
    
    // -------------------------------------------------------------------------
    // 								STATE: PlayerPaused
    // 									   - same as PlayerMuted
    // -------------------------------------------------------------------------
    this.togglePlayerPause = function() {
        meDirector.togglePlayerMute();
    }
    this._stPlayerPausedActions = function() {
        };
    
    // -------------------------------------------------------------------------
    // 								STATE: PlayerStopped
    // -------------------------------------------------------------------------
    this.goToPlayerStop = function() {
        meDirector.stateAutomat.goToState(stPlayerStopped);
    }
    
    this._stPlayerStoppedActions = function() {
    
        if (DEBUG) {
            console.log("STATE: PlayerStopped");
        }
        if (meDirector.sndPlayer.isPlaying()) {
            meDirector.sndPlayer.stop();
            
            // hide player:
            meDirector.onlinePlayerFrame.src = "about:blank";
            meDirector.onlinePlayerFrame.style.zIndex = 1;
            meDirector.onlinePlayerFrame.style.display = 'none';
            
            $$('a.teaser').invoke('show');
        }
        
        meDirector.animUtil.hideSliders();
        meDirector.animUtil.doStandingHoverOnCircle();
        
        meDirector.animUtil.shuffle();
    }
    
    // -------------------------------------------------------------------------
    // 								STATE: PlaysStream
    // -------------------------------------------------------------------------
    this.goToPlayStream = function() {
        meDirector.stateAutomat.goToState(stPlaysStream);
    }
    
    this._stPlaysStreamActions = function() {
        if (DEBUG) {
            console.log("STATE: PlaysStream");
        }
        
        meDirector.menu.hide();
        meDirector.animUtil.getLogo().hideNeighbor();
        
        if (!meDirector.sndPlayer.isPlayingStream()) {
        
            // show player frame:
            meDirector.onlinePlayerFrame.src = "player.action";
            meDirector.onlinePlayerFrame.style.zIndex = 100;
            meDirector.onlinePlayerFrame.style.display = 'block';
            
            // hide teasers:
            $$('a.teaser').invoke('hide');
            
            meDirector.sndPlayer.playStream();
        }
        
        meDirector.animUtil.showSliders();
        
        meDirector.animUtil.outItemsBackToStrategy();
        meDirector.animUtil.shuffle();
    }
    
    // -------------------------------------------------------------------------
    // 								STATE: PlaysItem
    // -------------------------------------------------------------------------
    this.goToPlayItem = function(itemId) {
        meDirector.sndPlayer.itemToPlayId = itemId;
        // meDirector.sndPlayer.playArchive(itemId);
        meDirector.stateAutomat.goToState(stPlaysItem);
    }
    
    this._stPlaysItemActions = function() {
    
        if (DEBUG) {
            console.log("STATE: PlaysItem (No. " + meDirector.sndPlayer.itemToPlayId + ")");
        }
        
        meDirector.animUtil.doStandingHoverOnCircle();
        meDirector.putLogoToCorner();
        
        if (meDirector.sndPlayer.isPlayingArchive() &&
        meDirector.sndPlayer.getPlayingArchiveId() == meDirector.sndPlayer.itemToPlayId) { // this archive-item is playing already
            return;
        }
        
        meDirector.onlinePlayerFrame.src = "about:blank";
        meDirector.onlinePlayerFrame.style.zIndex = 1;
        meDirector.onlinePlayerFrame.hide();
        // meDirector.stuffPlayer.style.display="block";
        meDirector.sndPlayer.playArchive(); // set a number before in players var: itemToPlayId
    }
    
    // -------------------------------------------------------------------------
    // 								STATE: MenuShown
    // -------------------------------------------------------------------------
    this.toggleMenu = function() {
        var state = meDirector.getState();
        if (state.name != stMenuShown.name) {
            meDirector.lastStateToGoBackTo = state;
            meDirector.stateAutomat.goToState(stMenuShown);
        }
        else {
            meDirector.menu.hide();
            meDirector.stateAutomat.goToState(meDirector.lastStateToGoBackTo);
        }
    }
    
    this._stMenuShownActions = function() {
    
        if (DEBUG) {
            console.log("STATE: MenuShown");
        }
        
        meDirector.menu.show();
        meDirector.animUtil.lineAllItemsUp();
    }
    
    
    // -------------------------------------------------------------------------
    // 								STATE: MenuItemSelected
    // -------------------------------------------------------------------------
    this.goToMenuItemSelected = function(itemId) {
        meDirector.stateAutomat.goToState(stMenuItemSelected);
        meDirector.goToPlayItem(itemId);
    }
    
    this._stItemSelectedActions = function() {
        if (DEBUG) {
            console.log("STATE: MenuItemSelected");
        }
        meDirector.menu.hide();
    }
    
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
    
    this.toggleRadio = function() {
        meDirector.radio.toggle();
    }
    
    /**
     * @param archiveItemId, if it's not given the director will have it's normal behaviour (show intro etc.). If an id is given, it will start with playing this doodad
     */
    this.init = function(doPlay) {
    
        if (DEBUG) {
            console.log("starting init director");
        }
        
        this.animUtil.init();
        this.sndPlayer = this.animUtil.sndPlayer;
        
        this.stopButton = $('stop');
        this.onlinePlayerFrame = $('onlinePlayer');
        
        var startingState = stIntro;
        if (doPlay) {
            startingState = stPlaysStream;
        }
        initStateAutomat();
        
        meDirector.lastStateToGoBackTo = stPlayerStopped;
        meDirector.stateAutomat.setStartState(startingState);
        
        if (DEBUG) {
            console.log("init director DONE.");
        }
    }
    
    
    // Actors Events:
    this.evtActorClick = function() {
        if (!meDirector.sndPlayer.isPlaying()) {
            meDirector.sndPlayer.playSoundRandom();
        }
    }
    
    this.evtActorWithBubbleMouseOver = function() {
        if (!meDirector.sndPlayer.isPlayingStream() && !meDirector.animUtil.isAnimating()) {
            this.showNeighbor();
        }
    }
    
    this.evtActorWithBubbleMouseOut = function() {
        this.hideNeighbor();
    }
    
    this.evtLogoClick = function() {
        var state = meDirector.getState();
        if (state.name == stPlaysStream.name) {
            meDirector.goToPlayerStop();
            return;
        }
        else if (state.name == stPlaysItem.name) {
            location.href = 'home.action';
        }
        meDirector.goToPlayStream();
    }
    
    this.evtArchiveItemClick = function(id) {
        var isNew = true;
        if (meDirector.sndPlayer.isPlayingArchive() &&
        meDirector.sndPlayer.getPlayingArchiveId() == id) { // this archive-item is playing already
            isNew = false;
        }
        var oldWindow = window;
        var newWin = window.open('/4duk/home.action?archiveItemId=' + id, window.name);
        newWin.history = oldWindow.history;
    }
    
    this.evtToggleDoAnimation = function() {
    
        if (meDirector.animUtil.getAnimator().isRunning()) {
            meDirector.animUtil.stopAnimation();
            meDirector.stopButton.update("ctарт");
        }
        else {
            meDirector.animUtil.resumeAnimation();
            meDirector.stopButton.update("stoп");
        }
        
    }
    
    
    // ------------------------------------------------------------------------------------------
    // 											helpers:
    // ------------------------------------------------------------------------------------------
    
    this.putLogoToCorner = function() {
        var logo = meDirector.animUtil.getLogo();
        var dim = meDirector.animUtil.getWindowDimensions();
        var position = dim.getTopRightPoint();
        position = position.add(new Point((logo.xOffset * 2), -1 * (logo.yOffset * 2)));
        logo.movementStrategy.center = position;
        logo.hideNeighbor();
    }
    
    this.getPossibleStrategies = function() {
        var strategyNames = ["StrategyTwister", "StrategyRotationY", "StrategyRotationX", "StrategyHorizontalHop", "StrategyVerticalHop"];
        return strategyNames;
    }
    
    this.getStartingStrategy = function() {
        return this.animUtil.getAnimator().getStrategyById(this.getPossibleStrategies()[0]);
    }
    
    this.getState = function() {
        return this.stateAutomat.getCurrentState();
    }
    
    this.logItems = function() {
        meDirector.animUtil.logItems();
    }
    
}