ajax_scaffold_plugin 3.2.0

data/lib/base/ajax_scaffold.rb

@@ -0,0 +1,180 @@
+module AjaxScaffold # :nodoc:
+  class ScaffoldColumn
+    attr_reader :name, :eval, :sort_sql, :label, :class_name, :sanitize
+
+    # Only options[:name] is required. It will infer the eval and sort values
+    # based on the given class.
+    def initialize(klass, options)
+      @name = options[:name]
+      @eval = options[:eval].nil? ? "#{Inflector.underscore(klass.to_s)}.#{@name}" : options[:eval]
+      @label = options[:label].nil? ? Inflector.titleize(@name) : options[:label]
+      @sortable = options[:sortable].nil? ? true : options[:sortable]
+      @sort_sql = options[:sort_sql].nil? ? "#{klass.table_name}.#{@name}" : options[:sort_sql] unless !@sortable
+      @class_name = options[:class_name].nil? ? "" : options[:class_name]
+      @sanitize = options[:sanitize].nil? ? true : options[:sanitize]
+    end
+
+    def sanitize?
+      @sanitize
+    end
+
+    def sortable?
+      @sortable
+    end
+
+  end
+
+  module Common
+    def current_sort(params)
+      session[params[:scaffold_id]][:sort]
+    end
+
+    def current_sort_direction(params)
+      session[params[:scaffold_id]][:sort_direction]
+    end
+  end
+
+  module Controller
+
+    def clear_flashes
+      if request.xhr?
+        flash.keys.each do |flash_key|
+          flash[flash_key] = nil
+        end
+      end
+    end
+
+    def default_per_page
+      25
+    end
+
+    def store_or_get_from_session(id_key, value_key)
+      session[id_key][value_key] = params[value_key] if !params[value_key].nil?
+      params[value_key] ||= session[id_key][value_key]
+    end
+
+    def update_params(options)
+      @scaffold_id = params[:scaffold_id] ||= options[:default_scaffold_id]
+      session[@scaffold_id] ||= {:sort => options[:default_sort], :sort_direction => options[:default_sort_direction], :page => 1}
+
+      store_or_get_from_session(@scaffold_id, :sort)
+      store_or_get_from_session(@scaffold_id, :sort_direction)
+      store_or_get_from_session(@scaffold_id, :page)
+    end
+
+  end
+
+  module Helper
+    include AjaxScaffold::Common
+
+    def format_column(column_value, sanitize = true)
+      if column_empty?(column_value)
+        empty_column_text
+      elsif column_value.instance_of? Time
+        format_time(column_value)
+      elsif column_value.instance_of? Date
+        format_date(column_value)
+      else
+        sanitize ? h(column_value.to_s) : column_value.to_s
+      end
+    end
+
+    def format_time(time)
+      time.strftime("%m/%d/%Y %I:%M %p")
+    end
+
+    def format_date(date)
+      date.strftime("%m/%d/%Y")
+    end
+
+    def column_empty?(column_value)
+      column_value.nil? || (column_value.empty? rescue false)
+    end
+
+    def empty_column_text
+      "-"
+    end
+
+    # Generates a temporary id for creating a new element
+    def generate_temporary_id
+      (Time.now.to_f*1000).to_i.to_s
+    end
+
+    def pagination_ajax_links(paginator, params)
+      pagination_links_each(paginator, {}) do |n|
+        link_to_remote n,
+           { :url => params.merge(:page => n ),
+           :loading => "Element.show('#{loading_indicator_id(params.merge(:action => 'pagination'))}');",
+           :update => scaffold_content_id(params) },
+           { :href => url_for(params.merge(:page => n )) }
+      end
+    end
+
+    def column_sort_direction(column_name, params)
+      if column_name && column_name == current_sort(params)
+        current_sort_direction(params) == "asc" ? "desc" : "asc"
+      else
+        "asc"
+      end
+    end
+
+    def column_class(column_name, column_value, sort_column, class_name = nil)
+      class_name = String.new
+      class_name += "empty " if column_empty?(column_value)
+      class_name += "sorted " if (!sort_column.nil? && column_name == sort_column)
+      class_name += "#{class_name} " unless class_name.nil?
+      class_name
+    end
+
+    def loading_indicator_tag(options)
+      image_tag "indicator.gif", :style => "display:none;", :id => loading_indicator_id(options), :alt => "loading indicator", :class => "loading-indicator"
+    end
+
+    # The following are a bunch of helper methods to produce the common scaffold view id's
+
+    def scaffold_content_id(options)
+      "#{options[:scaffold_id]}-content"
+    end
+
+    def scaffold_column_header_id(options)
+      "#{options[:scaffold_id]}-#{options[:column_name]}-column"
+    end
+
+    def scaffold_tbody_id(options)
+      "#{options[:scaffold_id]}-tbody"
+    end
+
+    def scaffold_messages_id(options)
+      "#{options[:scaffold_id]}-messages"
+    end
+
+    def empty_message_id(options)
+      "#{options[:scaffold_id]}-empty-message"
+    end
+
+    def element_row_id(options)
+      "#{options[:scaffold_id]}-#{options[:action]}-#{options[:id]}-row"
+    end
+
+    def element_cell_id(options)
+      "#{options[:scaffold_id]}-#{options[:action]}-#{options[:id]}-cell"
+    end
+
+    def element_form_id(options)
+      "#{options[:scaffold_id]}-#{options[:action]}-#{options[:id]}-form"
+    end
+
+    def loading_indicator_id(options)
+      if options[:id].nil?
+        "#{options[:scaffold_id]}-#{options[:action]}-loading-indicator"
+      else
+        "#{options[:scaffold_id]}-#{options[:action]}-#{options[:id]}-loading-indicator"
+      end
+    end
+
+    def element_messages_id(options)
+      "#{options[:scaffold_id]}-#{options[:action]}-#{options[:id]}-messages"
+    end
+  end
+
+end

data/public/blank.html

@@ -0,0 +1,33 @@
+<!--    
+   Copyright (c) 2005, Brad Neuberg, bkn3@columbia.edu
+   http://codinginparadise.org
+   
+   Permission is hereby granted, free of charge, to any person obtaining 
+   a copy of this software and associated documentation files (the "Software"), 
+   to deal in the Software without restriction, including without limitation 
+   the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+   and/or sell copies of the Software, and to permit persons to whom the 
+   Software is furnished to do so, subject to the following conditions:
+   
+   The above copyright notice and this permission notice shall be 
+   included in all copies or substantial portions of the Software.
+   
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 
+   OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR 
+   THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+-->
+
+<html>
+   <script language="JavaScript">
+            function pageLoaded() {
+               window.parent.dhtmlHistory.iframeLoaded(window.location);
+            }
+   </script>
+   <body onload="pageLoaded()">
+      <h1>blank.html - Needed for Internet Explorer's hidden IFrame</h1>
+   </body>
+</html>

data/public/javascripts/ajax_scaffold.js

@@ -0,0 +1,126 @@
+/*  
+ AjaxScaffoldGenerator version 3.1.0
+ (c) 2006 Richard White <rrwhite@gmail.com>
+ 
+ AjaxScaffoldGenerator is freely distributable under the terms of an MIT-style license.
+ 
+ For details, see the AjaxScaffoldGenerator web site: http://www.ajaxscaffold.com/
+*/
+
+/*
+ * The following is a cross browser way to move around <tr> elements in a <table> or <tbody>
+ */
+ 
+var Abstract = new Object();
+Abstract.Table = function() {};
+Abstract.Table.prototype = {
+  tagTest: function(element, tagName) {
+    return $(element).tagName.toLowerCase() == tagName.toLowerCase();
+  }		
+};	
+
+Abstract.TableRow = function() {};
+Abstract.TableRow.prototype = Object.extend(new Abstract.Table(), {
+  initialize: function(targetTableRow, sourceTableRow) {
+    try {
+      var sourceTableRow = $(sourceTableRow);
+      var targetTableRow = $(targetTableRow);
+      
+      if (targetTableRow == null || !this.tagTest(targetTableRow,'tr') 
+      	|| sourceTableRow == null || !this.tagTest(sourceTableRow,'tr')) {
+        throw("TableRow: both parameters must be a <tr> tag.");
+      }
+      
+      var tableOrTbody = this.findParentTableOrTbody(targetTableRow);
+      
+      var newRow = tableOrTbody.insertRow(this.getNewRowIndex(targetTableRow) - this.getRowOffset(tableOrTbody));
+      newRow.parentNode.replaceChild(sourceTableRow, newRow);
+
+    } catch (e) {
+      alert(e);
+    }
+  },
+  getRowOffset: function(tableOrTbody) {
+    //If we are inserting into a tablebody we would need figure out the rowIndex of the first
+    // row in that tbody and subtract that offset from the new row index  
+    var rowOffset = 0;
+    if (this.tagTest(tableOrTbody,'tbody')) {
+      rowOffset = tableOrTbody.rows[0].rowIndex;
+    }
+    return rowOffset;
+  },
+  findParentTableOrTbody: function(element) {
+    var element = $(element);
+    // Completely arbitrary value
+    var maxSearchDepth = 3;
+    var currentSearchDepth = 1;
+    var current = element;
+    while (currentSearchDepth <= maxSearchDepth) {
+      current = current.parentNode;
+      if (this.tagTest(current, 'tbody') || this.tagTest(current, 'table')) {
+        return current;
+      }
+      currentSearchDepth++;
+    }
+  }		
+});
+
+var TableRow = new Object();
+
+TableRow.MoveBefore = Class.create();
+TableRow.MoveBefore.prototype = Object.extend(new Abstract.TableRow(), {
+  getNewRowIndex: function(target) {
+    return target.rowIndex;
+  }
+});
+
+TableRow.MoveAfter = Class.create();
+TableRow.MoveAfter.prototype = Object.extend(new Abstract.TableRow(), {
+  getNewRowIndex: function(target) {
+    return target.rowIndex+1;
+  }
+});
+
+/*
+ * The following are simple utility methods
+ */
+ 
+var AjaxScaffold = {  
+  stripe: function(tableBody) {
+    var even = false;
+    var tableBody = $(tableBody);
+    var tableRows = tableBody.getElementsByTagName("tr");
+    var length = tableBody.rows.length;
+      
+    for (var i = 0; i < length; i++) {
+      var tableRow = tableBody.rows[i];
+      //Make sure to skip rows that are create or edit rows or messages
+      if (!Element.hasClassName(tableRow, "create") 
+        && !Element.hasClassName(tableRow, "update")) {
+      	
+        if (even) {
+          Element.addClassName(tableRow, "even");
+        } else {
+          Element.removeClassName(tableRow, "even");
+        }
+        even = !even;
+      }
+    }
+  },
+  displayMessageIfEmpty: function(tableBody, emptyMessageElement) {
+    // Check to see if this was the last element in the list
+    if ($(tableBody).rows.length == 0) {
+      Element.show($(emptyMessageElement));
+    }
+  },
+  removeSortClasses: function(scaffoldId) {
+    $$('#' + scaffoldId + ' td.sorted').each(function(element) {
+      Element.removeClassName(element, "sorted");
+    });
+    $$('#' + scaffoldId + ' th.sorted').each(function(element) {
+      Element.removeClassName(element, "sorted");
+      Element.removeClassName(element, "asc");
+      Element.removeClassName(element, "desc");
+    });
+  }
+}

data/public/javascripts/dhtml_history.js

@@ -0,0 +1,961 @@
+/** 
+   Copyright (c) 2005, Brad Neuberg, bkn3@columbia.edu
+   http://codinginparadise.org
+   
+   Permission is hereby granted, free of charge, to any person obtaining 
+   a copy of this software and associated documentation files (the "Software"), 
+   to deal in the Software without restriction, including without limitation 
+   the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+   and/or sell copies of the Software, and to permit persons to whom the 
+   Software is furnished to do so, subject to the following conditions:
+   
+   The above copyright notice and this permission notice shall be 
+   included in all copies or substantial portions of the Software.
+   
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 
+   OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR 
+   THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   
+   The JSON class near the end of this file is
+   Copyright 2005, JSON.org
+*/
+
+/** An object that provides DHTML history, history data, and bookmarking 
+    for AJAX applications. */
+window.dhtmlHistory = {
+   /** Initializes our DHTML history. You should
+       call this after the page is finished loading. */
+   /** public */ initialize: function() {
+      // only Internet Explorer needs to be explicitly initialized;
+      // other browsers don't have its particular behaviors.
+      // Basicly, IE doesn't autofill form data until the page
+      // is finished loading, which means historyStorage won't
+      // work until onload has been fired.
+      if (this.isInternetExplorer() == false) {
+         return;
+      }
+         
+      // if this is the first time this page has loaded...
+      if (historyStorage.hasKey("DhtmlHistory_pageLoaded") == false) {
+         this.fireOnNewListener = false;
+         this.firstLoad = true;
+         historyStorage.put("DhtmlHistory_pageLoaded", true);
+      }
+      // else if this is a fake onload event
+      else {
+         this.fireOnNewListener = true;
+         this.firstLoad = false;   
+      }
+   },
+             
+   /** Adds a history change listener. Note that
+       only one listener is supported at this
+       time. */
+   /** public */ addListener: function(callback) {
+      this.listener = callback;
+      
+      // if the page was just loaded and we
+      // should not ignore it, fire an event
+      // to our new listener now
+      if (this.fireOnNewListener == true) {
+         this.fireHistoryEvent(this.currentLocation);
+         this.fireOnNewListener = false;
+      }
+   },
+   
+   /** public */ add: function(newLocation, historyData) {
+      // most browsers require that we wait a certain amount of time before changing the
+      // location, such as 200 milliseconds; rather than forcing external callers to use
+      // window.setTimeout to account for this to prevent bugs, we internally handle this
+      // detail by using a 'currentWaitTime' variable and have requests wait in line
+      var self = this;
+      var addImpl = function() {
+         // indicate that the current wait time is now less
+         if (self.currentWaitTime > 0)
+            self.currentWaitTime = self.currentWaitTime - self.WAIT_TIME;
+            
+         // remove any leading hash symbols on newLocation
+         newLocation = self.removeHash(newLocation);
+         
+         // IE has a strange bug; if the newLocation
+         // is the same as _any_ preexisting id in the
+         // document, then the history action gets recorded
+         // twice; throw a programmer exception if there is
+         // an element with this ID
+         var idCheck = $(newLocation);
+         if (idCheck != undefined || idCheck != null) {
+            var message = 
+               "Exception: History locations can not have "
+               + "the same value as _any_ id's "
+               + "that might be in the document, "
+               + "due to a bug in Internet "
+               + "Explorer; please ask the "
+               + "developer to choose a history "
+               + "location that does not match "
+               + "any HTML id's in this "
+               + "document. The following ID "
+               + "is already taken and can not "
+               + "be a location: " 
+               + newLocation;
+               
+            throw message; 
+         }
+         
+         // store the history data into history storage
+         historyStorage.put(newLocation, historyData);
+         
+         // indicate to the browser to ignore this upcomming 
+         // location change
+         self.ignoreLocationChange = true;
+ 
+         // indicate to IE that this is an atomic location change
+         // block
+         this.ieAtomicLocationChange = true;
+                 
+         // save this as our current location
+         self.currentLocation = newLocation;
+         
+         // change the browser location
+         window.location.hash = newLocation;
+         
+         // change the hidden iframe's location if on IE
+         if (self.isInternetExplorer())
+            self.iframe.src = "/blank.html?" + newLocation;
+            
+         // end of atomic location change block
+         // for IE
+         this.ieAtomicLocationChange = false;
+      };
+
+      // now execute this add request after waiting a certain amount of time, so as to
+      // queue up requests
+      window.setTimeout(addImpl, this.currentWaitTime);
+   
+      // indicate that the next request will have to wait for awhile
+      this.currentWaitTime = this.currentWaitTime + this.WAIT_TIME;
+   },
+   
+   /** public */ isFirstLoad: function() {
+      if (this.firstLoad == true) {
+         return true;
+      }
+      else {
+         return false;
+      }
+   },
+   
+   /** public */ isInternational: function() {
+      return false;
+   },
+   
+   /** public */ getVersion: function() {
+      return "0.05";
+   },
+   
+   /** Gets the current hash value that is in the browser's
+       location bar, removing leading # symbols if they are present. */
+   /** public */ getCurrentLocation: function() {
+      var currentLocation = this.removeHash(window.location.hash);
+         
+      return currentLocation;
+   },
+   
+   
+   
+   
+   
+   /** Our current hash location, without the "#" symbol. */
+   /** private */ currentLocation: null,
+   
+   /** Our history change listener. */
+   /** private */ listener: null,
+   
+   /** A hidden IFrame we use in Internet Explorer to detect history
+       changes. */
+   /** private */ iframe: null,
+   
+   /** Indicates to the browser whether to ignore location changes. */
+   /** private */ ignoreLocationChange: null,
+ 
+   /** The amount of time in milliseconds that we should wait between add requests. 
+       Firefox is okay with 200 ms, but Internet Explorer needs 400. */
+   /** private */ WAIT_TIME: 200,
+
+   /** The amount of time in milliseconds an add request has to wait in line before being
+       run on a window.setTimeout. */
+   /** private */ currentWaitTime: 0,
+   
+   /** A flag that indicates that we should fire a history change event
+       when we are ready, i.e. after we are initialized and
+       we have a history change listener. This is needed due to 
+       an edge case in browsers other than Internet Explorer; if
+       you leave a page entirely then return, we must fire this
+       as a history change event. Unfortunately, we have lost
+       all references to listeners from earlier, because JavaScript
+       clears out. */
+   /** private */ fireOnNewListener: null,
+   
+   /** A variable that indicates whether this is the first time
+       this page has been loaded. If you go to a web page, leave
+       it for another one, and then return, the page's onload
+       listener fires again. We need a way to differentiate
+       between the first page load and subsequent ones.
+       This variable works hand in hand with the pageLoaded
+       variable we store into historyStorage.*/
+   /** private */ firstLoad: null,
+   
+   /** A variable to handle an important edge case in Internet
+       Explorer. In IE, if a user manually types an address into
+       their browser's location bar, we must intercept this by
+       continiously checking the location bar with an timer 
+       interval. However, if we manually change the location
+       bar ourselves programmatically, when using our hidden
+       iframe, we need to ignore these changes. Unfortunately,
+       these changes are not atomic, so we surround them with
+       the variable 'ieAtomicLocationChange', that if true,
+       means we are programmatically setting the location and
+       should ignore this atomic chunked change. */
+   /** private */ ieAtomicLocationChange: null,          
+   
+   /** Creates the DHTML history infrastructure. */
+   /** private */ create: function() {
+      // get our initial location
+      var initialHash = this.getCurrentLocation();
+      
+      // save this as our current location
+      this.currentLocation = initialHash;
+      
+      // write out a hidden iframe for IE and
+      // set the amount of time to wait between add() requests
+      if (this.isInternetExplorer()) {
+         document.write("<iframe style='border: 0px; width: 1px; "
+                               + "height: 1px; position: absolute; bottom: 0px; "
+                               + "right: 0px; visibility: visible;' "
+                               + "name='DhtmlHistoryFrame' id='DhtmlHistoryFrame' "
+                               + "src='/blank.html?" + initialHash + "'>"
+                               + "</iframe>");
+         // wait 400 milliseconds between history
+         // updates on IE, versus 200 on Firefox
+         this.WAIT_TIME = 400;
+      }
+      
+      // add an unload listener for the page; this is
+      // needed for Firefox 1.5+ because this browser caches all
+      // dynamic updates to the page, which can break some of our 
+      // logic related to testing whether this is the first instance
+      // a page has loaded or whether it is being pulled from the cache
+      var self = this;
+      window.onunload = function() {
+         self.firstLoad = null;
+      };
+      
+      // determine if this is our first page load;
+      // for Internet Explorer, we do this in 
+      // this.iframeLoaded(), which is fired on
+      // page load. We do it there because
+      // we have no historyStorage at this point
+      // in IE, which only exists after the page
+      // is finished loading for that browser
+      if (this.isInternetExplorer() == false) {
+         if (historyStorage.hasKey("DhtmlHistory_pageLoaded") == false) {
+            this.ignoreLocationChange = true;
+            this.firstLoad = true;
+            historyStorage.put("DhtmlHistory_pageLoaded", true);
+         }
+         else {
+            // indicate that we want to pay attention
+            // to this location change
+            this.ignoreLocationChange = false;
+            // For browser's other than IE, fire
+            // a history change event; on IE,
+            // the event will be thrown automatically
+            // when it's hidden iframe reloads
+            // on page load.
+            // Unfortunately, we don't have any 
+            // listeners yet; indicate that we want
+            // to fire an event when a listener
+            // is added.
+            this.fireOnNewListener = true;
+         }
+      }
+      else { // Internet Explorer
+         // the iframe will get loaded on page
+         // load, and we want to ignore this fact
+         this.ignoreLocationChange = true;
+      }
+      
+      if (this.isInternetExplorer()) {
+            this.iframe = $("DhtmlHistoryFrame");
+      }                                                              
+
+      // other browsers can use a location handler that checks
+      // at regular intervals as their primary mechanism;
+      // we use it for Internet Explorer as well to handle
+      // an important edge case; see checkLocation() for
+      // details
+      var self = this;
+      var locationHandler = function() {
+         self.checkLocation();
+      };
+      setInterval(locationHandler, 100);
+   },
+   
+   /** Notify the listener of new history changes. */
+   /** private */ fireHistoryEvent: function(newHash) {
+      // extract the value from our history storage for
+      // this hash
+      var historyData = historyStorage.get(newHash);
+
+      // call our listener      
+      this.listener.call(null, newHash, historyData);
+   },
+   
+   /** Sees if the browsers has changed location.  This is the primary history mechanism
+       for Firefox. For Internet Explorer, we use this to handle an important edge case:
+       if a user manually types in a new hash value into their Internet Explorer location
+       bar and press enter, we want to intercept this and notify any history listener. */
+   /** private */ checkLocation: function() {
+      // ignore any location changes that we made ourselves
+      // for browsers other than Internet Explorer
+      if (this.isInternetExplorer() == false
+         && this.ignoreLocationChange == true) {
+         this.ignoreLocationChange = false;
+         return;
+      }
+      
+      // if we are dealing with Internet Explorer
+      // and we are in the middle of making a location
+      // change from an iframe, ignore it
+      if (this.isInternetExplorer() == false
+          && this.ieAtomicLocationChange == true) {
+         return;
+      }
+      
+      // get hash location
+      var hash = this.getCurrentLocation();
+      
+      // see if there has been a change
+      if (hash == this.currentLocation)
+         return;
+         
+      // on Internet Explorer, we need to intercept users manually
+      // entering locations into the browser; we do this by comparing
+      // the browsers location against the iframes location; if they
+      // differ, we are dealing with a manual event and need to
+      // place it inside our history, otherwise we can return
+      this.ieAtomicLocationChange = true;
+      
+      if (this.isInternetExplorer()
+          && this.getIFrameHash() != hash) {
+         this.iframe.src = "/blank.html?" + hash;
+      }
+      else if (this.isInternetExplorer()) {
+         // the iframe is unchanged
+         return;
+      }
+         
+      // save this new location
+      this.currentLocation = hash;
+      
+      this.ieAtomicLocationChange = false;
+      
+      // notify listeners of the change
+      this.fireHistoryEvent(hash);
+   },  
+
+   /** Gets the current location of the hidden IFrames
+       that is stored as history. For Internet Explorer. */
+   /** private */ getIFrameHash: function() {
+      // get the new location
+      var historyFrame = $("DhtmlHistoryFrame");
+      var doc = historyFrame.contentWindow.document;
+      var hash = new String(doc.location.search);
+
+      if (hash.length == 1 && hash.charAt(0) == "?")
+         hash = "";
+      else if (hash.length >= 2 && hash.charAt(0) == "?")
+         hash = hash.substring(1); 
+    
+    
+      return hash;
+   },          
+   
+   /** Removes any leading hash that might be on a location. */
+   /** private */ removeHash: function(hashValue) {
+      if (hashValue == null || hashValue == undefined)
+         return null;
+      else if (hashValue == "")
+         return "";
+      else if (hashValue.length == 1 && hashValue.charAt(0) == "#")
+         return "";
+      else if (hashValue.length > 1 && hashValue.charAt(0) == "#")
+         return hashValue.substring(1);
+      else
+         return hashValue;     
+   },          
+   
+   /** For IE, says when the hidden iframe has finished loading. */
+   /** private */ iframeLoaded: function(newLocation) {
+      // ignore any location changes that we made ourselves
+      if (this.ignoreLocationChange == true) {
+         this.ignoreLocationChange = false;
+         return;
+      }
+      
+      // get the new location
+      var hash = new String(newLocation.search);
+      if (hash.length == 1 && hash.charAt(0) == "?")
+         hash = "";
+      else if (hash.length >= 2 && hash.charAt(0) == "?")
+         hash = hash.substring(1);
+      
+      // move to this location in the browser location bar
+      // if we are not dealing with a page load event
+      if (this.pageLoadEvent != true) {
+         window.location.hash = hash;
+      }
+
+      // notify listeners of the change
+      this.fireHistoryEvent(hash);
+   },
+   
+   /** Determines if this is Internet Explorer. */
+   /** private */ isInternetExplorer: function() {
+      var userAgent = navigator.userAgent.toLowerCase();
+      if (document.all && userAgent.indexOf('msie')!=-1) {
+         return true;
+      }
+      else {
+         return false;
+      }
+   }
+};
+
+/** An object that uses a hidden form to store history state 
+    across page loads. The chief mechanism for doing so is using
+    the fact that browser's save the text in form data for the
+    life of the browser and cache, which means the text is still
+    there when the user navigates back to the page. See
+    http://codinginparadise.org/weblog/2005/08/ajax-tutorial-saving-session-across.html
+    for full details. */
+window.historyStorage = {
+   /** If true, we are debugging and show the storage textfield. */
+   /** public */ debugging: false,
+   
+   /** Our hash of key name/values. */
+   /** private */ storageHash: new Object(),
+   
+   /** If true, we have loaded our hash table out of the storage form. */
+   /** private */ hashLoaded: false, 
+   
+   /** public */ put: function(key, value) {
+       this.assertValidKey(key);
+       
+       // if we already have a value for this,
+       // remove the value before adding the
+       // new one
+       if (this.hasKey(key)) {
+         this.remove(key);
+       }
+       
+       // store this new key
+       this.storageHash[key] = value;
+       
+       // save and serialize the hashtable into the form
+       this.saveHashTable(); 
+   },
+   
+   /** public */ get: function(key) {
+      this.assertValidKey(key);
+      
+      // make sure the hash table has been loaded
+      // from the form
+      this.loadHashTable();
+      
+      var value = this.storageHash[key];
+
+      if (value == undefined)
+         return null;
+      else
+         return value; 
+   },
+   
+   /** public */ remove: function(key) {
+      this.assertValidKey(key);
+      
+      // make sure the hash table has been loaded
+      // from the form
+      this.loadHashTable();
+      
+      // delete the value
+      delete this.storageHash[key];
+      
+      // serialize and save the hash table into the 
+      // form
+      this.saveHashTable();
+   },
+   
+   /** Clears out all saved data. */
+   /** public */ reset: function() {
+      this.storageField.value = "";
+      this.storageHash = new Object();
+   },
+   
+   /** public */ hasKey: function(key) {
+      this.assertValidKey(key);
+      
+      // make sure the hash table has been loaded
+      // from the form
+      this.loadHashTable();
+      
+      if (typeof this.storageHash[key] == "undefined")
+         return false;
+      else
+         return true;
+   },
+   
+   /** public */ isValidKey: function(key) {
+      // allow all strings, since we don't use XML serialization
+      // format anymore
+      return (typeof key == "string");
+   },   
+   
+   /** A reference to our textarea field. */
+   /** private */ storageField: null,
+   
+   /** private */ init: function() {
+      // write a hidden form into the page      
+      var newContent = "<div id='historyStorageFieldFormDiv' style='display:none;'><form id='historyStorageFieldForm'>"+
+							         "<input type='textarea' id='historyStorageField' name='historyStorageField'/></form></div>";
+      document.write(newContent);
+      
+      this.storageField = $("historyStorageField");
+   },
+   
+   /** Asserts that a key is valid, throwing
+       an exception if it is not. */
+   /** private */ assertValidKey: function(key) {
+      if (this.isValidKey(key) == false) {
+         throw "Please provide a valid key for "
+               + "window.historyStorage, key= "
+               + key;
+       }
+   },
+   
+   /** Loads the hash table up from the form. */
+   /** private */ loadHashTable: function() {
+      if (this.hashLoaded == false) {
+         // get the hash table as a serialized
+         // string
+         var serializedHashTable = this.storageField.value;
+         
+         if (serializedHashTable != "" &&
+             serializedHashTable != null) {
+            // destringify the content back into a 
+            // real JavaScript object
+            this.storageHash = eval('(' + serializedHashTable + ')');  
+         }
+         
+         this.hashLoaded = true;
+      }
+   },
+   
+   /** Saves the hash table into the form. */
+   /** private */ saveHashTable: function() {
+      this.loadHashTable();
+      
+      // serialized the hash table
+      var serializedHashTable = JSON.stringify(this.storageHash);
+      
+      // save this value
+      this.storageField.value = serializedHashTable;
+   }   
+};
+
+/** The JSON class is copyright 2005 JSON.org. */
+Array.prototype.______array = '______array';
+
+var JSON = {
+    org: 'http://www.JSON.org',
+    copyright: '(c)2005 JSON.org',
+    license: 'http://www.crockford.com/JSON/license.html',
+
+    stringify: function (arg) {
+        var c, i, l, s = '', v;
+
+        switch (typeof arg) {
+        case 'object':
+            if (arg) {
+                if (arg.______array == '______array') {
+                    for (i = 0; i < arg.length; ++i) {
+                        v = this.stringify(arg[i]);
+                        if (s) {
+                            s += ',';
+                        }
+                        s += v;
+                    }
+                    return '[' + s + ']';
+                } else if (typeof arg.toString != 'undefined') {
+                    for (i in arg) {
+                        v = arg[i];
+                        if (typeof v != 'undefined' && typeof v != 'function') {
+                            v = this.stringify(v);
+                            if (s) {
+                                s += ',';
+                            }
+                            s += this.stringify(i) + ':' + v;
+                        }
+                    }
+                    return '{' + s + '}';
+                }
+            }
+            return 'null';
+        case 'number':
+            return isFinite(arg) ? String(arg) : 'null';
+        case 'string':
+            l = arg.length;
+            s = '"';
+            for (i = 0; i < l; i += 1) {
+                c = arg.charAt(i);
+                if (c >= ' ') {
+                    if (c == '\\' || c == '"') {
+                        s += '\\';
+                    }
+                    s += c;
+                } else {
+                    switch (c) {
+                        case '\b':
+                            s += '\\b';
+                            break;
+                        case '\f':
+                            s += '\\f';
+                            break;
+                        case '\n':
+                            s += '\\n';
+                            break;
+                        case '\r':
+                            s += '\\r';
+                            break;
+                        case '\t':
+                            s += '\\t';
+                            break;
+                        default:
+                            c = c.charCodeAt();
+                            s += '\\u00' + Math.floor(c / 16).toString(16) +
+                                (c % 16).toString(16);
+                    }
+                }
+            }
+            return s + '"';
+        case 'boolean':
+            return String(arg);
+        default:
+            return 'null';
+        }
+    },
+    parse: function (text) {
+        var at = 0;
+        var ch = ' ';
+
+        function error(m) {
+            throw {
+                name: 'JSONError',
+                message: m,
+                at: at - 1,
+                text: text
+            };
+        }
+
+        function next() {
+            ch = text.charAt(at);
+            at += 1;
+            return ch;
+        }
+
+        function white() {
+            while (ch != '' && ch <= ' ') {
+                next();
+            }
+        }
+
+        function str() {
+            var i, s = '', t, u;
+
+            if (ch == '"') {
+outer:          while (next()) {
+                    if (ch == '"') {
+                        next();
+                        return s;
+                    } else if (ch == '\\') {
+                        switch (next()) {
+                        case 'b':
+                            s += '\b';
+                            break;
+                        case 'f':
+                            s += '\f';
+                            break;
+                        case 'n':
+                            s += '\n';
+                            break;
+                        case 'r':
+                            s += '\r';
+                            break;
+                        case 't':
+                            s += '\t';
+                            break;
+                        case 'u':
+                            u = 0;
+                            for (i = 0; i < 4; i += 1) {
+                                t = parseInt(next(), 16);
+                                if (!isFinite(t)) {
+                                    break outer;
+                                }
+                                u = u * 16 + t;
+                            }
+                            s += String.fromCharCode(u);
+                            break;
+                        default:
+                            s += ch;
+                        }
+                    } else {
+                        s += ch;
+                    }
+                }
+            }
+            error("Bad string");
+        }
+
+        function arr() {
+            var a = [];
+
+            if (ch == '[') {
+                next();
+                white();
+                if (ch == ']') {
+                    next();
+                    return a;
+                }
+                while (ch) {
+                    a.push(val());
+                    white();
+                    if (ch == ']') {
+                        next();
+                        return a;
+                    } else if (ch != ',') {
+                        break;
+                    }
+                    next();
+                    white();
+                }
+            }
+            error("Bad array");
+        }
+
+        function obj() {
+            var k, o = {};
+
+            if (ch == '{') {
+                next();
+                white();
+                if (ch == '}') {
+                    next();
+                    return o;
+                }
+                while (ch) {
+                    k = str();
+                    white();
+                    if (ch != ':') {
+                        break;
+                    }
+                    next();
+                    o[k] = val();
+                    white();
+                    if (ch == '}') {
+                        next();
+                        return o;
+                    } else if (ch != ',') {
+                        break;
+                    }
+                    next();
+                    white();
+                }
+            }
+            error("Bad object");
+        }
+
+        function num() {
+            var n = '', v;
+            if (ch == '-') {
+                n = '-';
+                next();
+            }
+            while (ch >= '0' && ch <= '9') {
+                n += ch;
+                next();
+            }
+            if (ch == '.') {
+                n += '.';
+                while (next() && ch >= '0' && ch <= '9') {
+                    n += ch;
+                }
+            }
+            if (ch == 'e' || ch == 'E') {
+                n += 'e';
+                next();
+                if (ch == '-' || ch == '+') {
+                    n += ch;
+                    next();
+                }
+                while (ch >= '0' && ch <= '9') {
+                    n += ch;
+                    next();
+                }
+            }
+            v = +n;
+            if (!isFinite(v)) {
+                error("Bad number");
+            } else {
+                return v;
+            }
+        }
+
+        function word() {
+            switch (ch) {
+                case 't':
+                    if (next() == 'r' && next() == 'u' && next() == 'e') {
+                        next();
+                        return true;
+                    }
+                    break;
+                case 'f':
+                    if (next() == 'a' && next() == 'l' && next() == 's' &&
+                            next() == 'e') {
+                        next();
+                        return false;
+                    }
+                    break;
+                case 'n':
+                    if (next() == 'u' && next() == 'l' && next() == 'l') {
+                        next();
+                        return null;
+                    }
+                    break;
+            }
+            error("Syntax error");
+        }
+
+        function val() {
+            white();
+            switch (ch) {
+                case '{':
+                    return obj();
+                case '[':
+                    return arr();
+                case '"':
+                    return str();
+                case '-':
+                    return num();
+                default:
+                    return ch >= '0' && ch <= '9' ? num() : word();
+            }
+        }
+
+        return val();
+    }
+};
+
+/** QueryString Object from http://adamv.com/dev/javascript/querystring */
+/* Client-side access to querystring name=value pairs
+	Version 1.2.3
+	22 Jun 2005
+	Adam Vandenberg
+*/
+function Querystring(qs) { // optionally pass a querystring to parse
+	this.params = new Object()
+	this.get=Querystring_get
+	
+	if (qs == null)
+		qs=location.search.substring(1,location.search.length)
+
+	if (qs.length == 0) return
+
+// Turn <plus> back to <space>
+// See: http://www.w3.org/TR/REC-html40/interact/forms.html#h-17.13.4.1
+	qs = qs.replace(/\+/g, ' ')
+	// added by Scott Rutherford, change all &amp; to &
+	qs = qs.replace(/&amp;/g, '&')
+	var args = qs.split('&') // parse out name/value pairs separated via &
+	
+// split out each name=value pair
+	for (var i=0;i<args.length;i++) {
+		var value;
+		var pair = args[i].split('=')
+		var name = unescape(pair[0])
+
+		if (pair.length == 2)
+			value = unescape(pair[1])
+		else
+			value = name
+		
+		this.params[name] = value
+	}
+}
+
+function Querystring_get(key, default_) {
+	// This silly looking line changes UNDEFINED to NULL
+	if (default_ == null) default_ = null;
+	
+	var value=this.params[key]
+	if (value==null) value=default_;
+	
+	return value
+}
+
+/** ADDED BY SCOTT RUTHERFORD, COMINDED July 2006 scott@cominded */
+/** Initialize all of our objects now. */
+window.historyStorage.init();
+window.dhtmlHistory.create();
+
+/** Create init methods for ajax_table */
+function initialize() {
+       // initialize our DHTML history
+       dhtmlHistory.initialize();
+       // subscribe to DHTML history change
+       // events
+       dhtmlHistory.addListener(handleHistoryChange);        
+}
+    
+/** Our callback to receive history 
+    change events. */
+function handleHistoryChange(pageId, pageData) {
+			 //alert(pageData)
+			 var info = pageId.split(':');
+			 var id = info[0];
+       new Ajax.Updater(id+'-content', pageData, {asynchronous:true, evalScripts:true, onLoading:function(request){Element.show(id+'-pagination-loading-indicator');}});
+}
+    
+function debugMsg(msg) {
+       var debugMsg = $("debugMsg");
+       debugMsg.innerHTML = msg;
+}
+
+function addAjaxTableUrlToHistory(url) {
+	var array = url.split('?');
+	var qs = new Querystring(array[1]);
+	var sort = qs.get('sort')
+	var dir = qs.get('sort_direction')
+	dhtmlHistory.add(qs.get('scaffold_id')+":"+qs.get('page')+":"+sort+":"+dir, url);
+}
+
+/** set onload handler */
+Event.observe(window, 'load', initialize, false);
+
+
+
+
+
+