wiselinks 0.3.0 → 0.3.2

data/lib/assets/javascripts/_history.html4.js

@@ -0,0 +1,621 @@
+/**
+ * History.js HTML4 Support
+ * Depends on the HTML5 Support
+ * @author Benjamin Arthur Lupton <contact@balupton.com>
+ * @copyright 2010-2011 Benjamin Arthur Lupton <contact@balupton.com>
+ * @license New BSD License <http://creativecommons.org/licenses/BSD/>
+ */
+
+(function(window,undefined){
+  "use strict";
+
+  // ========================================================================
+  // Initialise
+
+  // Localise Globals
+  var
+    document = window.document, // Make sure we are using the correct document
+    setTimeout = window.setTimeout||setTimeout,
+    clearTimeout = window.clearTimeout||clearTimeout,
+    setInterval = window.setInterval||setInterval,
+    History = window.History = window.History||{}; // Public History Object
+
+  // Check Existence
+  if ( typeof History.initHtml4 !== 'undefined' ) {
+    throw new Error('History.js HTML4 Support has already been loaded...');
+  }
+
+
+  // ========================================================================
+  // Initialise HTML4 Support
+
+  // Initialise HTML4 Support
+  History.initHtml4 = function(){
+    // Initialise
+    if ( typeof History.initHtml4.initialized !== 'undefined' ) {
+      // Already Loaded
+      return false;
+    }
+    else {
+      History.initHtml4.initialized = true;
+    }
+
+
+    // ====================================================================
+    // Properties
+
+    /**
+     * History.enabled
+     * Is History enabled?
+     */
+    History.enabled = true;
+
+
+    // ====================================================================
+    // Hash Storage
+
+    /**
+     * History.savedHashes
+     * Store the hashes in an array
+     */
+    History.savedHashes = [];
+
+    /**
+     * History.isLastHash(newHash)
+     * Checks if the hash is the last hash
+     * @param {string} newHash
+     * @return {boolean} true
+     */
+    History.isLastHash = function(newHash){
+      // Prepare
+      var oldHash = History.getHashByIndex(),
+        isLast;
+
+      // Check
+      isLast = newHash === oldHash;
+
+      // Return isLast
+      return isLast;
+    };
+
+    /**
+     * History.saveHash(newHash)
+     * Push a Hash
+     * @param {string} newHash
+     * @return {boolean} true
+     */
+    History.saveHash = function(newHash){
+      // Check Hash
+      if ( History.isLastHash(newHash) ) {
+        return false;
+      }
+
+      // Push the Hash
+      History.savedHashes.push(newHash);
+
+      // Return true
+      return true;
+    };
+
+    /**
+     * History.getHashByIndex()
+     * Gets a hash by the index
+     * @param {integer} index
+     * @return {string}
+     */
+    History.getHashByIndex = function(index){
+      // Prepare
+      var hash = null;
+
+      // Handle
+      if ( typeof index === 'undefined' ) {
+        // Get the last inserted
+        hash = History.savedHashes[History.savedHashes.length-1];
+      }
+      else if ( index < 0 ) {
+        // Get from the end
+        hash = History.savedHashes[History.savedHashes.length+index];
+      }
+      else {
+        // Get from the beginning
+        hash = History.savedHashes[index];
+      }
+
+      // Return hash
+      return hash;
+    };
+
+
+    // ====================================================================
+    // Discarded States
+
+    /**
+     * History.discardedHashes
+     * A hashed array of discarded hashes
+     */
+    History.discardedHashes = {};
+
+    /**
+     * History.discardedStates
+     * A hashed array of discarded states
+     */
+    History.discardedStates = {};
+
+    /**
+     * History.discardState(State)
+     * Discards the state by ignoring it through History
+     * @param {object} State
+     * @return {true}
+     */
+    History.discardState = function(discardedState,forwardState,backState){
+      //History.debug('History.discardState', arguments);
+      // Prepare
+      var discardedStateHash = History.getHashByState(discardedState),
+        discardObject;
+
+      // Create Discard Object
+      discardObject = {
+        'discardedState': discardedState,
+        'backState': backState,
+        'forwardState': forwardState
+      };
+
+      // Add to DiscardedStates
+      History.discardedStates[discardedStateHash] = discardObject;
+
+      // Return true
+      return true;
+    };
+
+    /**
+     * History.discardHash(hash)
+     * Discards the hash by ignoring it through History
+     * @param {string} hash
+     * @return {true}
+     */
+    History.discardHash = function(discardedHash,forwardState,backState){
+      //History.debug('History.discardState', arguments);
+      // Create Discard Object
+      var discardObject = {
+        'discardedHash': discardedHash,
+        'backState': backState,
+        'forwardState': forwardState
+      };
+
+      // Add to discardedHash
+      History.discardedHashes[discardedHash] = discardObject;
+
+      // Return true
+      return true;
+    };
+
+    /**
+     * History.discardState(State)
+     * Checks to see if the state is discarded
+     * @param {object} State
+     * @return {bool}
+     */
+    History.discardedState = function(State){
+      // Prepare
+      var StateHash = History.getHashByState(State),
+        discarded;
+
+      // Check
+      discarded = History.discardedStates[StateHash]||false;
+
+      // Return true
+      return discarded;
+    };
+
+    /**
+     * History.discardedHash(hash)
+     * Checks to see if the state is discarded
+     * @param {string} State
+     * @return {bool}
+     */
+    History.discardedHash = function(hash){
+      // Check
+      var discarded = History.discardedHashes[hash]||false;
+
+      // Return true
+      return discarded;
+    };
+
+    /**
+     * History.recycleState(State)
+     * Allows a discarded state to be used again
+     * @param {object} data
+     * @param {string} title
+     * @param {string} url
+     * @return {true}
+     */
+    History.recycleState = function(State){
+      //History.debug('History.recycleState', arguments);
+      // Prepare
+      var StateHash = History.getHashByState(State);
+
+      // Remove from DiscardedStates
+      if ( History.discardedState(State) ) {
+        delete History.discardedStates[StateHash];
+      }
+
+      // Return true
+      return true;
+    };
+
+
+    // ====================================================================
+    // HTML4 HashChange Support
+
+    if ( History.emulated.hashChange ) {
+      /*
+       * We must emulate the HTML4 HashChange Support by manually checking for hash changes
+       */
+
+      /**
+       * History.hashChangeInit()
+       * Init the HashChange Emulation
+       */
+      History.hashChangeInit = function(){
+        // Define our Checker Function
+        History.checkerFunction = null;
+
+        // Define some variables that will help in our checker function
+        var lastDocumentHash = '',
+          iframeId, iframe,
+          lastIframeHash, checkerRunning;
+
+        // Handle depending on the browser
+        if ( History.isInternetExplorer() ) {
+          // IE6 and IE7
+          // We need to use an iframe to emulate the back and forward buttons
+
+          // Create iFrame
+          iframeId = 'historyjs-iframe';
+          iframe = document.createElement('iframe');
+
+          // Adjust iFarme
+          iframe.setAttribute('id', iframeId);
+          iframe.style.display = 'none';
+
+          // Append iFrame
+          document.body.appendChild(iframe);
+
+          // Create initial history entry
+          iframe.contentWindow.document.open();
+          iframe.contentWindow.document.close();
+
+          // Define some variables that will help in our checker function
+          lastIframeHash = '';
+          checkerRunning = false;
+
+          // Define the checker function
+          History.checkerFunction = function(){
+            // Check Running
+            if ( checkerRunning ) {
+              return false;
+            }
+
+            // Update Running
+            checkerRunning = true;
+
+            // Fetch
+            var documentHash = History.getHash()||'',
+              iframeHash = History.unescapeHash(iframe.contentWindow.document.location.hash)||'';
+
+            // The Document Hash has changed (application caused)
+            if ( documentHash !== lastDocumentHash ) {
+              // Equalise
+              lastDocumentHash = documentHash;
+
+              // Create a history entry in the iframe
+              if ( iframeHash !== documentHash ) {
+                //History.debug('hashchange.checker: iframe hash change', 'documentHash (new):', documentHash, 'iframeHash (old):', iframeHash);
+
+                // Equalise
+                lastIframeHash = iframeHash = documentHash;
+
+                // Create History Entry
+                iframe.contentWindow.document.open();
+                iframe.contentWindow.document.close();
+
+                // Update the iframe's hash
+                iframe.contentWindow.document.location.hash = History.escapeHash(documentHash);
+              }
+
+              // Trigger Hashchange Event
+              History.Adapter.trigger(window,'hashchange');
+            }
+
+            // The iFrame Hash has changed (back button caused)
+            else if ( iframeHash !== lastIframeHash ) {
+              //History.debug('hashchange.checker: iframe hash out of sync', 'iframeHash (new):', iframeHash, 'documentHash (old):', documentHash);
+
+              // Equalise
+              lastIframeHash = iframeHash;
+
+              // Update the Hash
+              History.setHash(iframeHash,false);
+            }
+
+            // Reset Running
+            checkerRunning = false;
+
+            // Return true
+            return true;
+          };
+        }
+        else {
+          // We are not IE
+          // Firefox 1 or 2, Opera
+
+          // Define the checker function
+          History.checkerFunction = function(){
+            // Prepare
+            var documentHash = History.getHash();
+
+            // The Document Hash has changed (application caused)
+            if ( documentHash !== lastDocumentHash ) {
+              // Equalise
+              lastDocumentHash = documentHash;
+
+              // Trigger Hashchange Event
+              History.Adapter.trigger(window,'hashchange');
+            }
+
+            // Return true
+            return true;
+          };
+        }
+
+        // Apply the checker function
+        History.intervalList.push(setInterval(History.checkerFunction, History.options.hashChangeInterval));
+
+        // Done
+        return true;
+      }; // History.hashChangeInit
+
+      // Bind hashChangeInit
+      History.Adapter.onDomLoad(History.hashChangeInit);
+
+    } // History.emulated.hashChange
+
+
+    // ====================================================================
+    // HTML5 State Support
+
+    // Non-Native pushState Implementation
+    if ( History.emulated.pushState ) {
+      /*
+       * We must emulate the HTML5 State Management by using HTML4 HashChange
+       */
+
+      /**
+       * History.onHashChange(event)
+       * Trigger HTML5's window.onpopstate via HTML4 HashChange Support
+       */
+      History.onHashChange = function(event){
+        //History.debug('History.onHashChange', arguments);
+
+        // Prepare
+        var currentUrl = ((event && event.newURL) || document.location.href),
+          currentHash = History.getHashByUrl(currentUrl),
+          currentState = null,
+          currentStateHash = null,
+          currentStateHashExits = null,
+          discardObject;
+
+        // Check if we are the same state
+        if ( History.isLastHash(currentHash) ) {
+          // There has been no change (just the page's hash has finally propagated)
+          //History.debug('History.onHashChange: no change');
+          History.busy(false);
+          return false;
+        }
+
+        // Reset the double check
+        History.doubleCheckComplete();
+
+        // Store our location for use in detecting back/forward direction
+        History.saveHash(currentHash);
+
+        // Expand Hash
+        if ( currentHash && History.isTraditionalAnchor(currentHash) ) {
+          //History.debug('History.onHashChange: traditional anchor', currentHash);
+          // Traditional Anchor Hash
+          History.Adapter.trigger(window,'anchorchange');
+          History.busy(false);
+          return false;
+        }
+
+        // Create State
+        currentState = History.extractState(History.getFullUrl(currentHash||document.location.href,false),true);
+
+        // Check if we are the same state
+        if ( History.isLastSavedState(currentState) ) {
+          //History.debug('History.onHashChange: no change');
+          // There has been no change (just the page's hash has finally propagated)
+          History.busy(false);
+          return false;
+        }
+
+        // Create the state Hash
+        currentStateHash = History.getHashByState(currentState);
+
+        // Check if we are DiscardedState
+        discardObject = History.discardedState(currentState);
+        if ( discardObject ) {
+          // Ignore this state as it has been discarded and go back to the state before it
+          if ( History.getHashByIndex(-2) === History.getHashByState(discardObject.forwardState) ) {
+            // We are going backwards
+            //History.debug('History.onHashChange: go backwards');
+            History.back(false);
+          } else {
+            // We are going forwards
+            //History.debug('History.onHashChange: go forwards');
+            History.forward(false);
+          }
+          return false;
+        }
+
+        // Push the new HTML5 State
+        //History.debug('History.onHashChange: success hashchange');
+        History.pushState(currentState.data,currentState.title,currentState.url,false);
+
+        // End onHashChange closure
+        return true;
+      };
+      History.Adapter.bind(window,'hashchange',History.onHashChange);
+
+      /**
+       * History.pushState(data,title,url)
+       * Add a new State to the history object, become it, and trigger onpopstate
+       * We have to trigger for HTML4 compatibility
+       * @param {object} data
+       * @param {string} title
+       * @param {string} url
+       * @return {true}
+       */
+      History.pushState = function(data,title,url,queue){
+        //History.debug('History.pushState: called', arguments);
+
+        // Check the State
+        if ( History.getHashByUrl(url) ) {
+          throw new Error('History.js does not support states with fragement-identifiers (hashes/anchors).');
+        }
+
+        // Handle Queueing
+        if ( queue !== false && History.busy() ) {
+          // Wait + Push to Queue
+          //History.debug('History.pushState: we must wait', arguments);
+          History.pushQueue({
+            scope: History,
+            callback: History.pushState,
+            args: arguments,
+            queue: queue
+          });
+          return false;
+        }
+
+        // Make Busy
+        History.busy(true);
+
+        // Fetch the State Object
+        var newState = History.createStateObject(data,title,url),
+          newStateHash = History.getHashByState(newState),
+          oldState = History.getState(false),
+          oldStateHash = History.getHashByState(oldState),
+          html4Hash = History.getHash();
+
+        // Store the newState
+        History.storeState(newState);
+        History.expectedStateId = newState.id;
+
+        // Recycle the State
+        History.recycleState(newState);
+
+        // Force update of the title
+        // History.setTitle(newState);
+
+        // Check if we are the same State
+        if ( newStateHash === oldStateHash ) {
+          //History.debug('History.pushState: no change', newStateHash);
+          History.busy(false);
+          return false;
+        }
+
+        // Update HTML4 Hash
+        if ( newStateHash !== html4Hash && newStateHash !== History.getShortUrl(document.location.href) ) {
+          //History.debug('History.pushState: update hash', newStateHash, html4Hash);
+          History.setHash(newStateHash,false);
+          return false;
+        }
+
+        // Update HTML5 State
+        History.saveState(newState);
+
+        // Fire HTML5 Event
+        //History.debug('History.pushState: trigger popstate');
+        History.Adapter.trigger(window,'statechange');
+        History.busy(false);
+
+        // End pushState closure
+        return true;
+      };
+
+      /**
+       * History.replaceState(data,title,url)
+       * Replace the State and trigger onpopstate
+       * We have to trigger for HTML4 compatibility
+       * @param {object} data
+       * @param {string} title
+       * @param {string} url
+       * @return {true}
+       */
+      History.replaceState = function(data,title,url,queue){
+        //History.debug('History.replaceState: called', arguments);
+
+        // Check the State
+        if ( History.getHashByUrl(url) ) {
+          throw new Error('History.js does not support states with fragement-identifiers (hashes/anchors).');
+        }
+
+        // Handle Queueing
+        if ( queue !== false && History.busy() ) {
+          // Wait + Push to Queue
+          //History.debug('History.replaceState: we must wait', arguments);
+          History.pushQueue({
+            scope: History,
+            callback: History.replaceState,
+            args: arguments,
+            queue: queue
+          });
+          return false;
+        }
+
+        // Make Busy
+        History.busy(true);
+
+        // Fetch the State Objects
+        var newState        = History.createStateObject(data,title,url),
+          oldState        = History.getState(false),
+          previousState   = History.getStateByIndex(-2);
+
+        // Discard Old State
+        History.discardState(oldState,newState,previousState);
+
+        // Alias to PushState
+        History.pushState(newState.data,newState.title,newState.url,false);
+
+        // End replaceState closure
+        return true;
+      };
+
+    } // History.emulated.pushState
+
+
+
+    // ====================================================================
+    // Initialise
+
+    // Non-Native pushState Implementation
+    if ( History.emulated.pushState ) {
+      /**
+       * Ensure initial state is handled correctly
+       */
+      if ( History.getHash() && !History.emulated.hashChange ) {
+        History.Adapter.onDomLoad(function(){
+          History.Adapter.trigger(window,'hashchange');
+        });
+      }
+
+    } // History.emulated.pushState
+
+  }; // History.initHtml4
+
+  // Try and Initialise History
+  if ( typeof History.init !== 'undefined' ) {
+    History.init();
+  }
+
+})(window);