@qooxdoo/framework 7.0.0-beta.1 → 7.0.0-beta.10

package/source/class/qx/util/fsm/FiniteStateMachine.js

@@ -23,18 +23,15 @@
  * and {@link qx.util.fsm.Transition} for details on creating
  * transitions between states.
  */
-qx.Class.define("qx.util.fsm.FiniteStateMachine",
-{
-  extend : qx.core.Object,
-
+qx.Class.define("qx.util.fsm.FiniteStateMachine", {
+  extend: qx.core.Object,
 
   /**
    * @param machineName {String} The name of this finite state machine
    */
-  construct : function(machineName)
-  {
+  construct(machineName) {
     // Call our superclass' constructor
-    this.base(arguments);
+    super();
 
     // Save the machine name
     this.setName(machineName);
@@ -79,124 +76,105 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
     this.__friendlyToGroups = {};
   },
 
-
-  statics :
-  {
+  statics: {
     /**
      * Constants which may be values of the nextState member in the
      * transitionInfo parameter of the Transition constructor.
      */
-    StateChange :
-    {
-
+    StateChange: {
       /** When used as a nextState value, means remain in current state */
-      CURRENT_STATE   : 1,
+      CURRENT_STATE: 1,
 
       /**
        * When used as a nextState value, means go to most-recently pushed state
        */
-      POP_STATE_STACK : 2,
+      POP_STATE_STACK: 2,
 
       /** When used as a nextState value, means terminate this state machine */
-      TERMINATE       : 3
+      TERMINATE: 3
     },
 
-
     /**
      * Constants for use in the events member of the transitionInfo parameter
      * of the Transition constructor.
      */
-    EventHandling :
-    {
+    EventHandling: {
       /**
        * This event is handled by this state, but the predicate of a transition
        * will determine whether to use that transition.
        */
-      PREDICATE : 1,
+      PREDICATE: 1,
 
       /** Enqueue this event for possible use by the next state */
-      BLOCKED   : 2
+      BLOCKED: 2
     },
 
-
     /**
      * Debug bitmask values.
      */
-    DebugFlags :
-    {
-
+    DebugFlags: {
       /** Show events */
-      EVENTS           : 1,
+      EVENTS: 1,
 
       /** Show transitions */
-      TRANSITIONS      : 2,
+      TRANSITIONS: 2,
 
       /** Show individual function invocations during transitions */
-      FUNCTION_DETAIL  : 4,
+      FUNCTION_DETAIL: 4,
 
       /**
        * When object friendly names are referenced but not found, show message
        */
-      OBJECT_NOT_FOUND : 8
+      OBJECT_NOT_FOUND: 8
     }
   },
 
-  events :
-  {
+  events: {
     /**
      * Fired when the finite state machine terminates. Data is the last state
      * before termination.
      */
-    "terminated" : "qx.event.type.Data"
+    terminated: "qx.event.type.Data"
   },
 
-  properties :
-  {
+  properties: {
     /**
      * The name of this finite state machine (for debug messages)
      */
-    name :
-    {
-      check : "String",
-      nullable : true
+    name: {
+      check: "String",
+      nullable: true
     },
 
-
     /**
      * The current state of the finite state machine.
      */
-    state :
-    {
-      check : "String",
-      nullable : true
+    state: {
+      check: "String",
+      nullable: true
     },
 
-
     /**
      * The previous state of the finite state machine, i.e. the state from
      * which we most recently transitioned.  Note that this could be the same
      * as the current state if a successful transition brought us back to the
      * same state.
      */
-    previousState :
-    {
-      check : "String",
-      nullable : true
+    previousState: {
+      check: "String",
+      nullable: true
     },
 
-
     /**
      * The state to which we will be transitioning.  This property is valid
      * only during a Transition's ontransition function and a State's onexit
      * function.  At all other times, it is null.
      */
-    nextState :
-    {
-      check : "String",
-      nullable : true
+    nextState: {
+      check: "String",
+      nullable: true
     },
 
-
     /**
      * The maximum number of states which may pushed onto the state-stack.  It
      * is generally a poor idea to have very many states saved on a stack.
@@ -204,13 +182,11 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      * highly unmaintainable.  The default should be more than adequate.
      * You've been warned.
      */
-    maxSavedStates :
-    {
-      check : "Number",
-      init : 2
+    maxSavedStates: {
+      check: "Number",
+      init: 2
     },
 
-
     /**
      * Debug flags, composed of the bitmask values in the DebugFlags constant.
      *
@@ -225,41 +201,37 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *                   FSM.DebugFlags.OBJECT_NOT_FOUND);
      * </pre>
      */
-    debugFlags :
-    {
-      check : "Number",
+    debugFlags: {
+      check: "Number",
 
       // Default:
       // (qx.util.fsm.FiniteStateMachine.DebugFlags.EVENTS |
       //  qx.util.fsm.FiniteStateMachine.DebugFlags.TRANSITIONS |
       //  qx.util.fsm.FiniteStateMachine.DebugFlags.OBJECT_NOT_FOUND)
-      init  : 7
+      init: 7
     }
   },
 
-
-  members :
-  {
-    __states                     : null,
-    __startState                 : null,
-    __eventQueue                 : null,
-    __blockedEvents              : null,
-    __savedStates                : null,
-    __friendlyToObject           : null,
-    __friendlyToHash             : null,
-    __hashToFriendly             : null,
-    __groupToFriendly            : null,
-    __friendlyToGroups           : null,
-    __bEventProcessingInProgress : false,
-    __bTerminated                : true,
+  members: {
+    __states: null,
+    __startState: null,
+    __eventQueue: null,
+    __blockedEvents: null,
+    __savedStates: null,
+    __friendlyToObject: null,
+    __friendlyToHash: null,
+    __hashToFriendly: null,
+    __groupToFriendly: null,
+    __friendlyToGroups: null,
+    __bEventProcessingInProgress: false,
+    __bTerminated: true,
 
     /**
      * Checks whether the finite state machine is terminated or not.
      *
      * @return {Boolean} If the finite state machine is terminated.
      */
-    isTerminated : function()
-    {
+    isTerminated() {
       return this.__bTerminated;
     },
 
@@ -275,27 +247,24 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      * @throws {Error} If the given state is not an instanceof of qx.util.fsm.State.
      * @throws {Error} If the given state already exists.
      */
-    addState : function(state)
-    {
+    addState(state) {
       // Ensure that we got valid state info
-      if (!state instanceof qx.util.fsm.State)
-      {
-        throw new Error("Invalid state: not an instance of " +
-                        "qx.util.fsm.State");
+      if (!state instanceof qx.util.fsm.State) {
+        throw new Error(
+          "Invalid state: not an instance of " + "qx.util.fsm.State"
+        );
       }
 
       // Retrieve the name of this state
       var stateName = state.getName();
 
       // Ensure that the state name doesn't already exist
-      if (stateName in this.__states)
-      {
+      if (stateName in this.__states) {
         throw new Error("State " + stateName + " already exists");
       }
 
       // Is this the first state being added?
-      if (this.__startState == null)
-      {
+      if (this.__startState == null) {
         // Yup.  Save this state as the start state.
         this.__startState = stateName;
       }
@@ -304,7 +273,6 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       this.__states[stateName] = state;
     },
 
-
     /**
      * Replace a state in the finite state machine.  This is useful if
      * initially "dummy" states are created which load the real state table
@@ -327,13 +295,12 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *
      * @throws {Error} If the given state is not an instanceof of qx.util.fsm.State.
      */
-    replaceState : function(state, bDispose)
-    {
+    replaceState(state, bDispose) {
       // Ensure that we got valid state info
-      if (!state instanceof qx.util.fsm.State)
-      {
-        throw new Error("Invalid state: not an instance of " +
-                        "qx.util.fsm.State");
+      if (!state instanceof qx.util.fsm.State) {
+        throw new Error(
+          "Invalid state: not an instance of " + "qx.util.fsm.State"
+        );
       }
 
       // Retrieve the name of this state
@@ -346,8 +313,7 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       this.__states[stateName] = state;
 
       // Did they request that the old state be disposed?
-      if (bDispose)
-      {
+      if (bDispose) {
         // Yup.  Mark it to be disposed.
         oldState._bNeedDispose = true;
       }
@@ -355,7 +321,6 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       return oldState;
     },
 
-
     /**
      * Add an object (typically a widget) that is to be accessed during state
      * transitions, to the finite state machine.
@@ -371,35 +336,30 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   An optional list of group names of which this object is a member.
      *
      */
-    addObject : function(friendlyName, obj, groupNames)
-    {
+    addObject(friendlyName, obj, groupNames) {
       var hash = qx.core.ObjectRegistry.toHashCode(obj);
       this.__friendlyToHash[friendlyName] = hash;
       this.__hashToFriendly[hash] = friendlyName;
       this.__friendlyToObject[friendlyName] = obj;
 
       // If no groupNames are specified, we're done.
-      if (!groupNames)
-      {
+      if (!groupNames) {
         return;
       }
 
       // Allow either a single group name or an array of group names.  If the
       // former, we convert it to the latter to make the subsequent code
       // simpler.
-      if (typeof (groupNames) == "string")
-      {
-        groupNames = [ groupNames ];
+      if (typeof groupNames == "string") {
+        groupNames = [groupNames];
       }
 
       // For each group that this friendly name is to be a member of...
-      for (var i=0; i<groupNames.length; i++)
-      {
+      for (var i = 0; i < groupNames.length; i++) {
         var groupName = groupNames[i];
 
         // If the group name doesn't yet exist...
-        if (!this.__groupToFriendly[groupName])
-        {
+        if (!this.__groupToFriendly[groupName]) {
           // ... then create it.
           this.__groupToFriendly[groupName] = {};
         }
@@ -408,8 +368,7 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
         this.__groupToFriendly[groupName][friendlyName] = true;
 
         // If the friendly name group mapping doesn't yet exist...
-        if (!this.__friendlyToGroups[friendlyName])
-        {
+        if (!this.__friendlyToGroups[friendlyName]) {
           // ... then create it.
           this.__friendlyToGroups[friendlyName] = [];
         }
@@ -420,7 +379,6 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       }
     },
 
-
     /**
      * Remove an object which had previously been added by {@link #addObject}.
      *
@@ -430,35 +388,30 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   is to be removed.
      *
      */
-    removeObject : function(friendlyName)
-    {
-      var             hash;
-      var             groupName;
-      var             objName;
-      var             bGroupEmpty;
+    removeObject(friendlyName) {
+      var hash;
+      var groupName;
+      var objName;
+      var bGroupEmpty;
 
       hash = this.__friendlyToHash[friendlyName];
 
       // Delete references to any groups this friendly name was in
-      if (this.__friendlyToGroups[friendlyName])
-      {
-        for (var i = 0; i < this.__friendlyToGroups[friendlyName].length; i++)
-        {
+      if (this.__friendlyToGroups[friendlyName]) {
+        for (var i = 0; i < this.__friendlyToGroups[friendlyName].length; i++) {
           groupName = this.__friendlyToGroups[friendlyName][i];
           delete this.__groupToFriendly[groupName][friendlyName];
 
           // Is the group empty now?
           bGroupEmpty = true;
-          for (objName in this.__groupToFriendly[groupName])
-          {
+          for (objName in this.__groupToFriendly[groupName]) {
             // The group is not empty. That's all we wanted to know.
             bGroupEmpty = false;
             break;
           }
 
           // If the group is empty...
-          if (bGroupEmpty)
-          {
+          if (bGroupEmpty) {
             // ... then we can delete the entire entry
             delete this.__groupToFriendly[groupName];
           }
@@ -473,7 +426,6 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       delete this.__friendlyToObject[friendlyName];
     },
 
-
     /**
      * Retrieve an object previously saved via {@link #addObject}, using its
      * Friendly Name.
@@ -486,12 +438,10 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   The object which has the specified friendly name, or undefined if no
      *   object has been associated with that name.
      */
-    getObject : function(friendlyName)
-    {
+    getObject(friendlyName) {
       return this.__friendlyToObject[friendlyName];
     },
 
-
     /**
      * Get the friendly name of an object.
      *
@@ -503,13 +453,11 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   If the object has been previously registered via {@link #addObject},
      *   then the friendly name of the object is returned; otherwise, null.
      */
-    getFriendlyName : function(obj)
-    {
+    getFriendlyName(obj) {
       var hash = obj ? qx.core.ObjectRegistry.toHashCode(obj) : null;
       return hash ? this.__hashToFriendly[hash] : null;
     },
 
-
     /**
      * Retrieve the list of objects which have registered, via {@link #addObject}
      * as being members of the specified group.
@@ -522,40 +470,36 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   An array containing the friendly names of any objects which are
      *   members of the specified group.  The resultant array may be empty.
      */
-    getGroupObjects : function(groupName)
-    {
+    getGroupObjects(groupName) {
       var a = [];
 
-      for (var name in this.__groupToFriendly[groupName])
-      {
+      for (var name in this.__groupToFriendly[groupName]) {
         a.push(name);
       }
 
       return a;
     },
 
-
     /**
      * Display all of the saved objects and their reverse mappings.
      *
      */
-    displayAllObjects : function()
-    {
-      for (var friendlyName in this.__friendlyToHash)
-      {
+    displayAllObjects() {
+      for (var friendlyName in this.__friendlyToHash) {
         var hash = this.__friendlyToHash[friendlyName];
         var obj = this.getObject(friendlyName);
         this.debug(friendlyName + " => " + hash);
         this.debug("  " + hash + " => " + this.__hashToFriendly[hash]);
-        this.debug("  " +
-                   friendlyName + " => " + this.getObject(friendlyName));
-        this.debug("  " +
-                   this.getObject(friendlyName) + " => " +
-                   this.getFriendlyName(obj));
+        this.debug("  " + friendlyName + " => " + this.getObject(friendlyName));
+        this.debug(
+          "  " +
+            this.getObject(friendlyName) +
+            " => " +
+            this.getFriendlyName(obj)
+        );
       }
     },
 
-
     /**
      * Get internal data for debugging
      *
@@ -573,21 +517,19 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *     __friendlyToGroups
      *     __bEventProcessingInProgress
      */
-    _getInternalData : function()
-    {
-      return (
-        {
-          "states"           : this.__states,
-          "startState"       : this.__startState,
-          "eventQueue"       : this.__eventQueue,
-          "blockedEvents"    : this.__blockedEvents,
-          "savedStates"      : this.__savedStates,
-          "friendlyToObject" : this.__friendlyToObject,
-          "friendlyToHash"   : this.__friendlyToHash,
-          "hashToFriendly"   : this.__hashToFriendly,
-          "groupToFriendly"  : this.__groupToFriendly,
-          "friendlyToGroups" : this.__friendlyToGroups
-        });
+    _getInternalData() {
+      return {
+        states: this.__states,
+        startState: this.__startState,
+        eventQueue: this.__eventQueue,
+        blockedEvents: this.__blockedEvents,
+        savedStates: this.__savedStates,
+        friendlyToObject: this.__friendlyToObject,
+        friendlyToHash: this.__friendlyToHash,
+        hashToFriendly: this.__hashToFriendly,
+        groupToFriendly: this.__groupToFriendly,
+        friendlyToGroups: this.__friendlyToGroups
+      };
     },
 
     /**
@@ -597,14 +539,12 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *
      * @throws {Error} If the machine stared with not available state.
      */
-    start : function()
-    {
+    start() {
       this.__bTerminated = false;
 
       var stateName = this.__startState;
 
-      if (stateName == null)
-      {
+      if (stateName == null) {
         throw new Error("Machine started with no available states");
       }
 
@@ -615,35 +555,31 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       this.setNextState(null);
 
       var debugFunctions =
-        (this.getDebugFlags() &
-         qx.util.fsm.FiniteStateMachine.DebugFlags.FUNCTION_DETAIL);
+        this.getDebugFlags() &
+        qx.util.fsm.FiniteStateMachine.DebugFlags.FUNCTION_DETAIL;
 
       // Run the actionsBeforeOnentry actions for the initial state
-      if (debugFunctions)
-      {
+      if (debugFunctions) {
         this.debug(this.getName() + "#" + stateName + "#actionsBeforeOnentry");
       }
 
       this.__states[stateName].getAutoActionsBeforeOnentry()(this);
 
       // Run the entry function for the new state, if one is specified
-      if (debugFunctions)
-      {
+      if (debugFunctions) {
         this.debug(this.getName() + "#" + stateName + "#entry");
       }
 
       this.__states[stateName].getOnentry()(this, null);
 
       // Run the actionsAfterOnentry actions for the initial state
-      if (debugFunctions)
-      {
+      if (debugFunctions) {
         this.debug(this.getName() + "#" + stateName + "#actionsAfterOnentry");
       }
 
       this.__states[stateName].getAutoActionsAfterOnentry()(this);
     },
 
-
     /**
      * Save the current or previous state on the saved-state stack.  A future
      * transition can then provide, as its nextState value, the class
@@ -669,32 +605,24 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *
      * @throws {Error} If the saved-state stack is full.
      */
-    pushState : function(state)
-    {
+    pushState(state) {
       // See if there's room on the state stack for a new state
-      if (this.__savedStates.length >= this.getMaxSavedStates())
-      {
+      if (this.__savedStates.length >= this.getMaxSavedStates()) {
         // Nope.  Programmer error.
         throw new Error("Saved-state stack is full");
       }
 
-      if (state === true)
-      {
+      if (state === true) {
         // Push the current state onto the saved-state stack
         this.__savedStates.push(this.getState());
-      }
-      else if (state)
-      {
+      } else if (state) {
         this.__savedStates.push(state);
-      }
-      else
-      {
+      } else {
         // Push the previous state onto the saved-state stack
         this.__savedStates.push(this.getPreviousState());
       }
     },
 
-
     /**
      * Pop the saved state stack.
      *
@@ -702,11 +630,9 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   The name of a state or a boolean flag that had most recently been
      *   pushed onto the saved-state stack.
      */
-    popState : function()
-    {
+    popState() {
       // Is there anything on the saved-state stack?
-      if (this.__savedStates.length == 0)
-      {
+      if (this.__savedStates.length == 0) {
         // Nope. Programmer error.
         throw new Error("Saved-state stack is empty");
       }
@@ -723,14 +649,12 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   The event to add to the event queue for processing after state change.
      *
      */
-    postponeEvent : function(event)
-    {
+    postponeEvent(event) {
       // Add this event to the blocked event queue, so it will be passed to the
       // next state upon transition.
       this.__blockedEvents.unshift(event);
     },
 
-
     /**
      * Enqueue an event for processing
      *
@@ -744,52 +668,54 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   queue so that it receives in-order processing.
      *
      */
-    enqueueEvent : function(event, bAddAtHead)
-    {
+    enqueueEvent(event, bAddAtHead) {
       // Add the event to the event queue
-      if (bAddAtHead)
-      {
+      if (bAddAtHead) {
         // Put event at the head of the queue
         this.__eventQueue.push(event);
-      }
-      else
-      {
+      } else {
         // Put event at the tail of the queue
         this.__eventQueue.unshift(event);
       }
 
-      if (this.getDebugFlags() &
-          qx.util.fsm.FiniteStateMachine.DebugFlags.EVENTS)
-      {
+      if (
+        this.getDebugFlags() & qx.util.fsm.FiniteStateMachine.DebugFlags.EVENTS
+      ) {
         // Individual objects are listed.  Ensure target is a saved object
         var friendly = this.getFriendlyName(event.getTarget());
 
-        if (bAddAtHead)
-        {
-          this.debug(this.getName() + ": Pushed event: " + event.getType() +
-                   (friendly ? " on " + friendly : ""));
-        }
-        else
-        {
-          this.debug(this.getName() + ": Queued event: " + event.getType() +
-                   (friendly ? " on " + friendly : ""));
+        if (bAddAtHead) {
+          this.debug(
+            this.getName() +
+              ": Pushed event: " +
+              event.getType() +
+              (friendly ? " on " + friendly : "")
+          );
+        } else {
+          this.debug(
+            this.getName() +
+              ": Queued event: " +
+              event.getType() +
+              (friendly ? " on " + friendly : "")
+          );
         }
       }
     },
 
-
     /**
      * Event listener for all event types in the finite state machine
      *
      * @param event {qx.event.type.Event} The event that was dispatched.
      */
-    eventListener : function(event)
-    {
-      if (this.__bTerminated)
-      {
-        this.debug(this.getName() + ": Cannot listen to event '" +
-                   event.getType() +
-                   "', because the finite state machine is not running.");
+    eventListener(event) {
+      if (this.__bTerminated) {
+        this.debug(
+          this.getName() +
+            ": Cannot listen to event '" +
+            event.getType() +
+            "', because the finite state machine is not running."
+        );
+
         return;
       }
 
@@ -807,7 +733,6 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       this.__processEvents();
     },
 
-
     /**
      * Create an event and send it immediately to the finite state machine.
      *
@@ -824,34 +749,35 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   it.
      *
      */
-    fireImmediateEvent : function(type, target, data)
-    {
-      if (this.__bTerminated)
-      {
-        this.debug(this.getName() + ": Cannot listen to event '" + type +
-                   "', because the finite state machine is not running.");
+    fireImmediateEvent(type, target, data) {
+      if (this.__bTerminated) {
+        this.debug(
+          this.getName() +
+            ": Cannot listen to event '" +
+            type +
+            "', because the finite state machine is not running."
+        );
+
         return;
       }
 
-      if (data)
-      {
-        var event =
-          qx.event.Registration.createEvent(type,
-                                            qx.event.type.Data,
-                                            [ data, null, false ]);
-      }
-      else
-      {
-        var event =
-          qx.event.Registration.createEvent(type,
-                                            qx.event.type.Event,
-                                            [ false, false ]);
+      if (data) {
+        var event = qx.event.Registration.createEvent(
+          type,
+          qx.event.type.Data,
+          [data, null, false]
+        );
+      } else {
+        var event = qx.event.Registration.createEvent(
+          type,
+          qx.event.type.Event,
+          [false, false]
+        );
       }
       event.setTarget(target);
       this.eventListener(event);
     },
 
-
     /**
      * Create and schedule an event to be sent to the finite state machine
      * "shortly".  This allows such things as letting a progress cursor
@@ -872,38 +798,33 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      *   of 20 milliseconds) is used.
      *
      */
-    scheduleEvent : function(type, target, data, timeout)
-    {
+    scheduleEvent(type, target, data, timeout) {
       qx.event.Timer.once(
-        function()
-        {
+        function () {
           this.fireImmediateEvent(type, target, data);
         },
         this,
-        timeout || 20);
+        timeout || 20
+      );
     },
 
-
     /**
      * Process all of the events on the event queue.
      *
      */
-    __processEvents : function()
-    {
+    __processEvents() {
       // eventListener() can potentially be called while we're processing
       // events
-      if (this.__bEventProcessingInProgress)
-      {
+      if (this.__bEventProcessingInProgress) {
         // We were processing already, so don't process concurrently.
-        return ;
+        return;
       }
 
       // Track that we're processing events
       this.__bEventProcessingInProgress = true;
 
       // Process each of the events on the event queue
-      while (this.__eventQueue.length > 0)
-      {
+      while (this.__eventQueue.length > 0) {
         // Pull the next event from the pending event queue
         var event = this.__eventQueue.pop();
 
@@ -911,8 +832,7 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
         var bDispose = this.__run(event);
 
         // If we didn't block (and re-queue) the event, dispose it.
-        if (bDispose)
-        {
+        if (bDispose) {
           event.dispose();
         }
       }
@@ -921,7 +841,6 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       this.__bEventProcessingInProgress = false;
     },
 
-
     /**
      * Run the finite state machine to process a single event.
      *
@@ -942,8 +861,7 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
      * @throws {Error} If the state stack is empty and the next state is POP_STATE_STACK
      * @throws {Error} If the next state is invalid.
      */
-    __run : function(event)
-    {
+    __run(event) {
       // For use in generated functions...
       // State name variables
       var thisState;
@@ -978,10 +896,13 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       // Individual objects are listed.  Ensure target is a saved object
       var friendly = this.getFriendlyName(event.getTarget());
 
-      if (debugEvents)
-      {
-        this.debug(this.getName() + ": Process event: " + event.getType() +
-                   (friendly ? " on " + friendly : ""));
+      if (debugEvents) {
+        this.debug(
+          this.getName() +
+            ": Process event: " +
+            event.getType() +
+            (friendly ? " on " + friendly : "")
+        );
       }
 
       // Get the current state name
@@ -997,12 +918,15 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       e = currentState.getEvents()[event.getType()];
 
       // See if we actually found this event type
-      if (!e)
-      {
-        if (debugEvents)
-        {
-          this.debug(this.getName() + ": Event '" + event.getType() + "'" +
-                     " not handled.  Ignoring.");
+      if (!e) {
+        if (debugEvents) {
+          this.debug(
+            this.getName() +
+              ": Event '" +
+              event.getType() +
+              "'" +
+              " not handled.  Ignoring."
+          );
         }
 
         return true;
@@ -1012,16 +936,18 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
       // with each property name being the friendly name of a saved object,
       // and the property value being one of the constants (PREDICATE or
       // BLOCKED).
-      if (typeof (e) == "object")
-      {
-        if (!friendly)
-        {
+      if (typeof e == "object") {
+        if (!friendly) {
           // Nope, it doesn't seem so.  Just discard it.
-          if (debugObjectNotFound)
-          {
-            this.debug(this.getName() +
-                       ": Could not find friendly name for '" +
-                       event.getType() + "' on '" + event.getTarget() + "'");
+          if (debugObjectNotFound) {
+            this.debug(
+              this.getName() +
+                ": Could not find friendly name for '" +
+                event.getType() +
+                "' on '" +
+                event.getTarget() +
+                "'"
+            );
           }
 
           return true;
@@ -1031,35 +957,41 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
 
         // Do we handle this event type for the widget from which it
         // originated?
-        if (! action)
-        {
+        if (!action) {
           // Nope.
-          if (debugEvents)
-          {
-            this.debug(this.getName() + ": Event '" + event.getType() + "'" +
-                       " not handled for target " + friendly + ".  Ignoring.");
+          if (debugEvents) {
+            this.debug(
+              this.getName() +
+                ": Event '" +
+                event.getType() +
+                "'" +
+                " not handled for target " +
+                friendly +
+                ".  Ignoring."
+            );
           }
 
           return true;
         }
-      }
-      else
-      {
+      } else {
         action = e;
       }
 
-      switch(action)
-      {
+      switch (action) {
         case qx.util.fsm.FiniteStateMachine.EventHandling.PREDICATE:
           // Process this event.  One of the transitions should handle it.
           break;
 
         case qx.util.fsm.FiniteStateMachine.EventHandling.BLOCKED:
           // This event is blocked.  Enqueue it for later, and get outta here.
-          if (debugEvents)
-          {
-            this.debug(this.getName() + ": Event '" + event.getType() + "'" +
-                       " blocked.  Re-queuing.");
+          if (debugEvents) {
+            this.debug(
+              this.getName() +
+                ": Event '" +
+                event.getType() +
+                "'" +
+                " blocked.  Re-queuing."
+            );
           }
 
           this.__blockedEvents.unshift(event);
@@ -1067,21 +999,18 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
 
         default:
           // See if we've been given an explicit transition name
-          if (typeof (action) == "string")
-          {
+          if (typeof action == "string") {
             // Yup!  Ensure that it exists
-            if (transitions[action])
-            {
+            if (transitions[action]) {
               // Yup.  Create a transitions object containing only this
               // transition.
               var trans = transitions[action];
               transitions = {};
               transitions[action] = trans;
-            }
-            else
-            {
-              throw new Error("Explicit transition " +
-                              action + " does not exist");
+            } else {
+              throw new Error(
+                "Explicit transition " + action + " does not exist"
+              );
             }
 
             break;
@@ -1090,13 +1019,11 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
 
       // We handle the event.  Try each transition in turn until we find one
       // that is acceptable.
-      for (var t in transitions)
-      {
+      for (var t in transitions) {
         var trans = transitions[t];
 
         // Does the predicate allow use of this transition?
-        switch(trans.getPredicate()(this, event))
-        {
+        switch (trans.getPredicate()(this, event)) {
           case true:
             // Transition is allowed.  Proceed.
             break;
@@ -1110,31 +1037,32 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
             return true;
 
           default:
-            throw new Error("Transition " + thisState + ":" + t +
-                            " returned a value other than " +
-                            "true, false, or null.");
+            throw new Error(
+              "Transition " +
+                thisState +
+                ":" +
+                t +
+                " returned a value other than " +
+                "true, false, or null."
+            );
         }
 
         // We think we can transition to the next state.  Set next state.
         nextState = trans.getNextState();
 
-        if (typeof (nextState) == "string")
-        {
+        if (typeof nextState == "string") {
           // We found a literal state name.  Ensure it exists.
-          if (!nextState in this.__states)
-          {
-            throw new Error("Attempt to transition to nonexistent state " +
-                            nextState);
+          if (!nextState in this.__states) {
+            throw new Error(
+              "Attempt to transition to nonexistent state " + nextState
+            );
           }
 
           // It exists.  Track it being the next state.
           this.setNextState(nextState);
-        }
-        else
-        {
+        } else {
           // If it's not a string, nextState must be a StateChange constant
-          switch(nextState)
-          {
+          switch (nextState) {
             case qx.util.fsm.FiniteStateMachine.StateChange.CURRENT_STATE:
               // They want to remain in the same state.
               nextState = thisState;
@@ -1143,10 +1071,11 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
 
             case qx.util.fsm.FiniteStateMachine.StateChange.POP_STATE_STACK:
               // Switch to the state at the top of the state stack.
-              if (this.__savedStates.length == 0)
-              {
-                throw new Error("Attempt to transition to POP_STATE_STACK " +
-                                "while state stack is empty.");
+              if (this.__savedStates.length == 0) {
+                throw new Error(
+                  "Attempt to transition to POP_STATE_STACK " +
+                    "while state stack is empty."
+                );
               }
 
               // Pop the state stack to retrieve the state to transition to
@@ -1166,70 +1095,76 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
         }
 
         // Run the actionsBeforeOntransition actions for this transition
-        if (debugFunctions)
-        {
-          this.debug(this.getName() + "#" + thisState + "#" + t +
-                     "#autoActionsBeforeOntransition");
+        if (debugFunctions) {
+          this.debug(
+            this.getName() +
+              "#" +
+              thisState +
+              "#" +
+              t +
+              "#autoActionsBeforeOntransition"
+          );
         }
 
         trans.getAutoActionsBeforeOntransition()(this);
 
         // Run the 'ontransition' function
-        if (debugFunctions)
-        {
-          this.debug(this.getName() + "#" + thisState + "#" + t +
-                     "#ontransition");
+        if (debugFunctions) {
+          this.debug(
+            this.getName() + "#" + thisState + "#" + t + "#ontransition"
+          );
         }
 
         trans.getOntransition()(this, event);
 
         // Run the autoActionsAfterOntransition actions for this transition
-        if (debugFunctions)
-        {
-          this.debug(this.getName() + "#" + thisState + "#" + t +
-                     "#autoActionsAfterOntransition");
+        if (debugFunctions) {
+          this.debug(
+            this.getName() +
+              "#" +
+              thisState +
+              "#" +
+              t +
+              "#autoActionsAfterOntransition"
+          );
         }
 
         trans.getAutoActionsAfterOntransition()(this);
 
         // Run the autoActionsBeforeOnexit actions for the old state
-        if (debugFunctions)
-        {
-          this.debug(this.getName() + "#" + thisState +
-                     "#autoActionsBeforeOnexit");
+        if (debugFunctions) {
+          this.debug(
+            this.getName() + "#" + thisState + "#autoActionsBeforeOnexit"
+          );
         }
 
         currentState.getAutoActionsBeforeOnexit()(this);
 
         // Run the exit function for the old state
-        if (debugFunctions)
-        {
+        if (debugFunctions) {
           this.debug(this.getName() + "#" + thisState + "#exit");
         }
 
         currentState.getOnexit()(this, event);
 
         // Run the autoActionsAfterOnexit actions for the old state
-        if (debugFunctions)
-        {
-          this.debug(this.getName() + "#" + thisState +
-                     "#autoActionsAfterOnexit");
+        if (debugFunctions) {
+          this.debug(
+            this.getName() + "#" + thisState + "#autoActionsAfterOnexit"
+          );
         }
 
         currentState.getAutoActionsAfterOnexit()(this);
 
         // If this state has been replaced and we're supposed to dispose it...
-        if (currentState._bNeedDispose)
-        {
+        if (currentState._bNeedDispose) {
           // ... then dispose it now that it's no longer in use
           currentState.dispose();
         }
 
         // It the fsm has terminated, stop right here
-        if (this.__bTerminated)
-        {
-          if (debugFunctions)
-          {
+        if (this.__bTerminated) {
+          if (debugFunctions) {
             this.debug(this.getName() + "#" + "TERMINATED");
           }
           this.fireDataEvent("terminated", thisState);
@@ -1248,63 +1183,69 @@ qx.Class.define("qx.util.fsm.FiniteStateMachine",
         nextState = undefined;
 
         // Run the autoActionsBeforeOnentry actions for the new state
-        if (debugFunctions)
-        {
-          this.debug(this.getName() + "#" + thisState +
-                     "#autoActionsBeforeOnentry");
+        if (debugFunctions) {
+          this.debug(
+            this.getName() + "#" + thisState + "#autoActionsBeforeOnentry"
+          );
         }
 
         currentState.getAutoActionsBeforeOnentry()(this);
 
         // Run the entry function for the new state, if one is specified
-        if (debugFunctions)
-        {
+        if (debugFunctions) {
           this.debug(this.getName() + "#" + thisState + "#entry");
         }
 
         currentState.getOnentry()(this, event);
 
         // Run the autoActionsAfterOnentry actions for the new state
-        if (debugFunctions)
-        {
-          this.debug(this.getName() + "#" + thisState +
-                     "#autoActionsAfterOnentry");
+        if (debugFunctions) {
+          this.debug(
+            this.getName() + "#" + thisState + "#autoActionsAfterOnentry"
+          );
         }
 
         currentState.getAutoActionsAfterOnentry()(this);
 
         // Add any blocked events back onto the pending event queue
-        for (var i=0; i<this.__blockedEvents.length; i++)
-        {
+        for (var i = 0; i < this.__blockedEvents.length; i++) {
           e = this.__blockedEvents.pop();
           this.__eventQueue.unshift(e);
         }
 
-        if (debugTransitions)
-        {
-          this.debug(this.getName() + "#" + prevState + " => " +
-                     this.getName() + "#" + thisState);
+        if (debugTransitions) {
+          this.debug(
+            this.getName() +
+              "#" +
+              prevState +
+              " => " +
+              this.getName() +
+              "#" +
+              thisState
+          );
         }
 
         // See ya!
         return true;
       }
 
-      if (debugTransitions)
-      {
-        this.debug(this.getName() +
-                   "#" + thisState + ": event '" +
-                   event.getType() + "'" +
-                   ": no transition found.  No state change.");
+      if (debugTransitions) {
+        this.debug(
+          this.getName() +
+            "#" +
+            thisState +
+            ": event '" +
+            event.getType() +
+            "'" +
+            ": no transition found.  No state change."
+        );
       }
 
       return true;
     }
   },
 
-
-  destruct : function()
-  {
+  destruct() {
     this._disposeArray("__eventQueue");
     this._disposeArray("__blockedEvents");
     this.__savedStates = this.__states = null;