blacklight 3.0pre1

data/lib/generators/blacklight/templates/config/blacklight_config.rb

@@ -0,0 +1,245 @@
+# You can configure Blacklight from here. 
+#   
+#   Blacklight.configure(:environment) do |config| end
+#   
+# :shared (or leave it blank) is used by all environments. 
+# You can override a shared key by using that key in a particular
+# environment's configuration.
+# 
+# If you have no configuration beyond :shared for an environment, you
+# do not need to call configure() for that envirnoment.
+# 
+# For specific environments:
+# 
+#   Blacklight.configure(:test) {}
+#   Blacklight.configure(:development) {}
+#   Blacklight.configure(:production) {}
+# 
+
+Blacklight.configure(:shared) do |config|
+
+  config[:default_solr_params] = {
+    :qt => "search",
+    :per_page => 10 
+  }
+ 
+  # solr field values given special treatment in the show (single result) view
+  config[:show] = {
+    :html_title => "title_display",
+    :heading => "title_display",
+    :display_type => "format"
+  }
+
+  # solr fld values given special treatment in the index (search results) view
+  config[:index] = {
+    :show_link => "title_display",
+    :record_display_type => "format"
+  }
+
+  # solr fields that will be treated as facets by the blacklight application
+  #   The ordering of the field names is the order of the display
+  # TODO: Reorganize facet data structures supplied in config to make simpler
+  # for human reading/writing, kind of like search_fields. Eg,
+  # config[:facet] << {:field_name => "format", :label => "Format", :limit => 10}
+  config[:facet] = {
+    :field_names => (facet_fields = [
+      "format",
+      "pub_date",
+      "subject_topic_facet",
+      "language_facet",
+      "lc_1letter_facet",
+      "subject_geo_facet",
+      "subject_era_facet"
+    ]),
+    :labels => {
+      "format"              => "Format",
+      "pub_date"            => "Publication Year",
+      "subject_topic_facet" => "Topic",
+      "language_facet"      => "Language",
+      "lc_1letter_facet"    => "Call Number",
+      "subject_era_facet"   => "Era",
+      "subject_geo_facet"   => "Region"
+    },
+    # Setting a limit will trigger Blacklight's 'more' facet values link.
+    # * If left unset, then all facet values returned by solr will be displayed.
+    # * If set to an integer, then "f.somefield.facet.limit" will be added to
+    # solr request, with actual solr request being +1 your configured limit --
+    # you configure the number of items you actually want _displayed_ in a page.    
+    # * If set to 'true', then no additional parameters will be sent to solr,
+    # but any 'sniffed' request limit parameters will be used for paging, with
+    # paging at requested limit -1. Can sniff from facet.limit or 
+    # f.specific_field.facet.limit solr request params. This 'true' config
+    # can be used if you set limits in :default_solr_params, or as defaults
+    # on the solr side in the request handler itself. Request handler defaults
+    # sniffing requires solr requests to be made with "echoParams=all", for
+    # app code to actually have it echo'd back to see it.     
+    :limits => {
+      "subject_topic_facet" => 20,
+      "language_facet" => true
+    }
+  }
+
+  # Have BL send all facet field names to Solr, which has been the default
+  # previously. Simply remove these lines if you'd rather use Solr request
+  # handler defaults, or have no facets.
+  config[:default_solr_params] ||= {}
+  config[:default_solr_params][:"facet.field"] = facet_fields
+
+  # solr fields to be displayed in the index (search results) view
+  #   The ordering of the field names is the order of the display 
+  config[:index_fields] = {
+    :field_names => [
+      "title_display",
+      "title_vern_display",
+      "author_display",
+      "author_vern_display",
+      "format",
+      "language_facet",
+      "published_display",
+      "published_vern_display",
+      "lc_callnum_display"
+    ],
+    :labels => {
+      "title_display"           => "Title:",
+      "title_vern_display"      => "Title:",
+      "author_display"          => "Author:",
+      "author_vern_display"     => "Author:",
+      "format"                  => "Format:",
+      "language_facet"          => "Language:",
+      "published_display"       => "Published:",
+      "published_vern_display"  => "Published:",
+      "lc_callnum_display"      => "Call number:"
+    }
+  }
+
+  # solr fields to be displayed in the show (single result) view
+  #   The ordering of the field names is the order of the display 
+  config[:show_fields] = {
+    :field_names => [
+      "title_display",
+      "title_vern_display",
+      "subtitle_display",
+      "subtitle_vern_display",
+      "author_display",
+      "author_vern_display",
+      "format",
+      "url_fulltext_display",
+      "url_suppl_display",
+      "material_type_display",
+      "language_facet",
+      "published_display",
+      "published_vern_display",
+      "lc_callnum_display",
+      "isbn_t"
+    ],
+    :labels => {
+      "title_display"           => "Title:",
+      "title_vern_display"      => "Title:",
+      "subtitle_display"        => "Subtitle:",
+      "subtitle_vern_display"   => "Subtitle:",
+      "author_display"          => "Author:",
+      "author_vern_display"     => "Author:",
+      "format"                  => "Format:",
+      "url_fulltext_display"    => "URL:",
+      "url_suppl_display"       => "More Information:",
+      "material_type_display"   => "Physical description:",
+      "language_facet"          => "Language:",
+      "published_display"       => "Published:",
+      "published_vern_display"  => "Published:",
+      "lc_callnum_display"      => "Call number:",
+      "isbn_t"                  => "ISBN:"
+    }
+  }
+
+
+  # "fielded" search configuration. Used by pulldown among other places.
+  # For supported keys in hash, see rdoc for Blacklight::SearchFields
+  #
+  # Search fields will inherit the :qt solr request handler from
+  # config[:default_solr_parameters], OR can specify a different one
+  # with a :qt key/value. Below examples inherit, except for subject
+  # that specifies the same :qt as default for our own internal
+  # testing purposes.
+  #
+  # The :key is what will be used to identify this BL search field internally,
+  # as well as in URLs -- so changing it after deployment may break bookmarked
+  # urls.  A display label will be automatically calculated from the :key,
+  # or can be specified manually to be different. 
+  config[:search_fields] ||= []
+
+  # This one uses all the defaults set by the solr request handler. Which
+  # solr request handler? The one set in config[:default_solr_parameters][:qt],
+  # since we aren't specifying it otherwise. 
+  config[:search_fields] << {
+    :key => "all_fields",  
+    :display_label => 'All Fields'   
+  }
+
+  # Now we see how to over-ride Solr request handler defaults, in this
+  # case for a BL "search field", which is really a dismax aggregate
+  # of Solr search fields. 
+  config[:search_fields] << {
+    :key => 'title',     
+    # solr_parameters hash are sent to Solr as ordinary url query params. 
+    :solr_parameters => {
+      :"spellcheck.dictionary" => "title"
+    },
+    # :solr_local_parameters will be sent using Solr LocalParams
+    # syntax, as eg {! qf=$title_qf }. This is neccesary to use
+    # Solr parameter de-referencing like $title_qf.
+    # See: http://wiki.apache.org/solr/LocalParams
+    :solr_local_parameters => {
+      :qf => "$title_qf",
+      :pf => "$title_pf"
+    }
+  }
+  config[:search_fields] << {
+    :key =>'author',     
+    :solr_parameters => {
+      :"spellcheck.dictionary" => "author" 
+    },
+    :solr_local_parameters => {
+      :qf => "$author_qf",
+      :pf => "$author_pf"
+    }
+  }
+
+  # Specifying a :qt only to show it's possible, and so our internal automated
+  # tests can test it. In this case it's the same as 
+  # config[:default_solr_parameters][:qt], so isn't actually neccesary. 
+  config[:search_fields] << {
+    :key => 'subject', 
+    :qt=> 'search',
+    :solr_parameters => {
+      :"spellcheck.dictionary" => "subject"
+    },
+    :solr_local_parameters => {
+      :qf => "$subject_qf",
+      :pf => "$subject_pf"
+    }
+  }
+  
+  # "sort results by" select (pulldown)
+  # label in pulldown is followed by the name of the SOLR field to sort by and
+  # whether the sort is ascending or descending (it must be asc or desc
+  # except in the relevancy case).
+  # label is key, solr field is value
+  config[:sort_fields] ||= []
+  config[:sort_fields] << ['relevance', 'score desc, pub_date_sort desc, title_sort asc']
+  config[:sort_fields] << ['year', 'pub_date_sort desc, title_sort asc']
+  config[:sort_fields] << ['author', 'author_sort asc, title_sort asc']
+  config[:sort_fields] << ['title', 'title_sort asc, pub_date_sort desc']
+  
+  # If there are more than this many search results, no spelling ("did you 
+  # mean") suggestion is offered.
+  config[:spell_max] = 5
+
+  # Add documents to the list of object formats that are supported for all objects.
+  # This parameter is a hash, identical to the Blacklight::Solr::Document#export_formats 
+  # output; keys are format short-names that can be exported. Hash includes:
+  #    :content-type => mime-content-type
+  config[:unapi] = {
+    'oai_dc_xml' => { :content_type => 'text/xml' } 
+  }
+end
+

data/lib/generators/blacklight/templates/config/solr.yml

@@ -0,0 +1,6 @@
+development:
+  url: http://127.0.0.1:8983/solr
+test:
+  url: http://127.0.0.1:8888/solr
+cucumber:
+  url: http://127.0.0.1:8888/solr

data/lib/generators/blacklight/templates/migrations/add_user_types_to_bookmarks_searches.rb

@@ -0,0 +1,11 @@
+class AddUserTypesToBookmarksSearches < ActiveRecord::Migration
+  def self.up
+    add_column :searches, :user_type, :string
+    add_column :bookmarks, :user_type, :string
+  end
+
+  def self.down
+    remove_column :searches, :user_type, :string
+    remove_column :bookmarks, :user_type, :string
+  end
+end

data/lib/generators/blacklight/templates/migrations/create_bookmarks.rb

@@ -0,0 +1,17 @@
+class CreateBookmarks < ActiveRecord::Migration
+  def self.up
+    create_table :bookmarks do |t|
+      t.integer :user_id, :null=>false
+      t.text :url
+      t.string :document_id
+      t.string :title
+      t.text :notes
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :bookmarks
+  end
+  
+end

data/lib/generators/blacklight/templates/migrations/create_searches.rb

@@ -0,0 +1,15 @@
+class CreateSearches < ActiveRecord::Migration
+  def self.up
+    create_table :searches do |t|
+      t.text  :query_params
+      t.integer :user_id
+
+      t.timestamps
+    end
+    add_index :searches, :user_id
+  end
+
+  def self.down
+    drop_table :searches
+  end
+end

data/lib/generators/blacklight/templates/migrations/remove_editable_fields_from_bookmarks.rb

@@ -0,0 +1,11 @@
+class RemoveEditableFieldsFromBookmarks < ActiveRecord::Migration
+  def self.up
+    remove_column :bookmarks, :notes
+    remove_column :bookmarks, :url
+  end
+
+  def self.down
+    add_column :bookmarks, :notes, :text
+    add_column :bookmarks, :url, :string
+  end
+end

data/lib/generators/blacklight/templates/public/javascripts/blacklight.js

@@ -0,0 +1,485 @@
+/* Blacklight has a Javascript setup meant to support local disabling, 
+  modification, and use of Blacklight behaviors. 
+  
+  There is a global Blacklight object, available to your local JS. 
+  
+  Individual logic to apply JS behaviors to particular elements is 
+  stored in functions on that Blacklight object. 
+  
+  The actual behaviors themselves are implemented as JQuery plugins, 
+  JQuery-UI widgets (a special kind of JQuery plugin), or in some cases
+  just as logic in the Blacklight global object. 
+  
+  All of these things can be modified by your local JS code -- these functions
+  are all set up on js load, and only called on document ready, so do your
+  modifications just on js load, and they'll be made by the time document ready
+  comes along. 
+  
+  Examples, in your application's own JS:
+  
+    Change what items zebra_striping gets applied to:
+    
+        Blacklight.do_zebra_stripe.selector = ".my_class .even";
+        //Or even add on to existing:
+        Blacklight.do_zebra_stripe.selector = Blacklight.do_zebra_stripe.selector + " .my_class .even";
+      
+    Turn off adding of behavior to facet 'more' links, using a no-op function:
+    
+        Blacklight.do_more_facets_behavior = function() {};
+        
+    Change the implementation of facet 'more' link behavior to use entirely
+    different JS. 
+    
+        Blacklight.do_more_facets_behavior = function() {
+          $(Blacklight.do_more_facets_behavior.selector).each(function() {
+            //my own thing!
+          });
+        };
+*/
+
+Blacklight = {};
+
+
+$(document).ready(function() {
+  Blacklight.do_zebra_stripe();  
+  
+  Blacklight.do_select_submit();
+  
+  Blacklight.do_more_facets_behavior();
+  
+  Blacklight.do_lightbox_dialog();
+  
+  Blacklight.do_bookmark_toggle_behavior();
+  
+  Blacklight.do_folder_toggle_behavior();       
+  
+  Blacklight.do_facet_expand_contract_behavior();
+});
+
+
+
+//Note all of these definitions are NOT in document ready, they get defined on
+//page load, and later called on document ready. 
+(function($) {
+    
+    // adds classes for zebra striping table rows
+    Blacklight.do_zebra_stripe = function() {  
+      $(Blacklight.do_zebra_stripe.selector).addClass('zebra_stripe');        
+    };
+    Blacklight.do_zebra_stripe.selector = "table.zebra tr:even, ul.zebra li:even"; 
+    
+    //add ajaxy dialogs to certain links, using the ajaxyDialog widget.
+    Blacklight.do_more_facets_behavior = function () {
+      $( Blacklight.do_more_facets_behavior.selector ).ajaxyDialog({
+          width: $(window).width() / 2,  
+          chainAjaxySelector: "a.next_page, a.prev_page, a.sort_change"        
+      });
+    };
+    Blacklight.do_more_facets_behavior.selector = "a.more_facets_link";
+    
+    // Used for sort-by and per-page controls, hide the submit button
+    // and make the select auto-submit
+    Blacklight.do_select_submit = function() {
+      $(Blacklight.do_select_submit.selector).each(function() {
+          var select = $(this);
+          select.closest("form").find("input[type=submit]").hide();
+          select.bind("change", function() {
+              this.form.submit();
+          });
+      });
+    };
+    Blacklight.do_select_submit.selector = "form.sort select, form.per_page select";
+    
+    
+    Blacklight.do_lightbox_dialog = function() {    
+      $("a.lightboxLink").ajaxyDialog({
+          chainAjaxySelector: false
+      });
+      //But make the librarian link wider than 300px default. 
+      $('a.lightboxLink#librarianLink').ajaxyDialog("option", "width", 650);
+      //And the email one too needs to be wider to fit the textarea
+      $("a.lightboxLink#emailLink").ajaxyDialog("option", "width", 500);
+    };
+    
+    //change form submit toggle to checkbox
+    Blacklight.do_bookmark_toggle_behavior = function() {
+      $(Blacklight.do_bookmark_toggle_behavior.selector).bl_checkbox_submit({          
+          checked_label: "In Bookmarks",
+          unchecked_label: "Bookmark",
+          progress_label: "Saving...",
+          //css_class is added to elements added, plus used for id base
+          css_class: "toggle_bookmark"    
+      }); 
+    };
+    Blacklight.do_bookmark_toggle_behavior.selector = "form.bookmark_toggle"; 
+
+    Blacklight.do_folder_toggle_behavior = function() {
+      $( Blacklight.do_folder_toggle_behavior.selector ).bl_checkbox_submit({
+          checked_label: "Selected",
+          unchecked_label: "Select",
+          css_class: "toggle_folder",
+          success: function(new_state) {
+            
+            if (new_state) {
+               $("#folder_number").text(parseInt($("#folder_number").text()) + 1);
+            }
+            else {
+               $("#folder_number").text(parseInt($("#folder_number").text()) - 1);
+            }
+          }
+      });
+    };
+    Blacklight.do_folder_toggle_behavior.selector = "form.folder_toggle"; 
+    
+    Blacklight.do_facet_expand_contract_behavior = function() {
+      $( Blacklight.do_facet_expand_contract_behavior.selector ).each (
+          Blacklight.facet_expand_contract
+       );
+    }
+    Blacklight.do_facet_expand_contract_behavior.selector = '#facets h3';
+    	    
+	    /* Behavior that makes facet limit headings in sidebar expand/contract
+	       their contents. This is kind of fragile code targeted specifically
+	       at how we currently render facet HTML, which is why I put it in a function
+	       on Blacklight instead of in a jquery plugin. Perhaps in the future this
+	       could/should be expanded to a general purpose jquery plugin -- or
+	       we should just use one of the existing ones for expand/contract? */
+     Blacklight.facet_expand_contract = function() {
+       $(this).next("ul, div").each(function(){
+           var f_content = $(this);
+           $(f_content).prev('h3').addClass('twiddle');
+           // find all f_content's that don't have any span descendants with a class of "selected"
+           if($('span.selected', f_content).length == 0){
+             // hide it
+             f_content.hide();
+           } else {
+             $(this).prev('h3').addClass('twiddle-open');
+           }
+
+           // attach the toggle behavior to the h3 tag
+           $('h3', f_content.parent()).click(function(){
+               // toggle the content
+               $(this).toggleClass('twiddle-open');
+               $(f_content).slideToggle();
+           });
+       });
+   };
+    
+})(jQuery);
+
+
+
+
+
+
+/* A JQuery plugin (should this be implemented as a widget instead? not sure)
+   that will convert a "toggle" form, with single submit button to add/remove
+   something, like used for Bookmarks/Folder, into an AJAXy checkbox instead. 
+   
+   Apply to a form. Does require certain assumption about the form:
+    1) The same form 'action' href must be used for both ADD and REMOVE
+       actions, with the different being the hidden input name="_method"
+       being set to "put" or "delete" -- that's the Rails method to pretend
+       to be doing a certain HTTP verb. So same URL, PUT to add, DELETE
+       to remove. This plugin assumes that. 
+       
+       Plus, the form this is applied to should provide a data-doc-id 
+       attribute (HTML5-style doc-*) that contains the id/primary key
+       of the object in question -- used by plugin for a unique value for
+       DOM id's. 
+       
+   Pass in options for your class name and labels:
+   $("form.something").bl_checkbox_submit({    
+        checked_label: "Selected",
+        unchecked_label: "Select",
+        progress_label: "Saving...",
+        //css_class is added to elements added, plus used for id base
+        css_class: "toggle_my_kinda_form",
+        success: function(after_success_check_state) {
+          #optional callback
+        }
+   });
+*/
+(function($) {    
+    $.fn.bl_checkbox_submit = function(arg_opts) {              
+      
+      this.each(function() {
+        var options = $.extend({}, $.fn.bl_checkbox_submit.defaults, arg_opts);
+                                  
+          
+        var form = $(this);
+        form.children().hide();
+        //We're going to use the existing form to actually send our add/removes
+        //This works conveneintly because the exact same action href is used
+        //for both bookmarks/$doc_id.  But let's take out the irrelevant parts
+        //of the form to avoid any future confusion. 
+        form.find("input[type=submit]").remove();
+        
+        //View needs to set data-doc-id so we know a unique value
+        //for making DOM id
+        var unique_id = form.attr("data-doc-id") || Math.random();
+        // if form is currently using method delete to change state, 
+        // then checkbox is currently checked
+        var checked = (form.find("input[name=_method][value=delete]").size() != 0);
+            
+        var checkbox = $('<input type="checkbox">')	    
+          .addClass( options.css_class )
+          .attr("id", options.css_class + "_" + unique_id);	  
+        var label = $('<label>')
+          .addClass( options.css_class )
+          .attr("for", options.css_class + '_' + unique_id)
+          .attr("title", form.attr("title"));
+          
+          
+        function update_state_for(state) {
+            checkbox.attr("checked", state);
+            label.toggleClass("checked", state);
+            if (state) {    
+               //Set the Rails hidden field that fakes an HTTP verb
+               //properly for current state action. 
+               form.find("input[name=_method]").val("delete");
+               label.text(options.checked_label);
+            } else {
+               form.find("input[name=_method]").val("put");
+               label.text(options.unchecked_label);
+            }
+          }
+        
+        form.append(checkbox).append(" ").append(label);
+        update_state_for(checked);
+        
+        checkbox.click(function() {
+            label.text(options.progress_label).attr("disabled", "disabled");  
+            checkbox.attr("disabled", "disabled");
+                            
+            $.ajax({
+                url: form.attr("action"),
+                type: form.attr("method").toUpperCase(),
+                data: form.serialize(),
+                error: function() {
+                   alert("Error");
+                   update_state_for(checked);
+                   label.removeAttr("disabled");
+                   checkbox.removeAttr("disabled");
+                },
+                success: function(data, status, xhr) {
+                  //if app isn't running at all, xhr annoyingly
+                  //reports success with status 0. 
+                  if (xhr.status != 0) {
+                    checked = ! checked;
+                    update_state_for(checked);
+                    label.removeAttr("disabled");
+                    checkbox.removeAttr("disabled");
+                    options.success.call(form, checked);
+                  } else {
+                    alert("Error");
+                    update_state_for(checked);
+                    label.removeAttr("disabled");
+                    checkbox.removeAttr("disabled");
+                  }
+                }
+            });
+            
+            return false;
+        }); //checkbox.click
+        
+        
+      }); //this.each      
+      return this;
+    };
+	
+  $.fn.bl_checkbox_submit.defaults =  {
+            checked_label: "",
+            unchecked_label: "",
+            progress_label: "Saving...",
+            //css_class is added to elements added, plus used for id base
+            css_class: "bl_checkbox_submit",
+            success: function() {} //callback
+  };
+    
+})(jQuery);
+
+      
+/* A widget written by jrochkind to make a link or form result in
+   an in-window ajaxy dialog, instead of page load, using JQuery UI
+   Dialog widget. 
+      
+   This widget is actually hosted at: https://github.com/jrochkind/jquery.uiExt.ajaxyDialog
+   
+   
+   Included in this main file because I just couldn't bare to add yet
+   another JS file to our app, until we figure out a good fix those too
+   many JS files are serious page load speed problem. */ 
+
+      (function($) {
+          var widgetNamespace = "uiExt";
+          var widgetName = "ajaxyDialog";
+          
+          $.widget(widgetNamespace + "." + widgetName, {
+              options: {
+                  extractTitleSelector: "h1, h2, h3, h4, h5",
+                  chainAjaxySelector: "a:not([target]), form:not([target])",
+                  closeDialogSelector: "a.dialog-close"
+              },
+              
+              _create: function() {
+                  var self = this;
+                  var element = self.element[0];
+                  if (element.tagName.toUpperCase() == "A") {
+                    $(element).bind("click."+self.widgetName,  function(event, ui) {                        
+                        self._handleClick(); 
+                        return false;
+                    });
+                  }
+                  else if (element.tagName.toUpperCase() == "FORM") {
+                    $(element).bind("submit."+self.widgetName,  function(event, ui) {
+                        self._handleSubmit();
+                        return false;
+                    });
+                  }                
+              },
+                        
+              open: function() {
+                var self = this;
+                var element = self.element[0];                                
+                                
+                if ( element.tagName.toUpperCase() == "A") {
+                  self._handleClick();
+                } else if (element.tagName.toUpperCase() == "FORM") {
+                  self._handleSubmit();
+                }
+              },
+              
+              close: function() {
+                this.dialogContainer().dialog("close"); 
+              },                            
+              
+              _handleClick: function() {
+                  var self = this;
+                  var url = this.element.attr("href");
+                  var requestDialog = self.dialogContainer();
+            
+                  $("body").css("cursor", "progress");
+            
+                  $.ajax({
+                      url: url,
+                      dataType: "html",
+                      success: function(resp, status, xhr) {
+                        if (xhr.status != 0) {                          
+                          self._loadToDialog(resp);
+                        } else {
+                          //stupid jquery calling this 'success', it's
+                          //network unavailable.
+                          self._displayFailure(url, xhr, status); 
+                        }
+                      },
+                      error: function(xhr, msg) {
+                        self._displayFailure(url, xhr, msg); 
+                      }
+                  });                                
+              },
+              
+              _handleSubmit: function() {
+                  var self = this;
+                  var form = self.element;
+                  var actionUri = form.attr("action");
+                  var serialized = form.serialize();
+            
+                  $("body").css("cursor", "progress");
+            
+                  $.ajax({
+                      url: actionUri,
+                      data: serialized,
+                      type: form.attr("method").toUpperCase(),
+                      dataType: "html",
+                      success: function(resp, status, xhr) {
+                        if (xhr.status != 0) {
+                          self._loadToDialog(resp);
+                        } else {
+                          //stupid jquery calling this 'success', it's
+                          //network unavailable.
+                          self._displayFailure(url, xhr, status); 
+                        }
+                      },
+                      error: function(xhr, msg) {
+                        self._displayFailure(actionUri, xhr, msg); 
+                      }
+                  });
+              },
+              
+              _loadToDialog: function(html_content) {     
+                  var self = this;
+                  var dialog = self.dialogContainer();
+                  //Cheesy way to restore it to it's default options, plus
+                  //our own local options, since its' a reuseable dialog.
+                  //for now we insist on modal:true. 
+                  dialog.dialog($.extend({}, 
+                                  $.ui.dialog.prototype.options, 
+                                  self.options, 
+                                  {autoOpen:false, modal:true}
+                                ));
+                                    
+                  if (self._trigger('beforeDisplay', 0, html_content) !== false) {                  
+                    dialog.html( html_content );
+            
+                    //extract and set title
+                    var title;
+                    self.options.extractTitleSelector &&
+                      (title = dialog.find(self.options.extractTitleSelector).first().remove().text());                  
+                    title = title || 
+                      self.element.attr("title")
+                    title && dialog.dialog("option", "title", title);
+                                
+                    //Make any hyperlinks or forms ajaxified, by applying
+                    //this very same plugin to em, and passing on our options.  
+                    if (self.options.chainAjaxySelector) {
+                      dialog.find(self.options.chainAjaxySelector).ajaxyDialog(self.options);
+                    }
+            
+                    //Make any links marked dialog-close do so
+                    if ( self.options.closeDialogSelector ) {
+                      dialog.find(self.options.closeDialogSelector).unbind("click." + widgetName);
+                      dialog.find(self.options.closeDialogSelector).bind("click." + widgetName, function() {
+                          dialog.dialog("close");
+                          return false;
+                      });
+                    }
+            
+                    dialog.dialog("open");
+                  }
+                  $("body").css("cursor", "auto");
+              },
+              
+              _displayFailure: function(uri, xhr, serverMsg) {
+                if (  this._trigger("error", 0, {uri:uri, xhr: xhr, serverMsg: serverMsg}) !== false) {                                                           
+                      var dialog = this.dialogContainer();
+                          
+                      dialog.html("<div class='ui-state-error' style='padding: 1em;'><p><span style='float: left; margin-right: 0.3em;' class='ui-icon ui-icon-alert'></span>Sorry, a software error has occured.</p><p>" + uri + ": " + xhr.status + " "  + serverMsg+"</p></div>");
+                      dialog.dialog("option", "title", "Sorry, an error has occured.");           
+                      dialog.dialog("option", "buttons", {"OK": function() { dialog.dialog("close"); }});
+                      dialog.dialog("open");
+                  }           
+                  $("body").css("cursor", "auto");
+              },
+              
+              // The DOM element which has a ui dialog() called on it. 
+              // Right now we insist upon modal dialogs, and re-use the same
+              // <div>.dialog() for all of them. It's lazily created here.   
+              // If client calls dialog("destroy") on it, no problem, it'll
+              // be lazily created if it's needed again. 
+              dialogContainer: function() {
+                var existing = $("#reusableModalDialog");
+                if ( existing.size() > 0) {
+                  return existing.first();
+                }
+                else {
+                  //single shared element for modal dialogs      
+                  var requestDialog = $('<div id="reusableModalDialog" style="display:none"></div>').appendTo('body').
+                      dialog({autoOpen: false}); 
+                  return requestDialog;
+                }
+              }
+              
+          });
+      }(jQuery));
+