var Component_LayoutSceneBehavior,
  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  hasProp = {}.hasOwnProperty;

Component_LayoutSceneBehavior = (function(superClass) {
  extend(Component_LayoutSceneBehavior, superClass);


  /**
  * The base class of all scene-behavior components. A scene-behavior component
  * define the logic of a single game scene. 
  *
  * @module gs
  * @class Component_LayoutSceneBehavior
  * @extends gs.Component_SceneBehavior
  * @memberof gs
   */

  function Component_LayoutSceneBehavior() {
    Component_LayoutSceneBehavior.__super__.constructor.call(this);
    this.objectManager = SceneManager;
    this.layout = null;
    this.resourceContext = null;
  }


  /**
  * Initializes the scene. 
  *
  * @method initialize
   */

  Component_LayoutSceneBehavior.prototype.initialize = function() {
    Component_LayoutSceneBehavior.__super__.initialize.apply(this, arguments);
    this.resourceContext = ResourceManager.createContext();
    ResourceManager.context = this.resourceContext;
    if (this.object.layoutData == null) {
      this.object.layoutData = {
        "type": "ui.FreeLayout",
        "controls": [],
        "frame": [0, 0, 1, 1]
      };
    }
    return LanguageManager.loadBundles();
  };


  /**
  * Disposes the scene. 
  *
  * @method dispose
   */

  Component_LayoutSceneBehavior.prototype.dispose = function() {
    return Component_LayoutSceneBehavior.__super__.dispose.apply(this, arguments);
  };


  /**
  * Prepares all data for the scene and loads the necessary graphic and audio resources.
  *
  * @method prepareData
  * @abstract
   */

  Component_LayoutSceneBehavior.prototype.prepareData = function() {
    gs.ObjectManager.current = this.objectManager;
    if (!GameManager.initialized) {
      GameManager.initialize();
    }
    this.dataFields = ui.UiFactory.dataSources[this.object.layoutData.dataSource || "default"]();
    window.$dataFields = this.dataFields;
    this.music = ui.Component_FormulaHandler.fieldValue(this.object, this.object.layoutData.music);
    AudioManager.loadMusic(this.music);
    this.prepareTransition(RecordManager.system.menuTransition);
    ResourceLoader.loadUiTypesGraphics(ui.UiFactory.customTypes);
    ResourceLoader.loadUiLayoutGraphics(this.object.layoutData);
    if (this.dataFields != null) {
      ResourceLoader.loadUiDataFieldsGraphics(this.dataFields);
    }
    return ResourceManager.getBitmap("Graphics/Characters/JaneDate_Normal");
  };


  /**
  * Prepares all visual game object for the scene.
  *
  * @method prepareVisual
   */

  Component_LayoutSceneBehavior.prototype.prepareVisual = function() {
    var scale, vocab;
    scale = Graphics.scale;
    vocab = RecordManager.vocabulary;
    if (this.layout == null) {
      this.dataObject = {};
      this.layout = ui.UiFactory.createFromDescriptor(this.object.layoutData, this.object);
      if (this.music != null) {
        AudioManager.changeMusic(this.music, 30);
      }
    }
    this.layout.ui.prepare();
    this.layout.ui.appear();
    this.layout.update();
    this.transition();
    if (SceneManager.previousScenes.length === 0) {
      if (GameManager.tempFields.isExitingGame) {
        GameManager.tempFields.isExitingGame = false;
        return gs.GameNotifier.postResetSceneChange(this.object.layoutName);
      } else {
        return gs.GameNotifier.postSceneChange(this.object.layoutName);
      }
    }
  };


  /**
  * Updates the scene's content.
  *
  * @method updateContent
   */

  Component_LayoutSceneBehavior.prototype.updateContent = function() {
    GameManager.update();
    return Graphics.viewport.update();
  };


  /**
  * Shows/Hides the current scene. A hidden scene is no longer shown and executed
  * but all objects and data is still there and be shown again anytime.
  *
  * @method show
  * @param {boolean} visible - Indicates if the scene should be shown or hidden.
   */

  Component_LayoutSceneBehavior.prototype.show = function(visible) {
    if (visible) {
      ResourceManager.context = this.resourceContext;
    }
    this.layout.visible = visible;
    this.layout.update();
    this.objectManager.active = visible;
    if (visible) {
      return gs.ObjectManager.current = SceneManager;
    }
  };


  /**
  * Action method which triggers a full refresh on the object returned by the specified binding-expression.
  * The params must be a direct binding-expression string.
  *
  * @method fullRefreshObject
  * @param {gs.Object_Base} sender - The sender object.
  * @param {string} params -  The binding expression.
   */

  Component_LayoutSceneBehavior.prototype.fullRefreshObject = function(sender, object) {
    object = ui.Component_FormulaHandler.fieldValue(sender, object);
    return object != null ? object.fullRefresh() : void 0;
  };


  /**
  * Action method which triggers a refresh on the object returned by the specified binding-expression.
  * The params must be a direct binding-expression string.
  *
  * @method refreshObject
  * @param {gs.Object_Base} sender - The sender object.
  * @param {string} params -  The binding expression.
   */

  Component_LayoutSceneBehavior.prototype.refreshObject = function(sender, object) {
    object = ui.Component_FormulaHandler.fieldValue(sender, object);
    return object != null ? object.needsUpdate = true : void 0;
  };

  Component_LayoutSceneBehavior.prototype.addStyle = function(sender, style) {
    var styleObject;
    styleObject = ui.UIManager.styles[style];
    if (styleObject != null) {
      styleObject.apply(sender);
    }
    sender.needsUpdate = true;
    if (styleObject != null ? styleObject.font : void 0) {
      return sender.behavior.refresh();
    }
  };

  Component_LayoutSceneBehavior.prototype.removeStyle = function(sender, style) {
    var i, len, ref, ref1, s, styleObject;
    styleObject = ui.UIManager.styles[style];
    if (styleObject != null) {
      styleObject.revert(sender);
    }
    sender.descriptor.styles.remove(style);
    ref = sender.descriptor.styles;
    for (i = 0, len = ref.length; i < len; i++) {
      s = ref[i];
      if ((ref1 = ui.UIManager.styles[s]) != null) {
        ref1.apply(sender);
      }
    }
    sender.needsUpdate = true;
    if (styleObject != null ? styleObject.font : void 0) {
      return sender.behavior.refresh();
    }
  };


  /**
  * Action method which executes the specified bindings.
  *
  * @method executeBindings
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object[]} params -  An array of binding-definitions.
   */

  Component_LayoutSceneBehavior.prototype.executeBindings = function(sender, bindings) {
    var binding, i, len;
    for (i = 0, len = bindings.length; i < len; i++) {
      binding = bindings[i];
      ui.Component_FormulaHandler.executeBinding(sender, binding);
    }
    return null;
  };


  /**
  * Action method which executes the specified formulas.
  *
  * @method executeFormulas
  * @param {gs.Object_Base} sender - The sender object.
  * @param {ui.Formula[]} params -  An array of formula-definitions.
   */

  Component_LayoutSceneBehavior.prototype.executeFormulas = function(sender, formulas) {
    var formula, i, len, results;
    results = [];
    for (i = 0, len = formulas.length; i < len; i++) {
      formula = formulas[i];
      results.push(ui.Component_FormulaHandler.executeFormula(sender, formula));
    }
    return results;
  };


  /**
  * Action method which executes an animation on a specified target game object.
  *
  * @method executeAnimation
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params -  Contains target-id and animations: { target, animations }
   */

  Component_LayoutSceneBehavior.prototype.executeAnimation = function(sender, params) {
    var animation, object;
    object = ui.Component_FormulaHandler.fieldValue(sender, params.target);
    animation = object != null ? object.animations.first(function(a) {
      return a.event === params.event;
    }) : void 0;
    if (animation && object) {
      return object.animationExecutor.execute(animation);
    }
  };


  /**
  * Action method which emits the specified event.
  *
  * @method emitEvent
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Contains event name, source and data.
  * <ul>
  * <li>params.name - The name of the event to emit</li>
  * <li>params.source - A binding-expression to define the game object which should emit the event.</li>
  * <li>params.data - An object containing additional event specific data.</li>
  * </ul>
   */

  Component_LayoutSceneBehavior.prototype.emitEvent = function(sender, params) {
    var object;
    object = ui.Component_FormulaHandler.fieldValue(sender, params.source);
    return object != null ? object.events.emit(params.name, object, ui.Component_FormulaHandler.fieldValue(sender, params.data)) : void 0;
  };


  /**
  * Action method which changes the game's aspect ratio.
  *
  * @method executeBindings
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean} params -  If <b>true</b> the game screen will stretched so that it fills the entire screen
  * of the player without any black borders. Otherwise the game screen stretches but keeps its ratio
  * so black borders are possible if the game resolution's ratio and the target display's ratio are not match. It can also
  * be a binding-expression.
   */

  Component_LayoutSceneBehavior.prototype.adjustAspectRatio = function(sender, adjust) {
    adjust = ui.Component_FormulaHandler.fieldValue(sender, adjust);
    GameManager.settings.adjustAspectRatio = adjust;
    Graphics.keepRatio = !adjust;
    return Graphics.onResize();
  };


  /**
  * Action method which enters fullscreen mode.
  *
  * @method enterFullScreen
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean} params - Can be <b>null</b>
   */

  Component_LayoutSceneBehavior.prototype.enterFullScreen = function(sender, params) {
    gs.Graphics.enterFullscreen();
    return GameManager.settings.fullScreen = Graphics.isFullscreen();
  };


  /**
  * Action method which leaves fullscreen mode.
  *
  * @method leaveFullScreen
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean} params - Can be <b>null</b>
   */

  Component_LayoutSceneBehavior.prototype.leaveFullScreen = function() {
    gs.Graphics.leaveFullscreen();
    return GameManager.settings.fullScreen = Graphics.isFullscreen();
  };


  /**
  * Action method which toggles between window and fullscreen mode.
  *
  * @method toggleFullScreen
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - Can be <b>null</b>
   */

  Component_LayoutSceneBehavior.prototype.toggleFullScreen = function(sender, params) {
    if (gs.Graphics.isFullscreen()) {
      gs.Graphics.leaveFullscreen();
    } else {
      gs.Graphics.enterFullscreen();
    }
    return GameManager.settings.fullScreen = gs.Graphics.isFullscreen();
  };


  /**
  * Action method which plays the specified sound.
  *
  * @method playSound
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - The sound to play.
   */

  Component_LayoutSceneBehavior.prototype.playSound = function(sender, params) {
    AudioManager.loadSound(params);
    return AudioManager.playSound(params);
  };


  /**
  * Action method which plays the specified voice.
  *
  * @method playVoice
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - The voice to play.
   */

  Component_LayoutSceneBehavior.prototype.playVoice = function(sender, params) {
    AudioManager.loadSound(params);
    return AudioManager.playVoice(params);
  };


  /**
  * Action method which turns voice on or off.
  *
  * @method turnOnOffVoice
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - If <b>true</b> voice will be turned on. Otherwise it will be turned off. Can also be a binding-expression.
   */

  Component_LayoutSceneBehavior.prototype.turnOnOffVoice = function(sender, state) {
    if (ui.Component_FormulaHandler.fieldValue(sender, state)) {
      return this.turnOnVoice();
    } else {
      return this.turnOffVoice();
    }
  };


  /**
  * Action method which turns music on or off.
  *
  * @method turnOnOffMusic
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - If <b>true</b> music will be turned on. Otherwise it will be turned off. Can also be a binding-expression.
   */

  Component_LayoutSceneBehavior.prototype.turnOnOffMusic = function(sender, state) {
    if (ui.Component_FormulaHandler.fieldValue(sender, state)) {
      return this.turnOnMusic();
    } else {
      return this.turnOffMusic();
    }
  };


  /**
  * Action method which turns sound on or off.
  *
  * @method turnOnOffSound
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - If <b>true</b> sound will be turned on. Otherwise it will be turned off. Can also be a binding-expression.
   */

  Component_LayoutSceneBehavior.prototype.turnOnOffSound = function(sender, state) {
    if (ui.Component_FormulaHandler.fieldValue(sender, state)) {
      return this.turnOnSound();
    } else {
      return this.turnOffSound();
    }
  };


  /**
  * Action method which turns off voice.
  *
  * @method turnOffVoice
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.turnOffVoice = function() {
    return AudioManager.stopAllVoices();
  };


  /**
  * Action method which turns off music.
  *
  * @method turnOffMusic
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.turnOffMusic = function() {
    return AudioManager.stopMusic();
  };


  /**
  * Action method which turns off sound.
  *
  * @method turnOffSound
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.turnOffSound = function() {
    return AudioManager.stopAllSounds();
  };


  /**
  * Action method which turns on voice.
  *
  * @method turnOnVoice
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.turnOnVoice = function() {};


  /**
  * Action method which turns on sound.
  *
  * @method turnOnSound
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.turnOnSound = function() {};


  /**
  * Action method which turns on music.
  *
  * @method turnOnMusic
  * @param {gs.Object_Base} sender - The sender object.
  * @param {boolean|string} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.turnOnMusic = function() {
    return AudioManager.resumeMusic();
  };


  /**
  * Action method which selects the specified language.
  *
  * @method selectLanguage
  * @param {gs.Object_Base} sender - The sender object.
  * @param {number|string} params - Index of the language to set. Can be a binding-expression.
   */

  Component_LayoutSceneBehavior.prototype.selectLanguage = function(sender, params) {
    var language;
    language = LanguageManager.languages[ui.Component_FormulaHandler.fieldValue(sender, params)];
    return LanguageManager.selectLanguage(language);
  };


  /**
  * Action method which resets global data storage.
  *
  * @method resetGlobalData
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.resetGlobalData = function(sender) {
    return GameManager.resetGlobalData();
  };


  /**
  * Action method which saves game settings.
  *
  * @method saveSettings
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.saveSettings = function(sender) {
    return GameManager.saveSettings();
  };


  /**
  * Action method which prepares the game for saving by taking a snapshot of the current game state
  * and storing it in GameManager.saveGame.
  *
  * @method prepareSaveGame
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.prepareSaveGame = function(sender, params) {
    return GameManager.prepareSaveGame(params != null ? params.snapshot : void 0);
  };


  /**
  * Action method which saves the current game at the specified save slot.
  *
  * @method saveGame
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Contains the slot-index where the game should be saved.
  * <ul>
  * <li>params.slot - The slot-index where the game should be saved. Can be a binding-expression.</li>
  * </ul>
   */

  Component_LayoutSceneBehavior.prototype.saveGame = function(sender, params) {
    return GameManager.save(ui.Component_FormulaHandler.fieldValue(sender, params.slot));
  };


  /**
  * Action method which loads the game from the specified save slot.
  *
  * @method loadGame
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Contains the slot-index where the game should be loaded from.
  * <ul>
  * <li>params.slot - The slot-index where the game should be loaded from. Can be a binding-expression.</li>
  * </ul>
   */

  Component_LayoutSceneBehavior.prototype.loadGame = function(sender, params) {
    GameManager.tempSettings.skip = false;
    return GameManager.load(ui.Component_FormulaHandler.fieldValue(sender, params.slot));
  };


  /**
  * Action method which starts a new game.
  *
  * @method newGame
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Can be <b>null</b>
   */

  Component_LayoutSceneBehavior.prototype.newGame = function(sender, params) {
    var scene;
    AudioManager.stopAllMusic(30);
    GameManager.newGame();
    scene = new vn.Object_Scene();
    SceneManager.clear();
    return SceneManager.switchTo(scene);
  };


  /**
  * Action method which exists the current game. It doesn't change the scene and
  * should be called before switching back to the title screen or main menu.
  *
  * @method exitGame
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Can be <b>null</b>
   */

  Component_LayoutSceneBehavior.prototype.exitGame = function(sender, params) {
    return GameManager.exitGame();
  };


  /**
  * Action method which switches to another scene.
  *
  * @method switchScene
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Contains the class name of the scene to switch to.
  * <ul>
  * <li>params.name - The class-name of the scene to switch to. The class must be defined in vn-namespace.</li>
  * </ul>
   */

  Component_LayoutSceneBehavior.prototype.switchScene = function(sender, params) {
    var f;
    f = (function(_this) {
      return function() {
        var scene;
        if (params.clear) {
          SceneManager.clear();
        }
        scene = new vn[params.name]();
        return SceneManager.switchTo(scene, params.savePrevious);
      };
    })(this);
    if (!params.savePrevious) {
      return this.layout.ui.disappear((function(_this) {
        return function(e) {
          return f();
        };
      })(this));
    } else {
      return f();
    }
  };


  /**
  * Action method which switches to another game scene.
  *
  * @method switchGameScene
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Contains the UID of the scene to switch to.
  * <ul>
  * <li>params.uid - The UID of the scene to switch to.</li>
  * </ul>
   */

  Component_LayoutSceneBehavior.prototype.switchGameScene = function(sender, params) {
    var f;
    f = (function(_this) {
      return function() {
        var newScene, sceneData, sceneDocument, sceneDocuments, uid;
        if (params.clear) {
          SceneManager.clear();
        }
        uid = params.uid;
        if (params.name) {
          sceneDocuments = DataManager.getDocumentsByType("vn.scene");
          sceneDocument = sceneDocuments.first(function(d) {
            return d.items.name === params.name;
          });
          if (sceneDocument) {
            uid = sceneDocument.uid;
          }
        }
        sceneData = {
          uid: uid,
          pictures: [],
          texts: []
        };
        GameManager.sceneData = sceneData;
        newScene = new vn.Object_Scene();
        newScene.sceneData = sceneData;
        return SceneManager.switchTo(newScene, params.savePrevious);
      };
    })(this);
    if (!params.savePrevious) {
      return (this.layout || this.object.layout).ui.disappear((function(_this) {
        return function(e) {
          return f();
        };
      })(this));
    } else {
      return f();
    }
  };


  /**
  * Action method which switches to another layout.
  *
  * @method switchLayout
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Contains the name of the layout to switch to.
  * <ul>
  * <li>params.name - The name of the layout to switch to.</li>
  * <li>params.savePrevious - Indicates if the current layout should not be erased but paused and hidden instead so
  * that it can be restored using <i>returnToPrevious</i> action.</li>
  * <li>params.dataFields - Defines the data of "$dataFields" binding-expression variable. Can be a binding-expression
  * or a direct object. Optional.</li>
  * </ul>
   */

  Component_LayoutSceneBehavior.prototype.switchLayout = function(sender, layout) {
    var f;
    f = (function(_this) {
      return function() {
        var dataFields, i, len, ref, scene, senderField;
        Graphics.freeze();
        if (layout.clear) {
          SceneManager.clear();
        }
        scene = new gs.Object_Layout(layout.name);
        dataFields = sender.dataFields;
        if (typeof layout.dataFields === "string") {
          dataFields = ui.Component_FormulaHandler.fieldValue(sender, layout.dataFields);
        } else if (layout.dataFields != null) {
          dataFields = layout.dataFields;
        }
        scene.dataFields = dataFields;
        scene.controllers = layout.controllers;
        if (layout.senderData != null) {
          ref = layout.senderData;
          for (i = 0, len = ref.length; i < len; i++) {
            senderField = ref[i];
            scene[senderField] = sender[senderField];
          }
        }
        return SceneManager.switchTo(scene, layout.savePrevious, layout.stack);
      };
    })(this);
    if (!layout.savePrevious) {
      return (this.layout || this.object.layout).ui.disappear((function(_this) {
        return function(e) {
          return f();
        };
      })(this));
    } else {
      return f();
    }
  };


  /**
  * Action method which returns to previous layout. (If savePrevious was set to <b>true</b> on switchLayout.).
  *
  * @method previousLayout
  * @param {gs.Object_Base} sender - The sender object.
  * @param {Object} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.previousLayout = function(sender) {
    return SceneManager.returnToPrevious();
  };


  /**
  * Action method which disposes the specified control.
  *
  * @method disposeControl
  * @param {gs.Object_Base} sender - The sender object.
  * @param {string} params - The ID of the control to dispose. Can be a binding-expression.
   */

  Component_LayoutSceneBehavior.prototype.disposeControl = function(sender, id) {
    var control;
    control = this.objectManager.objectById(ui.Component_FormulaHandler.fieldValue(sender, id));
    return control != null ? control.ui.disappear(function(sender) {
      return sender.dispose();
    }) : void 0;
  };


  /**
  * Action method which creates a new control from the specified descriptor.
  *
  * @method createControl
  * @param {gs.Object_Base} sender - The sender object.
  * @param {string} params - Contains the descriptor and other data needed to construct the control.
  * <ul>
  * <li>params.descriptor - The control' descriptor. Can be a direct descriptor definition or a template name</li>
  * <li>params.parent - A binding-expression which returns the control's parent.</li>
  * <li>params.senderData - An object containing additional data merged into the control object.</li>
  * </ul>
   */

  Component_LayoutSceneBehavior.prototype.createControl = function(sender, data) {
    var control, descriptor, fieldName, i, len, parent, ref;
    if (typeof data.descriptor === "string") {
      descriptor = ui.UIManager.customTypes[data.descriptor];
    } else {
      descriptor = data.descriptor;
    }
    parent = ui.Component_FormulaHandler.fieldValue(sender, data.parent);
    control = ui.UiFactory._createFromDescriptor(descriptor, parent != null ? parent : this.object.layout || this.object);
    if (data.senderData != null) {
      ref = data.senderData;
      for (i = 0, len = ref.length; i < len; i++) {
        fieldName = ref[i];
        control[fieldName] = sender[fieldName];
      }
    }
    control.ui.prepare();
    control.ui.appear();
    return control;
  };


  /**
  * Action method which quits the game.
  *
  * @method quitGame
  * @param {gs.Object_Base} sender - The sender object.
  * @param {string} params - Can be <b>null</b>.
   */

  Component_LayoutSceneBehavior.prototype.quitGame = function(sender, data) {
    return SceneManager.switchTo(null);
  };

  return Component_LayoutSceneBehavior;

})(gs.Component_SceneBehavior);

gs.Component_LayoutSceneBehavior = Component_LayoutSceneBehavior;

//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"","sourceRoot":"","sources":[""],"names":[],"mappings":"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","sourcesContent":["# ===================================================================\n#\n#   Script: Component_LayoutSceneBehavior　\n#\n#   $$COPYRIGHT$$\n#\n# ===================================================================\nclass Component_LayoutSceneBehavior extends gs.Component_SceneBehavior\n  #  @objectCodecBlackList = [\"objectManager\"]\n    ###*\n    * The base class of all scene-behavior components. A scene-behavior component\n    * define the logic of a single game scene. \n    *\n    * @module gs\n    * @class Component_LayoutSceneBehavior\n    * @extends gs.Component_SceneBehavior\n    * @memberof gs\n    ###\n    constructor: ->\n        super()\n        \n        @objectManager = SceneManager\n        @layout = null\n        @resourceContext = null\n    \n    ###*\n    * Initializes the scene. \n    *\n    * @method initialize\n    ###    \n    initialize: ->\n        super\n        \n        @resourceContext = ResourceManager.createContext()\n        ResourceManager.context = @resourceContext\n        \n        if not @object.layoutData?\n            @object.layoutData = { \"type\": \"ui.FreeLayout\", \"controls\": [], \"frame\": [0, 0, 1, 1] }\n            \n        LanguageManager.loadBundles()\n        \n    ###*\n    * Disposes the scene. \n    *\n    * @method dispose\n    ###\n    dispose: ->\n        super\n     \n    ###*\n    * Prepares all data for the scene and loads the necessary graphic and audio resources.\n    *\n    * @method prepareData\n    * @abstract\n    ###    \n    prepareData: ->\n        gs.ObjectManager.current = @objectManager\n        \n        if not GameManager.initialized\n            GameManager.initialize()\n            \n        @dataFields = ui.UiFactory.dataSources[@object.layoutData.dataSource || \"default\"]()\n        window.$dataFields = @dataFields\n        @music = ui.Component_FormulaHandler.fieldValue(@object, @object.layoutData.music)\n        AudioManager.loadMusic(@music)\n        @prepareTransition(RecordManager.system.menuTransition)\n        \n        ResourceLoader.loadUiTypesGraphics(ui.UiFactory.customTypes)\n        ResourceLoader.loadUiLayoutGraphics(@object.layoutData)\n        \n        if @dataFields?\n            ResourceLoader.loadUiDataFieldsGraphics(@dataFields)\n        ResourceManager.getBitmap(\"Graphics/Characters/JaneDate_Normal\")\n     \n    ###*\n    * Prepares all visual game object for the scene.\n    *\n    * @method prepareVisual\n    ###         \n    prepareVisual: ->\n        scale = Graphics.scale\n        vocab = RecordManager.vocabulary\n\n        if not @layout?\n            @dataObject = {}\n            @layout = ui.UiFactory.createFromDescriptor(@object.layoutData, @object)\n    \n            if @music?\n                AudioManager.changeMusic(@music, 30)\n\n                        \n        @layout.ui.prepare()\n        @layout.ui.appear()\n        @layout.update()\n        \n        @transition()\n        \n        if SceneManager.previousScenes.length == 0\n            if GameManager.tempFields.isExitingGame\n                GameManager.tempFields.isExitingGame = no\n                gs.GameNotifier.postResetSceneChange(@object.layoutName)\n            else\n                gs.GameNotifier.postSceneChange(@object.layoutName)\n     \n    ###*\n    * Updates the scene's content.\n    *\n    * @method updateContent\n    ###    \n    updateContent: ->\n        GameManager.update()\n        Graphics.viewport.update()\n     \n    ###*\n    * Shows/Hides the current scene. A hidden scene is no longer shown and executed\n    * but all objects and data is still there and be shown again anytime.\n    *\n    * @method show\n    * @param {boolean} visible - Indicates if the scene should be shown or hidden.\n    ###          \n    show: (visible) ->\n        if visible\n            ResourceManager.context = @resourceContext\n        @layout.visible = visible\n        @layout.update()\n        @objectManager.active = visible\n        if visible\n            gs.ObjectManager.current = SceneManager #@objectManager\n        #@objectManager.update()\n     \n    ###*\n    * Action method which triggers a full refresh on the object returned by the specified binding-expression.\n    * The params must be a direct binding-expression string.\n    *\n    * @method fullRefreshObject\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {string} params -  The binding expression.\n    ###    \n    fullRefreshObject: (sender, object) ->\n        object = ui.Component_FormulaHandler.fieldValue(sender, object)\n        object?.fullRefresh()\n      \n    ###*\n    * Action method which triggers a refresh on the object returned by the specified binding-expression.\n    * The params must be a direct binding-expression string.\n    *\n    * @method refreshObject\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {string} params -  The binding expression.\n    ###    \n    refreshObject: (sender, object) ->\n        object = ui.Component_FormulaHandler.fieldValue(sender, object)\n        object?.needsUpdate = true\n        \n    addStyle: (sender, style) ->\n        styleObject = ui.UIManager.styles[style]\n        styleObject?.apply(sender)\n        sender.needsUpdate = yes\n        if styleObject?.font\n            sender.behavior.refresh()\n        \n    removeStyle: (sender, style) -> \n        styleObject = ui.UIManager.styles[style]\n        styleObject?.revert(sender)\n        sender.descriptor.styles.remove(style)\n        \n        for s in sender.descriptor.styles\n            ui.UIManager.styles[s]?.apply(sender)\n        sender.needsUpdate = yes\n        if styleObject?.font\n            sender.behavior.refresh()\n            \n    \n    \n    ###*\n    * Action method which executes the specified bindings.\n    *\n    * @method executeBindings\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object[]} params -  An array of binding-definitions.\n    ### \n    executeBindings: (sender, bindings) ->\n        for binding in bindings\n            ui.Component_FormulaHandler.executeBinding(sender, binding)\n            \n        return null\n    \n    ###*\n    * Action method which executes the specified formulas.\n    *\n    * @method executeFormulas\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {ui.Formula[]} params -  An array of formula-definitions.\n    ###  \n    executeFormulas: (sender, formulas) ->\n        for formula in formulas\n            ui.Component_FormulaHandler.executeFormula(sender, formula)\n    \n    ###*\n    * Action method which executes an animation on a specified target game object.\n    *\n    * @method executeAnimation\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params -  Contains target-id and animations: { target, animations }\n    ###         \n    executeAnimation: (sender, params) ->\n        object = ui.Component_FormulaHandler.fieldValue(sender, params.target)\n        animation = object?.animations.first (a) -> a.event == params.event\n        \n        if animation and object\n            object.animationExecutor.execute(animation)\n            \n    ###*\n    * Action method which emits the specified event.\n    *\n    * @method emitEvent\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Contains event name, source and data.\n    * <ul>\n    * <li>params.name - The name of the event to emit</li>\n    * <li>params.source - A binding-expression to define the game object which should emit the event.</li>\n    * <li>params.data - An object containing additional event specific data.</li>\n    * </ul>\n    ###    \n    emitEvent: (sender, params) ->\n        object = ui.Component_FormulaHandler.fieldValue(sender, params.source)\n        object?.events.emit(params.name, object, ui.Component_FormulaHandler.fieldValue(sender, params.data))\n    \n    ###*\n    * Action method which changes the game's aspect ratio.\n    *\n    * @method executeBindings\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean} params -  If <b>true</b> the game screen will stretched so that it fills the entire screen\n    * of the player without any black borders. Otherwise the game screen stretches but keeps its ratio\n    * so black borders are possible if the game resolution's ratio and the target display's ratio are not match. It can also\n    * be a binding-expression.\n    ###\n    adjustAspectRatio: (sender, adjust) ->\n        adjust = ui.Component_FormulaHandler.fieldValue(sender, adjust)\n    \n        GameManager.settings.adjustAspectRatio = adjust\n        Graphics.keepRatio = !adjust\n        Graphics.onResize()\n        \n    ###*\n    * Action method which enters fullscreen mode.\n    *\n    * @method enterFullScreen\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean} params - Can be <b>null</b>\n    ###\n    enterFullScreen: (sender, params) -> \n        gs.Graphics.enterFullscreen()\n        GameManager.settings.fullScreen = Graphics.isFullscreen()\n        \n            \n    ###*\n    * Action method which leaves fullscreen mode.\n    *\n    * @method leaveFullScreen\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean} params - Can be <b>null</b>\n    ###\n    leaveFullScreen: -> \n        gs.Graphics.leaveFullscreen()\n        GameManager.settings.fullScreen = Graphics.isFullscreen()\n        \n    ###*\n    * Action method which toggles between window and fullscreen mode.\n    *\n    * @method toggleFullScreen\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - Can be <b>null</b>\n    ###\n    toggleFullScreen: (sender, params) ->\n        if gs.Graphics.isFullscreen()\n            gs.Graphics.leaveFullscreen()\n        else\n            gs.Graphics.enterFullscreen()\n\n        GameManager.settings.fullScreen = gs.Graphics.isFullscreen()\n      \n    ###*\n    * Action method which plays the specified sound.\n    *\n    * @method playSound\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - The sound to play.\n    ###\n    playSound: (sender, params) ->\n        AudioManager.loadSound(params)\n        AudioManager.playSound(params)\n        \n    ###*\n    * Action method which plays the specified voice.\n    *\n    * @method playVoice\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - The voice to play.\n    ###\n    playVoice: (sender, params) ->\n        AudioManager.loadSound(params)\n        AudioManager.playVoice(params)\n      \n     \n    ###*\n    * Action method which turns voice on or off.\n    *\n    * @method turnOnOffVoice\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - If <b>true</b> voice will be turned on. Otherwise it will be turned off. Can also be a binding-expression.\n    ### \n    turnOnOffVoice: (sender, state) ->\n        if ui.Component_FormulaHandler.fieldValue(sender, state) then @turnOnVoice() else @turnOffVoice()\n        \n    ###*\n    * Action method which turns music on or off.\n    *\n    * @method turnOnOffMusic\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - If <b>true</b> music will be turned on. Otherwise it will be turned off. Can also be a binding-expression.\n    ### \n    turnOnOffMusic: (sender, state) ->\n        if ui.Component_FormulaHandler.fieldValue(sender, state) then @turnOnMusic() else @turnOffMusic()\n        \n    ###*\n    * Action method which turns sound on or off.\n    *\n    * @method turnOnOffSound\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - If <b>true</b> sound will be turned on. Otherwise it will be turned off. Can also be a binding-expression.\n    ### \n    turnOnOffSound: (sender, state) ->\n        if ui.Component_FormulaHandler.fieldValue(sender, state) then @turnOnSound() else @turnOffSound()\n        \n    ###*\n    * Action method which turns off voice.\n    *\n    * @method turnOffVoice\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - Can be <b>null</b>.\n    ### \n    turnOffVoice: ->\n        AudioManager.stopAllVoices()\n        \n    ###*\n    * Action method which turns off music.\n    *\n    * @method turnOffMusic\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - Can be <b>null</b>.\n    ### \n    turnOffMusic: ->\n        AudioManager.stopMusic()\n        \n    ###*\n    * Action method which turns off sound.\n    *\n    * @method turnOffSound\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - Can be <b>null</b>.\n    ### \n    turnOffSound: ->\n        AudioManager.stopAllSounds()\n        \n    ###*\n    * Action method which turns on voice.\n    *\n    * @method turnOnVoice\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - Can be <b>null</b>.\n    ### \n    turnOnVoice: ->\n        \n    ###*\n    * Action method which turns on sound.\n    *\n    * @method turnOnSound\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - Can be <b>null</b>.\n    ### \n    turnOnSound: ->\n        \n    ###*\n    * Action method which turns on music.\n    *\n    * @method turnOnMusic\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {boolean|string} params - Can be <b>null</b>.\n    ### \n    turnOnMusic: ->\n        AudioManager.resumeMusic()\n        \n    ###*\n    * Action method which selects the specified language.\n    *\n    * @method selectLanguage\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {number|string} params - Index of the language to set. Can be a binding-expression.\n    ### \n    selectLanguage: (sender, params)->\n        language = LanguageManager.languages[ui.Component_FormulaHandler.fieldValue(sender, params)]\n        LanguageManager.selectLanguage(language)\n       \n    ###*\n    * Action method which resets global data storage.\n    *\n    * @method resetGlobalData\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Can be <b>null</b>.\n    ### \n    resetGlobalData: (sender) -> \n        GameManager.resetGlobalData()\n    \n    ###*\n    * Action method which saves game settings.\n    *\n    * @method saveSettings\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Can be <b>null</b>.\n    ### \n    saveSettings: (sender) -> GameManager.saveSettings()\n    \n    ###*\n    * Action method which prepares the game for saving by taking a snapshot of the current game state\n    * and storing it in GameManager.saveGame.\n    *\n    * @method prepareSaveGame\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Can be <b>null</b>.\n    ### \n    prepareSaveGame: (sender, params) ->\n        GameManager.prepareSaveGame(params?.snapshot)\n        \n    ###*\n    * Action method which saves the current game at the specified save slot.\n    *\n    * @method saveGame\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Contains the slot-index where the game should be saved.\n    * <ul>\n    * <li>params.slot - The slot-index where the game should be saved. Can be a binding-expression.</li>\n    * </ul>\n    ### \n    saveGame: (sender, params) -> GameManager.save(ui.Component_FormulaHandler.fieldValue(sender, params.slot))\n    \n    ###*\n    * Action method which loads the game from the specified save slot.\n    *\n    * @method loadGame\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Contains the slot-index where the game should be loaded from.\n    * <ul>\n    * <li>params.slot - The slot-index where the game should be loaded from. Can be a binding-expression.</li>\n    * </ul>\n    ### \n    loadGame: (sender, params) ->\n        GameManager.tempSettings.skip = no\n        GameManager.load(ui.Component_FormulaHandler.fieldValue(sender, params.slot))\n     \n    ###*\n    * Action method which starts a new game.\n    *\n    * @method newGame\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Can be <b>null</b>\n    ### \n    newGame: (sender, params) ->\n        AudioManager.stopAllMusic(30)\n        GameManager.newGame()\n        \n        scene = new vn.Object_Scene()\n        SceneManager.clear()\n        SceneManager.switchTo(scene)\n    \n    ###*\n    * Action method which exists the current game. It doesn't change the scene and\n    * should be called before switching back to the title screen or main menu.\n    *\n    * @method exitGame\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Can be <b>null</b>\n    ### \n    exitGame: (sender, params) ->\n        GameManager.exitGame()\n        \n    ###*\n    * Action method which switches to another scene.\n    *\n    * @method switchScene\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Contains the class name of the scene to switch to.\n    * <ul>\n    * <li>params.name - The class-name of the scene to switch to. The class must be defined in vn-namespace.</li>\n    * </ul>\n    ###     \n    switchScene: (sender, params) ->\n        f = =>\n            if params.clear\n                SceneManager.clear()\n                \n            scene = new vn[params.name]()\n            SceneManager.switchTo(scene, params.savePrevious)\n            \n        if !params.savePrevious\n            @layout.ui.disappear (e) => f()\n        else\n            f()\n        \n    ###*\n    * Action method which switches to another game scene.\n    *\n    * @method switchGameScene\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Contains the UID of the scene to switch to.\n    * <ul>\n    * <li>params.uid - The UID of the scene to switch to.</li>\n    * </ul>\n    ###    \n    switchGameScene: (sender, params) ->\n        f = =>\n            if params.clear\n                SceneManager.clear()\n                \n            uid = params.uid\n            if params.name\n                sceneDocuments = DataManager.getDocumentsByType(\"vn.scene\")\n                sceneDocument = sceneDocuments.first (d) -> d.items.name == params.name\n                if sceneDocument\n                    uid = sceneDocument.uid\n            \n            sceneData = uid: uid, pictures: [], texts: []\n            GameManager.sceneData = sceneData\n            newScene = new vn.Object_Scene()\n            newScene.sceneData = sceneData\n            \n            SceneManager.switchTo(newScene, params.savePrevious)\n            \n        if !params.savePrevious\n            (@layout||@object.layout).ui.disappear (e) => f()\n        else\n            f()\n    \n    ###*\n    * Action method which switches to another layout.\n    *\n    * @method switchLayout\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Contains the name of the layout to switch to.\n    * <ul>\n    * <li>params.name - The name of the layout to switch to.</li>\n    * <li>params.savePrevious - Indicates if the current layout should not be erased but paused and hidden instead so\n    * that it can be restored using <i>returnToPrevious</i> action.</li>\n    * <li>params.dataFields - Defines the data of \"$dataFields\" binding-expression variable. Can be a binding-expression\n    * or a direct object. Optional.</li>\n    * </ul>\n    ###    \n    switchLayout: (sender, layout) ->\n        f = =>\n            Graphics.freeze()\n            if layout.clear\n                SceneManager.clear()\n                \n            scene = new gs.Object_Layout(layout.name)\n          \n            dataFields = sender.dataFields\n            if typeof layout.dataFields == \"string\"\n                dataFields = ui.Component_FormulaHandler.fieldValue(sender, layout.dataFields)\n            else if layout.dataFields?\n                dataFields = layout.dataFields\n                \n            scene.dataFields = dataFields\n            scene.controllers = layout.controllers\n            \n            if layout.senderData?\n                for senderField in layout.senderData\n                    scene[senderField] = sender[senderField]\n            SceneManager.switchTo(scene, layout.savePrevious, layout.stack)\n        \n        if !layout.savePrevious\n            (@layout||@object.layout).ui.disappear (e) => f()\n        else\n            f()\n     \n    ###*\n    * Action method which returns to previous layout. (If savePrevious was set to <b>true</b> on switchLayout.).\n    *\n    * @method previousLayout\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {Object} params - Can be <b>null</b>.\n    ###     \n    previousLayout: (sender) ->\n        SceneManager.returnToPrevious()\n      \n    ###*\n    * Action method which disposes the specified control.\n    *\n    * @method disposeControl\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {string} params - The ID of the control to dispose. Can be a binding-expression.\n    ###    \n    disposeControl: (sender, id) ->\n        control = @objectManager.objectById(ui.Component_FormulaHandler.fieldValue(sender, id))\n        \n        \n        control?.ui.disappear (sender) -> sender.dispose()\n    \n    ###*\n    * Action method which creates a new control from the specified descriptor.\n    *\n    * @method createControl\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {string} params - Contains the descriptor and other data needed to construct the control.\n    * <ul>\n    * <li>params.descriptor - The control' descriptor. Can be a direct descriptor definition or a template name</li>\n    * <li>params.parent - A binding-expression which returns the control's parent.</li>\n    * <li>params.senderData - An object containing additional data merged into the control object.</li>\n    * </ul>\n    ###  \n    createControl: (sender, data) ->\n        if typeof data.descriptor == \"string\"\n            descriptor = ui.UIManager.customTypes[data.descriptor]\n        else\n            descriptor = data.descriptor\n        \n        parent = ui.Component_FormulaHandler.fieldValue(sender, data.parent)\n        control = ui.UiFactory._createFromDescriptor(descriptor, parent ? (@object.layout||@object) )\n        \n        if data.senderData?\n            for fieldName in data.senderData\n                control[fieldName] = sender[fieldName]\n        control.ui.prepare()\n        control.ui.appear()\n        \n        return control\n        \n    ###*\n    * Action method which quits the game.\n    *\n    * @method quitGame\n    * @param {gs.Object_Base} sender - The sender object.\n    * @param {string} params - Can be <b>null</b>.\n    ### \n    quitGame: (sender, data) ->\n        SceneManager.switchTo(null)\n            \n        \n        \ngs.Component_LayoutSceneBehavior = Component_LayoutSceneBehavior"]}
//# sourceURL=Component_LayoutSceneBehavior_22.js