Source: singletons/history.js

  1. /**
  2.  * @class
  3.  * @classdesc Manages and stores [Actions]{@link Syntree.Action}
  4.  */
  5. Syntree.History = {
  6.     /**
  7.      * Actions is stored as a queue with the most recent action at the end (index length-1).
  8.      * Note that it is returned as an array with the most recent action at the front (index 0).
  9.      *
  10.      * @see Syntree.History.getAll()
  11.      */
  12.     actions: [],
  14.     /**
  15.      * While this is set to true, no [Actions]{@link Syntree.Action} are added to the history.
  16.      * This is used so that we don't have to worry about creating new [Actions]{@link Syntree.Action} while undoing old ones.
  17.      */
  18.     silent: false,
  20.     /**
  21.      * Add an action to the history.
  22.      *
  23.      * @see Syntree.History.actions
  24.      */
  25.     addAction: function(action) {
  26.         action = Syntree.Lib.checkArg(action, 'action');
  28.         if (!this.silent) {
  29.             this.actions.push(action);
  30.         }
  31.     },
  33.     /**
  34.      * Get the most recent [Action]{@link Syntree.Action}.
  35.      *
  36.      * @see Syntree.History.actions
  37.      * @returns {Syntree.Action} - the most recent action.
  38.      */
  39.     getLast: function() {
  40.         return this.actions[this.actions.length-1];
  41.     },
  43.     /**
  44.      * Get all [Actions]{@link Syntree.Action}, reversed so that the most recent is at the front.
  45.      *
  46.      * @returns {Syntree.Action[]} - all actions in the history.
  47.      *
  48.      * @see Syntree.History.actions
  49.      */
  50.     getAll: function() {
  51.         return this.actions.slice().reverse();
  52.     },
  54.     /**
  55.      * Get all [Actions]{@link Syntree.Action}, reversed so that the most recent is at the front.
  56.      * Filter by given type.
  57.      *
  58.      * @param {string} - type of action to filter by, e.g. 'select'
  59.      * @returns {Syntree.Action[]} - all actions matching the given type
  60.      *
  61.      * @see Syntree.History.getAll
  62.      * @see Syntree.History.actions
  63.      */
  64.     getAllByType: function(type) {
  65.         type = Syntree.Lib.checkArg(type, 'string');
  67.         var filtered = this.actions.filter(function(value) {
  68.             return value.type === type;
  69.         });
  70.         return filtered.slice().reverse();
  71.     },
  73.     /**
  74.      * Get the most recent [Action]{@link Syntree.Action} of given type.
  75.      *
  76.      * @param {string} - type of action to filter by, e.g. 'select'
  77.      * @returns {Syntree.Action} - most recent action of given type
  78.      *
  79.      * @see Syntree.History.getLast
  80.      * @see Syntree.History.actions
  81.      */
  82.     getLastOfType: function(type) {
  83.         type = Syntree.Lib.checkArg(type, 'string');
  85.         var actions = this.getByType(type);
  86.         return actions[actions.length-1];
  87.     },
  89.     /**
  90.      * Undo the most recent undoable [Action]{@link Syntree.Action}.
  91.      * During this function, History is silenced so that it does not collect eroneously produced [Actions]{@link Syntree.Action}.
  92.      *
  93.      * @see Syntree.History.silent
  94.      */
  95.     undo: function() {
  96.         this.silent = true;
  97.         var all = this.getAll();
  98.         for (i=0; i<all.length; i++) {
  99.             if (typeof all[i].undo !== 'undefined') {
  100.                 this.removeAction(all[i]);
  101.                 all[i].undo();
  102.                 this.silent = false;
  103.                 return;
  104.             }
  105.         }
  106.         this.silent = false;
  107.     },
  109.     /**
  110.      * Remove the given [Action]{@link Syntree.Action} from the history.
  111.      *
  112.      * @param {Syntree.Action} - action to remove
  113.      *
  114.      * @see Syntree.History.actions
  115.      */
  116.     removeAction: function(a) {
  117.         a = Syntree.Lib.checkArg(a, 'action');
  119.         this.actions.splice(this.actions.indexOf(a),1);
  120.     },
  122.     /**
  123.      * Get all [Actions]{@link Syntree.Action} representing a Node selection.
  124.      * This is a convenience function, so that we don't have to filter for selected element type inline.
  125.      *
  126.      * @returns {Syntree.Action[]} - all Node select actions, most recent at index 0
  127.      *
  128.      * @see Syntree.History.actions
  129.      */
  130.     getNodeSelects: function() {
  131.         var res = this.getAllByType('select');
  132.         res = res.filter(function(x) {
  133.             return Syntree.Lib.checkType(x.selected_obj, 'node');
  134.         });
  135.         return res;
  136.     },
  138.     toString: function() {
  139.         return '[object History]';
  140.     }
  141. }