From: Jakub Skoczen Date: Thu, 22 Mar 2007 16:08:19 +0000 (+0000) Subject: Rewrite of Masterkey using new mark-up X-Git-Tag: stable.27032007~8 X-Git-Url: http://git.indexdata.com/?a=commitdiff_plain;h=15359ada181de961e00fba3d68a9ff169ef6813c;p=pazpar2-moved-to-github.git Rewrite of Masterkey using new mark-up TODO: detailed record view, pager --- diff --git a/js/pz2.js b/js/pz2.js new file mode 100644 index 0000000..c2bbb41 --- /dev/null +++ b/js/pz2.js @@ -0,0 +1,386 @@ +// check for jQuery +if(typeof window.jQuery == "undefined") + throw new Error("pz2.js requires jQuery library"); +// prevent execution of more than once +if(typeof window.pz2 == "undefined") { +window.undefined = window.undefined; + +var pz2 = function(paramArray) { + //for convenience + __myself = this; + + // at least one callback required + if ( !paramArray ) + throw new Error("An array with parameters has to be suplied when instantiating a class"); + + // function callbacks + __myself.statCallback = paramArray.onstat || null; + __myself.showCallback = paramArray.onshow || null; + __myself.termlistCallback = paramArray.onterm || null; + __myself.recordCallback = paramArray.onrecord || null; + __myself.bytargetCallback = paramArray.onbytarget || null; + + // termlist keys + __myself.termKeys = paramArray.termlist || "subject"; + + // some configurational stuff + __myself.pz2String = "search.pz2"; + __myself.keepAlive = 50000; + + __myself.sessionID = null; + __myself.initStatusOK = false; + __myself.pingStatusOK = false; + __myself.searchStatusOK = false; + + if ( paramArray.keepAlive < __myself.keepAlive ) + __myself.keepAlive = paramArray.keepAlive; + + // for sorting + __myself.currentSort = "relevance"; + // where are we? + __myself.currentStart = 0; + __myself.currentNum = 20; + + // last full record retrieved + __myself.currRecID = null; + // current query + __myself.currQuery = null; + + //timers + __myself.statTime = paramArray.stattime || 2000; + __myself.statTimer = null; + __myself.termTime = paramArray.termtime || 1000; + __myself.termTimer = null; + __myself.showTime = paramArray.showtime || 1000; + __myself.showTimer = null; + __myself.bytargetTime = paramArray.bytargettime || 1000; + __myself.bytargetTimer = null; + + // active clients, updated by stat and show + // might be an issue since bytarget will poll accordingly + __myself.activeClients = 1; + + // error handling + $(document).ajaxError( + function (request, settings, exception) { + if ( settings.responseXML && settings.responseXML.getElementsByTagName("error") ) + throw new Error( settings.responseXML.getElementsByTagName("error")[0].childNodes[0].nodeValue); + }); + + // auto init session? + if (paramArray.autoInit !== false) + __myself.init(__myself.keepAlive); +} +pz2.prototype = { + init: function(keepAlive) + { + if ( keepAlive < __myself.keepAlive ) + __myself.keepAlive = keepAlive; + + $.get( __myself.pz2String, + { "command": "init" }, + function(data) { + if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) { + __myself.initStatusOK = true; + __myself.sessionID = data.getElementsByTagName("session")[0].childNodes[0].nodeValue; + setTimeout(__myself.ping, __myself.keepAlive); + } + else + // if it gets here the http return code was 200 (pz2 errors are 417) + // but the response was invalid, it should never occur + setTimeout("__myself.init()", 1000) + } + ); + }, + // no need to ping explicitly + ping: function() + { + if( !__myself.initStatusOK ) + return; + // session is not initialized code here + + $.get( __myself.pz2String, + { "command": "ping", "session": __myself.sessionID }, + function(data) { + if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) { + __myself.pingStatusOK = true; + setTimeout("__myself.ping()", __myself.keepAlive); + } + else + // if it gets here the http return code was 200 (pz2 errors are 417) + // but the response was invalid, it should never occur + setTimeout("__myself.ping()", 1000) + } + ); + }, + search: function(query, num, sort, filter) + { + clearTimeout(__myself.statTimer); + clearTimeout(__myself.showTimer); + clearTimeout(__myself.termTimer); + clearTimeout(__myself.bytargetTimer); + + if( !__myself.initStatusOK ) + return; + + if( query !== undefined ) + __myself.currQuery = query; + else + throw new Error("You need to supply query to the search command"); + + if( filter !== undefined ) + var searchParams = { "command": "search", "session": __myself.sessionID, "query": __myself.currQuery, "filter": filter }; + else + var searchParams = { "command": "search", "session": __myself.sessionID, "query": __myself.currQuery }; + + $.get( __myself.pz2String, + searchParams, + function(data) { + if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) { + __myself.searchStatusOK = true; + //piggyback search + __myself.show(0, num, sort) + if ( __myself.statCallback ) + __myself.statTimer = setTimeout("__myself.stat()", __myself.statTime / 2); + if ( __myself.termlistCallback ) + __myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime / 2); + if ( __myself.bytargetCallback ) + __myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime / 2); + } + else + // if it gets here the http return code was 200 (pz2 errors are 417) + // but the response was invalid, it should never occur + setTimeout("__myself.search(__myself.currQuery)", 1000); + } + ); + }, + stat: function() + { + if( !__myself.searchStatusOK ) + return; + // if called explicitly takes precedence + clearTimeout(__myself.statTimer); + + $.get( __myself.pz2String, + { "command": "stat", "session": __myself.sessionID }, + function(data) { + if ( data.getElementsByTagName("stat") ) { + var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue ); + __myself.activeClients = activeClients; + var stat = { + "activeclients": activeClients, + "hits": Number( data.getElementsByTagName("hits")[0].childNodes[0].nodeValue ), + "records": Number( data.getElementsByTagName("records")[0].childNodes[0].nodeValue ), + "clients": Number( data.getElementsByTagName("clients")[0].childNodes[0].nodeValue ), + "initializing": Number( data.getElementsByTagName("initializing")[0].childNodes[0].nodeValue ), + "searching": Number( data.getElementsByTagName("searching")[0].childNodes[0].nodeValue ), + "presenting": Number( data.getElementsByTagName("presenting")[0].childNodes[0].nodeValue ), + "idle": Number( data.getElementsByTagName("idle")[0].childNodes[0].nodeValue ), + "failed": Number( data.getElementsByTagName("failed")[0].childNodes[0].nodeValue ), + "error": Number( data.getElementsByTagName("error")[0].childNodes[0].nodeValue ) + } + __myself.statCallback(stat); + if (activeClients > 0) + __myself.statTimer = setTimeout("__myself.stat()", __myself.statTime); + } + else + // if it gets here the http return code was 200 (pz2 errors are 417) + // but the response was invalid, it should never occur + __myself.statTimer = setTimeout("__myself.stat()", __myself.statTime / 4) + } + ); + }, + show: function(start, num, sort) + { + if( !__myself.searchStatusOK ) + return; + // if called explicitly takes precedence + clearTimeout(__myself.showTimer); + + if( sort !== undefined ) + __myself.currentSort = sort; + if( start !== undefined ) + __myself.currentStart = Number( start ); + if( num !== undefined ) + __myself.currentNum = Number( num ); + + $.get( __myself.pz2String, + { "command": "show", "session": __myself.sessionID, "start": __myself.currentStart, + "num": __myself.currentNum, "sort": __myself.currentSort, "block": 1 }, + function(data) { + if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) { + // first parse the status data send along with records + // this is strictly bound to the format + var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue ); + var show = { + "activeclients": activeClients, + "merged": Number( data.getElementsByTagName("merged")[0].childNodes[0].nodeValue ), + "total": Number( data.getElementsByTagName("total")[0].childNodes[0].nodeValue ), + "start": Number( data.getElementsByTagName("start")[0].childNodes[0].nodeValue ), + "num": Number( data.getElementsByTagName("num")[0].childNodes[0].nodeValue ), + "hits": [] + } + // parse all the first-level nodes for all tags + var hits = data.getElementsByTagName("hit"); + var hit = new Array(); + for (i = 0; i < hits.length; i++) { + show.hits[i] = new Array(); + for ( j = 0; j < hits[i].childNodes.length; j++) { + if ( hits[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) { + var nodeName = hits[i].childNodes[j].nodeName; + var nodeText = hits[i].childNodes[j].firstChild.nodeValue; + show.hits[i][nodeName] = nodeText; + } + } + } + __myself.showCallback(show); + if (activeClients > 0) + __myself.showTimer = setTimeout("__myself.show()", __myself.showTime); + } + else + // if it gets here the http return code was 200 (pz2 errors are 417) + // but the response was invalid, it should never occur + __myself.showTimer = setTimeout("__myself.show()", __myself.showTime / 4); + } + ); + }, + record: function(id) + { + if( !__myself.searchStatusOK ) + return; + + if( id !== undefined ) + __myself.currRecID = id; + + $.get( __myself.pz2String, + { "command": "record", "session": __myself.sessionID, "id": __myself.currRecID }, + function(data) { + var recordNode; + var record = new Array(); + if ( recordNode = data.getElementsByTagName("record")[0] ) { + for ( i = 0; i < recordNode.childNodes.length; i++) { + if ( recordNode.childNodes[i].nodeType == Node.ELEMENT_NODE ) { + var nodeName = recordNode.childNodes[i].nodeName; + var nodeText = recordNode.childNodes[i].firstChild.nodeValue; + record[nodeName] = nodeText; + } + } + // the location is hard coded + var locationNodes = recordNode.getElementsByTagName("location"); + record["location"] = new Array(); + for ( i = 0; i < locationNodes.length; i++ ) { + record["location"][i] = { + "id": locationNodes[i].getAttribute("id"), + "name": locationNodes[i].getAttribute("name") + }; + for ( j = 0; j < locationNodes[i].childNodes.length; j++) { + if ( locationNodes[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) { + var nodeName = locationNodes[i].childNodes[j].nodeName; + var nodeText = locationNodes[i].childNodes[j].firstChild.nodeValue; + record["location"][i][nodeName] = nodeText; + } + } + } + __myself.recordCallback(record); + } + else + // if it gets here the http return code was 200 (pz2 errors are 417) + // but the response was invalid, it should never occur + setTimeout("__myself.record(__myself.currRecID)", 1000); + } + ); + }, + termlist: function() + { + if( !__myself.searchStatusOK ) + return; + // if called explicitly takes precedence + clearTimeout(__myself.termTimer); + + $.get( __myself.pz2String, + { "command": "termlist", "session": __myself.sessionID, "name": __myself.termKeys }, + function(data) { + if ( data.getElementsByTagName("termlist") ) { + var termList = { "activeclients": Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue ) } + var termLists = data.getElementsByTagName("list"); + //for each termlist + for (i = 0; i < termLists.length; i++) { + var listName = termLists[i].getAttribute('name'); + termList[listName] = new Array(); + var terms = termLists[i].getElementsByTagName('term'); + //for each term in the list + for (j = 0; j < terms.length; j++) { + var term = { + "name": terms[j].getElementsByTagName("name")[0].childNodes[0].nodeValue, + "freq": terms[j].getElementsByTagName("frequency")[0].childNodes[0].nodeValue, + } + + var termIdNode = terms[j].getElementsByTagName("id"); + if(terms[j].getElementsByTagName("id").length) + term["id"] = termIdNode[0].childNodes[0].nodeValue; + + termList[listName][j] = term; + } + } + __myself.termlistCallback(termList); + if (termList["activeclients"] > 0) + __myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime); + } + else + // if it gets here the http return code was 200 (pz2 errors are 417) + // but the response was invalid, it should never occur + __myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime / 4); + } + ); + + }, + bytarget: function() + { + if( !__myself.searchStatusOK ) + return; + // if called explicitly takes precedence + clearTimeout(__myself.bytargetTimer); + + $.get( __myself.pz2String, + { "command": "bytarget", "session": __myself.sessionID }, + function(data) { + if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) { + var targetNodes = data.getElementsByTagName("target"); + var bytarget = new Array(); + for ( i = 0; i < targetNodes.length; i++) { + bytarget[i] = new Array(); + for( j = 0; j < targetNodes[i].childNodes.length; j++ ) { + if ( targetNodes[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) { + var nodeName = targetNodes[i].childNodes[j].nodeName; + var nodeText = targetNodes[i].childNodes[j].firstChild.nodeValue; + bytarget[i][nodeName] = nodeText; + } + } + } + __myself.bytargetCallback(bytarget); + if ( __myself.activeClients > 0 ) + __myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime); + } + else + // if it gets here the http return code was 200 (pz2 errors are 417) + // but the response was invalid, it should never occur + __myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime / 4); + } + ); + }, + // just for testing, probably shouldn't be here + showNext: function(page) + { + var step = page || 1; + __myself.show( ( step * __myself.currentNum ) + __myself.currentStart ); + }, + showPrev: function(page) + { + if (__myself.currentStart == 0 ) + return false; + var step = page || 1; + var newStart = __myself.currentStart - (step * __myself.currentNum ); + __myself.show( newStart > 0 ? newStart : 0 ); + } +}; +} diff --git a/www/masterkey/css/styles.css b/www/masterkey/css/styles.css new file mode 100755 index 0000000..10d5a06 --- /dev/null +++ b/www/masterkey/css/styles.css @@ -0,0 +1,398 @@ +html { +overflow-y: scroll; +} + +html, body { +background-color:#f0f0f9; /*#335382;*/ +color: #002863; +font: 11px verdana, arial, sans-serif; +} + +div.container { +position: relative; +width: 980px; +background-color: #ffffff; +color: #002863; +margin-left: auto; +margin-right: auto; +height: 100%; +} + +img { +border: none; +} + +strong { +color: #31568c; +font-weight: bold; +} + +h2 { +font-size: 11px; +margin: 0px; +padding: 0px; +line-height: 13px; +} + +select { +border: 1px solid #7f9db9; +} + +div.topbar { +background-color: #002863; +color: #ffffff; +height: 85px; +position: absolute; +left: 0px; +top: 0px; +width: 100%; +border-bottom: 5px solid #f0f0f9; /*#335382;*/ +} + +#logo { +position: relative; +left: 39px; +top: 28px; +} + +div.topmenu { +position: absolute; +left: 245px; +top: 53px; +text-align: right; +width: 573px; +padding-top: 4px; +border-top: 1px solid #335382; +height: 25px; +} + +div.topmenu a { +color: #ffffff; +font: bold 11px verdana, arial, sans-serif; +padding-left: 41px; +} + +div.bluebox { +width: 124px; +height: 59px; +background-color: #31568c; +position: absolute; +right: 19px; +top: 14px; +} + +div.search { +position: relative; +top: 90px; +left: 0px; +width: 100%; +height: 73px; +background-color: #e1e5ec; +color: #31568c; +font-weight: bold; +} + +div.search span { +position: absolute; +left: 74px; +top: 28px; +} + +div.search div { +position: absolute; +left: 225px; +top: 25px; +} + +input.search { +background-color: #ffffff; +color: #000000; +border: 1px solid #a5acb2; +height: 17px; +line-height: 17px; +width: 500px; +margin-top: -1px; +} + +div.main { +width: 100%; +background-color: #ffffff; +background-image: url(../gfx/background.gif); +background-position: 0px 271px; +background-repeat: repeat-y; +color: #002863; +position: relative; +top: 108px; +left: 0px; +} + +div.clear { +clear: both; +} + +div.leftbar { +float: left; +width: 209px; +height: 100%; +margin-bottom: 10px; +margin-right: 17px; +color: #000000; +} + +div.head { +padding: 0px; +width: 100%; +height: 55px; +background-color: #c1cbd9; +font-size: 10px; +margin-bottom: 8px; +} + +div.margin { +padding-left: 13px; +padding-top: 10px; +padding-right: 13px; +} + +div.content { +float: right; +width: 754px; +background-color: #ffffff; +color: #002863; +} + +input.button { +color: #ffffff; +font: bold 11px verdana; +vertical-align: top; +margin-left: 8px; +} + +div.search a { +margin-left: 30px; +color: #31568c; +text-decoration: underline; +font-weight: normal; +line-height: 15px; +} + +a { +color: #5d82b7; +text-decoration: none; +} + +a:visited { +color: #a0689d; +} + +a:hover { +text-decoration: underline; +} + +div.clear { +clear: both; +} + +a.result { +width: 44px; +float: left; +line-height: 20px; +margin-bottom: 5px; +text-indent: 10px; +clear: both; +} + +div.record { +float: left; +width: 675px; +margin-bottom: 5px; +line-height: 20px; +} + +a.close { +float: left; +padding: 5px; +width: 18px; +height: 20px; +border: 1px solid #aec0db; +border-left: 0px; +text-align: center; +margin-top: -6px; +} + +a.close img { +margin-top: 6px; +} + +div.records a.select { +float: left; +width: 651px; +font-weight: bold; +line-height: 20px; +padding: 5px; +margin-top: -6px; +border: 1px solid #aec0db; +} + +div.detail { +padding: 5px 5px 5px 10px; +border: 1px solid #aec0db; +border-top: 0px; +margin-left: 44px; +margin-bottom: 5px; +width: 675px; +float: left; +clear: left; +} + +div.results { +float: left; +color: #000000; +background-color: #e1e5ec; +padding-left: 10px; +padding-right: 20px; +padding-top: 5px; +height: 50px; +line-height: 25px; +margin-bottom: 12px; +} + +div.bottom { +float: left; +color: #000000; +background-color: #e1e5ec; +padding-left: 10px; +padding-right: 20px; +height: 28px; +line-height: 28px; +} + +table { +padding: 0px; +margin: 0px; +border-collapse: collapse; +} + +td { +color: #000000; +} + +td.item { +width: 100px; +color: #31568c; +} + +div.detail a { +background: none; +padding: 0px; +margin: 0px; +} + +div.showing { +float: left; +clear: left; +} + +div.pages { +float: right; +} + +div.pages a.page, div.pages a.select { +text-decoration: underline; +padding-left: 2px; +padding-right: 2px; +} + +div.pages a.select { +text-decoration: none; +font-weight: bold; +} + +a.previous_inactive { +background-image: url(../gfx/previous_inactive.gif); +color: #757575; +} + +a.previous_active { +background-image: url(../gfx/previous_active.gif); +} + +a.next_inactive { +background-image: url(../gfx/next_inactive.gif); +color: #757575; +} + +a.next_active { +background-image: url(../gfx/next_active.gif); +} + +a.previous_active, a.previous_inactive { +margin-right: 10px; +text-decoration: none; +padding-left: 10px; +background-position: 0px 4px; +background-repeat: no-repeat; +} + +a.next_inactive, a.next_active { +margin-left: 10px; +padding-right: 10px; +background-position: 100% 4px; +background-repeat: no-repeat; +text-decoration: none; +} + +div.leftbar a { +display: block; +padding-left: 20px; +} + +a span { +color: #959595; +} + +a.selected { +background-image: url(../gfx/minus.gif); +background-position: 0px 2px; +background-repeat: no-repeat; +text-transform: capitalize; +font-weight: bold; +font-size: 10px; +line-height: 13px; +} + +a.unselected { +background-image: url(../gfx/plus.gif); +background-position: 0px 2px; +background-repeat: no-repeat; +text-transform: capitalize; +font-weight: bold; +font-size: 10px; +line-height: 13px; +} + +a.sub { +text-indent: 15px; +font-size: 10px; +line-height: 13px; +} + +span.green { +color: #63b05d; +font-weight: bold; +} + +div.leftbar hr { +border: 0px; +border-bottom: 1px solid #c5cedc; +height: 1px; +line-height: 8px; +} + +div.trailer { +background-color: #ffffff; +width: 100%; +height: 37px; +padding-top: 3px; +text-indent: 227px; +} diff --git a/www/masterkey/gfx/arrow_down.gif b/www/masterkey/gfx/arrow_down.gif new file mode 100755 index 0000000..09a19d2 Binary files /dev/null and b/www/masterkey/gfx/arrow_down.gif differ diff --git a/www/masterkey/gfx/arrow_right.gif b/www/masterkey/gfx/arrow_right.gif new file mode 100755 index 0000000..0e56a1f Binary files /dev/null and b/www/masterkey/gfx/arrow_right.gif differ diff --git a/www/masterkey/gfx/background.gif b/www/masterkey/gfx/background.gif new file mode 100755 index 0000000..874b12f Binary files /dev/null and b/www/masterkey/gfx/background.gif differ diff --git a/www/masterkey/gfx/button.gif b/www/masterkey/gfx/button.gif new file mode 100755 index 0000000..6d0ca2d Binary files /dev/null and b/www/masterkey/gfx/button.gif differ diff --git a/www/masterkey/gfx/close.gif b/www/masterkey/gfx/close.gif new file mode 100755 index 0000000..4c28b95 Binary files /dev/null and b/www/masterkey/gfx/close.gif differ diff --git a/www/masterkey/gfx/logo.gif b/www/masterkey/gfx/logo.gif new file mode 100755 index 0000000..96ea119 Binary files /dev/null and b/www/masterkey/gfx/logo.gif differ diff --git a/www/masterkey/gfx/minus.gif b/www/masterkey/gfx/minus.gif new file mode 100755 index 0000000..e254e5f Binary files /dev/null and b/www/masterkey/gfx/minus.gif differ diff --git a/www/masterkey/gfx/next_active.gif b/www/masterkey/gfx/next_active.gif new file mode 100755 index 0000000..5179461 Binary files /dev/null and b/www/masterkey/gfx/next_active.gif differ diff --git a/www/masterkey/gfx/next_inactive.gif b/www/masterkey/gfx/next_inactive.gif new file mode 100755 index 0000000..ff8a3b4 Binary files /dev/null and b/www/masterkey/gfx/next_inactive.gif differ diff --git a/www/masterkey/gfx/plus.gif b/www/masterkey/gfx/plus.gif new file mode 100755 index 0000000..5e663e0 Binary files /dev/null and b/www/masterkey/gfx/plus.gif differ diff --git a/www/masterkey/gfx/previous_active.gif b/www/masterkey/gfx/previous_active.gif new file mode 100755 index 0000000..6b85add Binary files /dev/null and b/www/masterkey/gfx/previous_active.gif differ diff --git a/www/masterkey/gfx/previous_inactive.gif b/www/masterkey/gfx/previous_inactive.gif new file mode 100755 index 0000000..6b85add Binary files /dev/null and b/www/masterkey/gfx/previous_inactive.gif differ diff --git a/www/masterkey/gfx/trailer.gif b/www/masterkey/gfx/trailer.gif new file mode 100755 index 0000000..33627ee Binary files /dev/null and b/www/masterkey/gfx/trailer.gif differ diff --git a/www/masterkey/index.html b/www/masterkey/index.html new file mode 100755 index 0000000..d04da05 --- /dev/null +++ b/www/masterkey/index.html @@ -0,0 +1,66 @@ + + + + MasterKey Power Search + + + + + + + +
+
+ +
+ FRONT PAGE + ABOUT + HELP +
+
+
+
+ ENTER SEARCH TERM: +
+
+ + + Advanced search +
+
+
+
+ + +
+
MasterKey
+
+
+ + diff --git a/www/masterkey/js/client.js b/www/masterkey/js/client.js new file mode 100644 index 0000000..4ed2e30 --- /dev/null +++ b/www/masterkey/js/client.js @@ -0,0 +1,218 @@ +// very simple client that shows a basic usage of the pz2.js + +// create a parameters array and pass it to the pz2's constructor +// then register the form submit event with the pz2.search function + +var my_paz = new pz2( { "onshow": my_onshow, + //"showtime": 1000, + //"onstat": my_onstat, + "onterm": my_onterm, + "termlist": "subject,author,xtargets,date", + //"onbytarget": my_onbytarget, + "onrecord": my_onrecord } ); + +var currentSort = 'relevance'; +var currentResultsPerPage = 20; +var currentQuery = null; +var currentDetailed = null; + +var termStartup = true; //some things should be done only once + +// wait until the DOM is ready (could have been defined in the HTML) +$(document).ready( function() { + document.search.onsubmit = onFormSubmitEventHandler; + } ); + +function onFormSubmitEventHandler() { + currentQuery = document.search.query.value; + my_paz.search(document.search.query.value, 20, 'relevance'); + $('div.content').show(); + $("div.leftbar").show(); + return false; +} +// +// pz2.js event handlers: +// +function my_onshow(data) +{ + var recsBody = $('div.records'); + recsBody.empty(); + + for (var i = 0; i < data.hits.length; i++) { + var title = data.hits[i]["md-title"] || 'N/A'; + var author = data.hits[i]["md-author"] || ''; + var id = data.hits[i].recid; + var count = data.hits[i].count || 1; + + recsBody.append(''+(i+1)+'.\n'); + + var recBody = $('
'+title+'\n'); + + if( author ) + recBody.append(' by '); + $(''+author+'\n').click(function(){ refine(this.name, this.firstChild.nodeValue) }).appendTo(recBody); + } +} + +/* + + body.innerHTML = ""; + for ( i = 0; i < data.hits.length; i++) { + var hit = data.hits[i]; + body.innerHTML += '
' + i + + '. ' + hit["md-title"] + + ' by ' + hit["md-author"] + '
'; + } + body.innerHTML += "
"; + body.innerHTML += '
active clients: ' + data.activeclients + '
' + + '
merged: ' + data.merged + '
' + + '
total: ' + data.total + '
' + + '
start: ' + data.start + '
' + + '
num: ' + data.num + '
'; +} +*/ + +function my_onstat(data) +{ +/* + var stat = document.getElementById("stat"); + stat.innerHTML = '
active clients: ' + data.activeclients + '
' + + '
hits: ' + data.hits + '
' + + '
records: ' + data.records + '
' + + '
clients: ' + data.clients + '
' + + '
searching: ' + data.searching + '
'; +*/ +} + +function my_onterm(data) +{ + global = data; + var termLists = $("#termlists"); + //termLists.empty() + + if(termStartup) + { + for(var key in data){ + if (key == "activeclients") + continue; + var listName = key; + if (key == "xtargets") + listName = "institution"; + + var termList = $('
').appendTo(termLists); + var termTitle = $('
'+listName+'
').appendTo(termList); + termTitle.click(function(){ + if( this.firstChild.className == "selected" ){ + this.firstChild.className = "unselected"; + $(this.nextSibling).hide(); + } else { + this.firstChild.className = "selected"; + $(this.nextSibling).show(); + } + }); + + listEntries = $('
'); + listEntries.hide(); + listEntries.appendTo(termList); + + for(var i = 0; i < data[key].length; i++) + { + if (key == "xtargets"){ + var listItem = $(''+data[key][i].name+ + ' ('+data[key][i].freq+')').appendTo(listEntries); + listItem.click(function(){ + refine(this.name, this.attributes[0].nodeValue) }); + } else { + var listItem = $(''+data[key][i].name+ + ' ('+data[key][i].freq+')').appendTo(listEntries); + listItem.click(function(){ refine(this.name, this.firstChild.nodeValue) }); + } + } + $('
').appendTo(termLists); + } + termStartup = false; + } + else + { + for(var key in data){ + if (key == "activeclients") + continue; + var listEntries = $('#term_'+key).children('.termEntries'); + listEntries.empty() + + for(var i = 0; i < data[key].length; i++){ + if (key == "xtargets"){ + var listItem = $(''+data[key][i].name+ + ' ('+data[key][i].freq+')').appendTo(listEntries); + listItem.click(function(){ + refine(this.name, this.attributes[0].nodeValue) }); + } else { + var listItem = $(''+data[key][i].name+ + ' ('+data[key][i].freq+')').appendTo(listEntries); + listItem.click(function(){ refine(this.name, this.firstChild.nodeValue) }); + } + } + } + } +} + +/* + var termlist = document.getElementById("termlist"); + termlist.innerHTML = ""; + termlist.innerHTML += "
--Author--
"; + for ( i = 0; i < data.author.length; i++ ) { + termlist.innerHTML += '
' + data.author[i].name + ' (' + data.author[i].freq + ')
'; + } + termlist.innerHTML += "
"; + termlist.innerHTML += "
--Subject--
"; + for ( i = 0; i < data.subject.length; i++ ) { + termlist.innerHTML += '
' + data.subject[i].name + ' (' + data.subject[i].freq + ')
'; + } +*/ + +function my_onrecord(data) +{ + /* + details = data; + recordDiv = document.getElementById(data.recid); + recordDiv.innerHTML = "
Ttle : " + data["md-title"] + + "
Date : " + data["md-date"] + + "
Author : " + data["md-author"] + + "
Subject : " + data["md-subject"] + + "
Location : " + data["location"][0].name + "
"; + */ + +} + +function my_onbytarget(data) +{ + /* + targetDiv = document.getElementById("bytarget"); + targetDiv.innerHTML = "IDHitsDiagRecState"; + + for ( i = 0; i < data.length; i++ ) { + targetDiv.innerHTML += "" + data[i].id + + "" + data[i].hits + + "" + data[i].diagnostic + + "" + data[i].records + + "" + data[i].state + ""; + } + */ +} + +function refine(field, value) +{ + var query = ''; + var filter = undefined; + + switch(field) { + case "author": query = ' and au="'+value+'"'; break; + case "title": query = ' and ti="'+value+'"'; break; + case "date": query = ' and date="'+value+'"'; break; + case "subject": query = ' and su="'+value+'"'; break; + case "xtarget": filter = 'id='+value; break; + } + + my_paz.search(currentQuery + query, currentResultsPerPage, currentSort, filter); +} diff --git a/www/masterkey/js/jquery.js b/www/masterkey/js/jquery.js new file mode 100644 index 0000000..fdb8764 --- /dev/null +++ b/www/masterkey/js/jquery.js @@ -0,0 +1,2245 @@ +/* prevent execution of jQuery if included more than once */ +if(typeof window.jQuery == "undefined") { +/* + * jQuery 1.1.2 - New Wave Javascript + * + * Copyright (c) 2007 John Resig (jquery.com) + * Dual licensed under the MIT (MIT-LICENSE.txt) + * and GPL (GPL-LICENSE.txt) licenses. + * + * $Date: 2007-03-22 16:08:20 $ + * $Rev: 1465 $ + */ + +// Global undefined variable +window.undefined = window.undefined; +var jQuery = function(a,c) { + // If the context is global, return a new object + if ( window == this ) + return new jQuery(a,c); + + // Make sure that a selection was provided + a = a || document; + + // HANDLE: $(function) + // Shortcut for document ready + if ( jQuery.isFunction(a) ) + return new jQuery(document)[ jQuery.fn.ready ? "ready" : "load" ]( a ); + + // Handle HTML strings + if ( typeof a == "string" ) { + // HANDLE: $(html) -> $(array) + var m = /^[^<]*(<(.|\s)+>)[^>]*$/.exec(a); + if ( m ) + a = jQuery.clean( [ m[1] ] ); + + // HANDLE: $(expr) + else + return new jQuery( c ).find( a ); + } + + return this.setArray( + // HANDLE: $(array) + a.constructor == Array && a || + + // HANDLE: $(arraylike) + // Watch for when an array-like object is passed as the selector + (a.jquery || a.length && a != window && !a.nodeType && a[0] != undefined && a[0].nodeType) && jQuery.makeArray( a ) || + + // HANDLE: $(*) + [ a ] ); +}; + +// Map over the $ in case of overwrite +if ( typeof $ != "undefined" ) + jQuery._$ = $; + +// Map the jQuery namespace to the '$' one +var $ = jQuery; + +jQuery.fn = jQuery.prototype = { + jquery: "1.1.2", + + size: function() { + return this.length; + }, + + length: 0, + + get: function( num ) { + return num == undefined ? + + // Return a 'clean' array + jQuery.makeArray( this ) : + + // Return just the object + this[num]; + }, + pushStack: function( a ) { + var ret = jQuery(a); + ret.prevObject = this; + return ret; + }, + setArray: function( a ) { + this.length = 0; + [].push.apply( this, a ); + return this; + }, + each: function( fn, args ) { + return jQuery.each( this, fn, args ); + }, + index: function( obj ) { + var pos = -1; + this.each(function(i){ + if ( this == obj ) pos = i; + }); + return pos; + }, + + attr: function( key, value, type ) { + var obj = key; + + // Look for the case where we're accessing a style value + if ( key.constructor == String ) + if ( value == undefined ) + return this.length && jQuery[ type || "attr" ]( this[0], key ) || undefined; + else { + obj = {}; + obj[ key ] = value; + } + + // Check to see if we're setting style values + return this.each(function(index){ + // Set all the styles + for ( var prop in obj ) + jQuery.attr( + type ? this.style : this, + prop, jQuery.prop(this, obj[prop], type, index, prop) + ); + }); + }, + + css: function( key, value ) { + return this.attr( key, value, "curCSS" ); + }, + + text: function(e) { + if ( typeof e == "string" ) + return this.empty().append( document.createTextNode( e ) ); + + var t = ""; + jQuery.each( e || this, function(){ + jQuery.each( this.childNodes, function(){ + if ( this.nodeType != 8 ) + t += this.nodeType != 1 ? + this.nodeValue : jQuery.fn.text([ this ]); + }); + }); + return t; + }, + + wrap: function() { + // The elements to wrap the target around + var a = jQuery.clean(arguments); + + // Wrap each of the matched elements individually + return this.each(function(){ + // Clone the structure that we're using to wrap + var b = a[0].cloneNode(true); + + // Insert it before the element to be wrapped + this.parentNode.insertBefore( b, this ); + + // Find the deepest point in the wrap structure + while ( b.firstChild ) + b = b.firstChild; + + // Move the matched element to within the wrap structure + b.appendChild( this ); + }); + }, + append: function() { + return this.domManip(arguments, true, 1, function(a){ + this.appendChild( a ); + }); + }, + prepend: function() { + return this.domManip(arguments, true, -1, function(a){ + this.insertBefore( a, this.firstChild ); + }); + }, + before: function() { + return this.domManip(arguments, false, 1, function(a){ + this.parentNode.insertBefore( a, this ); + }); + }, + after: function() { + return this.domManip(arguments, false, -1, function(a){ + this.parentNode.insertBefore( a, this.nextSibling ); + }); + }, + end: function() { + return this.prevObject || jQuery([]); + }, + find: function(t) { + return this.pushStack( jQuery.map( this, function(a){ + return jQuery.find(t,a); + }), t ); + }, + clone: function(deep) { + return this.pushStack( jQuery.map( this, function(a){ + var a = a.cloneNode( deep != undefined ? deep : true ); + a.$events = null; // drop $events expando to avoid firing incorrect events + return a; + }) ); + }, + + filter: function(t) { + return this.pushStack( + jQuery.isFunction( t ) && + jQuery.grep(this, function(el, index){ + return t.apply(el, [index]) + }) || + + jQuery.multiFilter(t,this) ); + }, + + not: function(t) { + return this.pushStack( + t.constructor == String && + jQuery.multiFilter(t, this, true) || + + jQuery.grep(this, function(a) { + return ( t.constructor == Array || t.jquery ) + ? jQuery.inArray( a, t ) < 0 + : a != t; + }) + ); + }, + + add: function(t) { + return this.pushStack( jQuery.merge( + this.get(), + t.constructor == String ? + jQuery(t).get() : + t.length != undefined && (!t.nodeName || t.nodeName == "FORM") ? + t : [t] ) + ); + }, + is: function(expr) { + return expr ? jQuery.filter(expr,this).r.length > 0 : false; + }, + + val: function( val ) { + return val == undefined ? + ( this.length ? this[0].value : null ) : + this.attr( "value", val ); + }, + + html: function( val ) { + return val == undefined ? + ( this.length ? this[0].innerHTML : null ) : + this.empty().append( val ); + }, + domManip: function(args, table, dir, fn){ + var clone = this.length > 1; + var a = jQuery.clean(args); + if ( dir < 0 ) + a.reverse(); + + return this.each(function(){ + var obj = this; + + if ( table && jQuery.nodeName(this, "table") && jQuery.nodeName(a[0], "tr") ) + obj = this.getElementsByTagName("tbody")[0] || this.appendChild(document.createElement("tbody")); + + jQuery.each( a, function(){ + fn.apply( obj, [ clone ? this.cloneNode(true) : this ] ); + }); + + }); + } +}; + +jQuery.extend = jQuery.fn.extend = function() { + // copy reference to target object + var target = arguments[0], + a = 1; + + // extend jQuery itself if only one argument is passed + if ( arguments.length == 1 ) { + target = this; + a = 0; + } + var prop; + while (prop = arguments[a++]) + // Extend the base object + for ( var i in prop ) target[i] = prop[i]; + + // Return the modified object + return target; +}; + +jQuery.extend({ + noConflict: function() { + if ( jQuery._$ ) + $ = jQuery._$; + return jQuery; + }, + + // This may seem like some crazy code, but trust me when I say that this + // is the only cross-browser way to do this. --John + isFunction: function( fn ) { + return !!fn && typeof fn != "string" && !fn.nodeName && + typeof fn[0] == "undefined" && /function/i.test( fn + "" ); + }, + + // check if an element is in a XML document + isXMLDoc: function(elem) { + return elem.tagName && elem.ownerDocument && !elem.ownerDocument.body; + }, + + nodeName: function( elem, name ) { + return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase(); + }, + // args is for internal usage only + each: function( obj, fn, args ) { + if ( obj.length == undefined ) + for ( var i in obj ) + fn.apply( obj[i], args || [i, obj[i]] ); + else + for ( var i = 0, ol = obj.length; i < ol; i++ ) + if ( fn.apply( obj[i], args || [i, obj[i]] ) === false ) break; + return obj; + }, + + prop: function(elem, value, type, index, prop){ + // Handle executable functions + if ( jQuery.isFunction( value ) ) + value = value.call( elem, [index] ); + + // exclude the following css properties to add px + var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i; + + // Handle passing in a number to a CSS property + return value && value.constructor == Number && type == "curCSS" && !exclude.test(prop) ? + value + "px" : + value; + }, + + className: { + // internal only, use addClass("class") + add: function( elem, c ){ + jQuery.each( c.split(/\s+/), function(i, cur){ + if ( !jQuery.className.has( elem.className, cur ) ) + elem.className += ( elem.className ? " " : "" ) + cur; + }); + }, + + // internal only, use removeClass("class") + remove: function( elem, c ){ + elem.className = c ? + jQuery.grep( elem.className.split(/\s+/), function(cur){ + return !jQuery.className.has( c, cur ); + }).join(" ") : ""; + }, + + // internal only, use is(".class") + has: function( t, c ) { + t = t.className || t; + // escape regex characters + c = c.replace(/([\.\\\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:])/g, "\\$1"); + return t && new RegExp("(^|\\s)" + c + "(\\s|$)").test( t ); + } + }, + swap: function(e,o,f) { + for ( var i in o ) { + e.style["old"+i] = e.style[i]; + e.style[i] = o[i]; + } + f.apply( e, [] ); + for ( var i in o ) + e.style[i] = e.style["old"+i]; + }, + + css: function(e,p) { + if ( p == "height" || p == "width" ) { + var old = {}, oHeight, oWidth, d = ["Top","Bottom","Right","Left"]; + + jQuery.each( d, function(){ + old["padding" + this] = 0; + old["border" + this + "Width"] = 0; + }); + + jQuery.swap( e, old, function() { + if (jQuery.css(e,"display") != "none") { + oHeight = e.offsetHeight; + oWidth = e.offsetWidth; + } else { + e = jQuery(e.cloneNode(true)) + .find(":radio").removeAttr("checked").end() + .css({ + visibility: "hidden", position: "absolute", display: "block", right: "0", left: "0" + }).appendTo(e.parentNode)[0]; + + var parPos = jQuery.css(e.parentNode,"position"); + if ( parPos == "" || parPos == "static" ) + e.parentNode.style.position = "relative"; + + oHeight = e.clientHeight; + oWidth = e.clientWidth; + + if ( parPos == "" || parPos == "static" ) + e.parentNode.style.position = "static"; + + e.parentNode.removeChild(e); + } + }); + + return p == "height" ? oHeight : oWidth; + } + + return jQuery.curCSS( e, p ); + }, + + curCSS: function(elem, prop, force) { + var ret; + + if (prop == "opacity" && jQuery.browser.msie) + return jQuery.attr(elem.style, "opacity"); + + if (prop == "float" || prop == "cssFloat") + prop = jQuery.browser.msie ? "styleFloat" : "cssFloat"; + + if (!force && elem.style[prop]) + ret = elem.style[prop]; + + else if (document.defaultView && document.defaultView.getComputedStyle) { + + if (prop == "cssFloat" || prop == "styleFloat") + prop = "float"; + + prop = prop.replace(/([A-Z])/g,"-$1").toLowerCase(); + var cur = document.defaultView.getComputedStyle(elem, null); + + if ( cur ) + ret = cur.getPropertyValue(prop); + else if ( prop == "display" ) + ret = "none"; + else + jQuery.swap(elem, { display: "block" }, function() { + var c = document.defaultView.getComputedStyle(this, ""); + ret = c && c.getPropertyValue(prop) || ""; + }); + + } else if (elem.currentStyle) { + + var newProp = prop.replace(/\-(\w)/g,function(m,c){return c.toUpperCase();}); + ret = elem.currentStyle[prop] || elem.currentStyle[newProp]; + + } + + return ret; + }, + + clean: function(a) { + var r = []; + + jQuery.each( a, function(i,arg){ + if ( !arg ) return; + + if ( arg.constructor == Number ) + arg = arg.toString(); + + // Convert html string into DOM nodes + if ( typeof arg == "string" ) { + // Trim whitespace, otherwise indexOf won't work as expected + var s = jQuery.trim(arg), div = document.createElement("div"), tb = []; + + var wrap = + // option or optgroup + !s.indexOf("", ""] || + + (!s.indexOf("", ""] || + + !s.indexOf("", ""] || + + // matched above + (!s.indexOf("", ""] || + + [0,"",""]; + + // Go to html and back, then peel off extra wrappers + div.innerHTML = wrap[1] + s + wrap[2]; + + // Move to the right depth + while ( wrap[0]-- ) + div = div.firstChild; + + // Remove IE's autoinserted from table fragments + if ( jQuery.browser.msie ) { + + // String was a , *may* have spurious + if ( !s.indexOf(" or + else if ( wrap[1] == "
" && s.indexOf("= 0 ; --n ) + if ( jQuery.nodeName(tb[n], "tbody") && !tb[n].childNodes.length ) + tb[n].parentNode.removeChild(tb[n]); + + } + + arg = []; + for (var i=0, l=div.childNodes.length; im[3]-0", + nth: "m[3]-0==i", + eq: "m[3]-0==i", + first: "i==0", + last: "i==r.length-1", + even: "i%2==0", + odd: "i%2", + + // Child Checks + "nth-child": "jQuery.nth(a.parentNode.firstChild,m[3],'nextSibling',a)==a", + "first-child": "jQuery.nth(a.parentNode.firstChild,1,'nextSibling')==a", + "last-child": "jQuery.nth(a.parentNode.lastChild,1,'previousSibling')==a", + "only-child": "jQuery.sibling(a.parentNode.firstChild).length==1", + + // Parent Checks + parent: "a.firstChild", + empty: "!a.firstChild", + + // Text Check + contains: "jQuery.fn.text.apply([a]).indexOf(m[3])>=0", + + // Visibility + visible: 'a.type!="hidden"&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden"', + hidden: 'a.type=="hidden"||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden"', + + // Form attributes + enabled: "!a.disabled", + disabled: "a.disabled", + checked: "a.checked", + selected: "a.selected||jQuery.attr(a,'selected')", + + // Form elements + text: "a.type=='text'", + radio: "a.type=='radio'", + checkbox: "a.type=='checkbox'", + file: "a.type=='file'", + password: "a.type=='password'", + submit: "a.type=='submit'", + image: "a.type=='image'", + reset: "a.type=='reset'", + button: 'a.type=="button"||jQuery.nodeName(a,"button")', + input: "/input|select|textarea|button/i.test(a.nodeName)" + }, + ".": "jQuery.className.has(a,m[2])", + "@": { + "=": "z==m[4]", + "!=": "z!=m[4]", + "^=": "z&&!z.indexOf(m[4])", + "$=": "z&&z.substr(z.length - m[4].length,m[4].length)==m[4]", + "*=": "z&&z.indexOf(m[4])>=0", + "": "z", + _resort: function(m){ + return ["", m[1], m[3], m[2], m[5]]; + }, + _prefix: "z=a[m[3]];if(!z||/href|src/.test(m[3]))z=jQuery.attr(a,m[3]);" + }, + "[": "jQuery.find(m[2],a).length" + }, + + // The regular expressions that power the parsing engine + parse: [ + // Match: [@value='test'], [@foo] + /^\[ *(@)([a-z0-9_-]*) *([!*$^=]*) *('?"?)(.*?)\4 *\]/i, + + // Match: [div], [div p] + /^(\[)\s*(.*?(\[.*?\])?[^[]*?)\s*\]/, + + // Match: :contains('foo') + /^(:)([a-z0-9_-]*)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/i, + + // Match: :even, :last-chlid + /^([:.#]*)([a-z0-9_*-]*)/i + ], + + token: [ + /^(\/?\.\.)/, "a.parentNode", + /^(>|\/)/, "jQuery.sibling(a.firstChild)", + /^(\+)/, "jQuery.nth(a,2,'nextSibling')", + /^(~)/, function(a){ + var s = jQuery.sibling(a.parentNode.firstChild); + return s.slice(jQuery.inArray(a,s) + 1); + } + ], + + multiFilter: function( expr, elems, not ) { + var old, cur = []; + + while ( expr && expr != old ) { + old = expr; + var f = jQuery.filter( expr, elems, not ); + expr = f.t.replace(/^\s*,\s*/, "" ); + cur = not ? elems = f.r : jQuery.merge( cur, f.r ); + } + + return cur; + }, + find: function( t, context ) { + // Quickly handle non-string expressions + if ( typeof t != "string" ) + return [ t ]; + + // Make sure that the context is a DOM Element + if ( context && !context.nodeType ) + context = null; + + // Set the correct context (if none is provided) + context = context || document; + + // Handle the common XPath // expression + if ( !t.indexOf("//") ) { + context = context.documentElement; + t = t.substr(2,t.length); + + // And the / root expression + } else if ( !t.indexOf("/") ) { + context = context.documentElement; + t = t.substr(1,t.length); + if ( t.indexOf("/") >= 1 ) + t = t.substr(t.indexOf("/"),t.length); + } + + // Initialize the search + var ret = [context], done = [], last = null; + + // Continue while a selector expression exists, and while + // we're no longer looping upon ourselves + while ( t && last != t ) { + var r = []; + last = t; + + t = jQuery.trim(t).replace( /^\/\//i, "" ); + + var foundToken = false; + + // An attempt at speeding up child selectors that + // point to a specific element tag + var re = /^[\/>]\s*([a-z0-9*-]+)/i; + var m = re.exec(t); + + if ( m ) { + // Perform our own iteration and filter + jQuery.each( ret, function(){ + for ( var c = this.firstChild; c; c = c.nextSibling ) + if ( c.nodeType == 1 && ( jQuery.nodeName(c, m[1]) || m[1] == "*" ) ) + r.push( c ); + }); + + ret = r; + t = t.replace( re, "" ); + if ( t.indexOf(" ") == 0 ) continue; + foundToken = true; + } else { + // Look for pre-defined expression tokens + for ( var i = 0; i < jQuery.token.length; i += 2 ) { + // Attempt to match each, individual, token in + // the specified order + var re = jQuery.token[i]; + var m = re.exec(t); + + // If the token match was found + if ( m ) { + // Map it against the token's handler + r = ret = jQuery.map( ret, jQuery.isFunction( jQuery.token[i+1] ) ? + jQuery.token[i+1] : + function(a){ return eval(jQuery.token[i+1]); }); + + // And remove the token + t = jQuery.trim( t.replace( re, "" ) ); + foundToken = true; + break; + } + } + } + + // See if there's still an expression, and that we haven't already + // matched a token + if ( t && !foundToken ) { + // Handle multiple expressions + if ( !t.indexOf(",") ) { + // Clean the result set + if ( ret[0] == context ) ret.shift(); + + // Merge the result sets + jQuery.merge( done, ret ); + + // Reset the context + r = ret = [context]; + + // Touch up the selector string + t = " " + t.substr(1,t.length); + + } else { + // Optomize for the case nodeName#idName + var re2 = /^([a-z0-9_-]+)(#)([a-z0-9\\*_-]*)/i; + var m = re2.exec(t); + + // Re-organize the results, so that they're consistent + if ( m ) { + m = [ 0, m[2], m[3], m[1] ]; + + } else { + // Otherwise, do a traditional filter check for + // ID, class, and element selectors + re2 = /^([#.]?)([a-z0-9\\*_-]*)/i; + m = re2.exec(t); + } + + // Try to do a global search by ID, where we can + if ( m[1] == "#" && ret[ret.length-1].getElementById ) { + // Optimization for HTML document case + var oid = ret[ret.length-1].getElementById(m[2]); + + // Do a quick check for the existence of the actual ID attribute + // to avoid selecting by the name attribute in IE + if ( jQuery.browser.msie && oid && oid.id != m[2] ) + oid = jQuery('[@id="'+m[2]+'"]', ret[ret.length-1])[0]; + + // Do a quick check for node name (where applicable) so + // that div#foo searches will be really fast + ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : []; + + } else { + // Pre-compile a regular expression to handle class searches + if ( m[1] == "." ) + var rec = new RegExp("(^|\\s)" + m[2] + "(\\s|$)"); + + // We need to find all descendant elements, it is more + // efficient to use getAll() when we are already further down + // the tree - we try to recognize that here + jQuery.each( ret, function(){ + // Grab the tag name being searched for + var tag = m[1] != "" || m[0] == "" ? "*" : m[2]; + + // Handle IE7 being really dumb about s + if ( jQuery.nodeName(this, "object") && tag == "*" ) + tag = "param"; + + jQuery.merge( r, + m[1] != "" && ret.length != 1 ? + jQuery.getAll( this, [], m[1], m[2], rec ) : + this.getElementsByTagName( tag ) + ); + }); + + // It's faster to filter by class and be done with it + if ( m[1] == "." && ret.length == 1 ) + r = jQuery.grep( r, function(e) { + return rec.test(e.className); + }); + + // Same with ID filtering + if ( m[1] == "#" && ret.length == 1 ) { + // Remember, then wipe out, the result set + var tmp = r; + r = []; + + // Then try to find the element with the ID + jQuery.each( tmp, function(){ + if ( this.getAttribute("id") == m[2] ) { + r = [ this ]; + return false; + } + }); + } + + ret = r; + } + + t = t.replace( re2, "" ); + } + + } + + // If a selector string still exists + if ( t ) { + // Attempt to filter it + var val = jQuery.filter(t,r); + ret = r = val.r; + t = jQuery.trim(val.t); + } + } + + // Remove the root context + if ( ret && ret[0] == context ) ret.shift(); + + // And combine the results + jQuery.merge( done, ret ); + + return done; + }, + + filter: function(t,r,not) { + // Look for common filter expressions + while ( t && /^[a-z[({<*:.#]/i.test(t) ) { + + var p = jQuery.parse, m; + + jQuery.each( p, function(i,re){ + + // Look for, and replace, string-like sequences + // and finally build a regexp out of it + m = re.exec( t ); + + if ( m ) { + // Remove what we just matched + t = t.substring( m[0].length ); + + // Re-organize the first match + if ( jQuery.expr[ m[1] ]._resort ) + m = jQuery.expr[ m[1] ]._resort( m ); + + return false; + } + }); + + // :not() is a special case that can be optimized by + // keeping it out of the expression list + if ( m[1] == ":" && m[2] == "not" ) + r = jQuery.filter(m[3], r, true).r; + + // Handle classes as a special case (this will help to + // improve the speed, as the regexp will only be compiled once) + else if ( m[1] == "." ) { + + var re = new RegExp("(^|\\s)" + m[2] + "(\\s|$)"); + r = jQuery.grep( r, function(e){ + return re.test(e.className || ""); + }, not); + + // Otherwise, find the expression to execute + } else { + var f = jQuery.expr[m[1]]; + if ( typeof f != "string" ) + f = jQuery.expr[m[1]][m[2]]; + + // Build a custom macro to enclose it + eval("f = function(a,i){" + + ( jQuery.expr[ m[1] ]._prefix || "" ) + + "return " + f + "}"); + + // Execute it against the current filter + r = jQuery.grep( r, f, not ); + } + } + + // Return an array of filtered elements (r) + // and the modified expression string (t) + return { r: r, t: t }; + }, + + getAll: function( o, r, token, name, re ) { + for ( var s = o.firstChild; s; s = s.nextSibling ) + if ( s.nodeType == 1 ) { + var add = true; + + if ( token == "." ) + add = s.className && re.test(s.className); + else if ( token == "#" ) + add = s.getAttribute("id") == name; + + if ( add ) + r.push( s ); + + if ( token == "#" && r.length ) break; + + if ( s.firstChild ) + jQuery.getAll( s, r, token, name, re ); + } + + return r; + }, + parents: function( elem ){ + var matched = []; + var cur = elem.parentNode; + while ( cur && cur != document ) { + matched.push( cur ); + cur = cur.parentNode; + } + return matched; + }, + nth: function(cur,result,dir,elem){ + result = result || 1; + var num = 0; + for ( ; cur; cur = cur[dir] ) { + if ( cur.nodeType == 1 ) num++; + if ( num == result || result == "even" && num % 2 == 0 && num > 1 && cur == elem || + result == "odd" && num % 2 == 1 && cur == elem ) return cur; + } + }, + sibling: function( n, elem ) { + var r = []; + + for ( ; n; n = n.nextSibling ) { + if ( n.nodeType == 1 && (!elem || n != elem) ) + r.push( n ); + } + + return r; + } +}); +/* + * A number of helper functions used for managing events. + * Many of the ideas behind this code orignated from + * Dean Edwards' addEvent library. + */ +jQuery.event = { + + // Bind an event to an element + // Original by Dean Edwards + add: function(element, type, handler, data) { + // For whatever reason, IE has trouble passing the window object + // around, causing it to be cloned in the process + if ( jQuery.browser.msie && element.setInterval != undefined ) + element = window; + + // if data is passed, bind to handler + if( data ) + handler.data = data; + + // Make sure that the function being executed has a unique ID + if ( !handler.guid ) + handler.guid = this.guid++; + + // Init the element's event structure + if (!element.$events) + element.$events = {}; + + // Get the current list of functions bound to this event + var handlers = element.$events[type]; + + // If it hasn't been initialized yet + if (!handlers) { + // Init the event handler queue + handlers = element.$events[type] = {}; + + // Remember an existing handler, if it's already there + if (element["on" + type]) + handlers[0] = element["on" + type]; + } + + // Add the function to the element's handler list + handlers[handler.guid] = handler; + + // And bind the global event handler to the element + element["on" + type] = this.handle; + + // Remember the function in a global list (for triggering) + if (!this.global[type]) + this.global[type] = []; + this.global[type].push( element ); + }, + + guid: 1, + global: {}, + + // Detach an event or set of events from an element + remove: function(element, type, handler) { + if (element.$events) { + var i,j,k; + if ( type && type.type ) { // type is actually an event object here + handler = type.handler; + type = type.type; + } + + if (type && element.$events[type]) + // remove the given handler for the given type + if ( handler ) + delete element.$events[type][handler.guid]; + + // remove all handlers for the given type + else + for ( i in element.$events[type] ) + delete element.$events[type][i]; + + // remove all handlers + else + for ( j in element.$events ) + this.remove( element, j ); + + // remove event handler if no more handlers exist + for ( k in element.$events[type] ) + if (k) { + k = true; + break; + } + if (!k) element["on" + type] = null; + } + }, + + trigger: function(type, data, element) { + // Clone the incoming data, if any + data = jQuery.makeArray(data || []); + + // Handle a global trigger + if ( !element ) + jQuery.each( this.global[type] || [], function(){ + jQuery.event.trigger( type, data, this ); + }); + + // Handle triggering a single element + else { + var handler = element["on" + type ], val, + fn = jQuery.isFunction( element[ type ] ); + + if ( handler ) { + // Pass along a fake event + data.unshift( this.fix({ type: type, target: element }) ); + + // Trigger the event + if ( (val = handler.apply( element, data )) !== false ) + this.triggered = true; + } + + if ( fn && val !== false ) + element[ type ](); + + this.triggered = false; + } + }, + + handle: function(event) { + // Handle the second event of a trigger and when + // an event is called after a page has unloaded + if ( typeof jQuery == "undefined" || jQuery.event.triggered ) return; + + // Empty object is for triggered events with no data + event = jQuery.event.fix( event || window.event || {} ); + + // returned undefined or false + var returnValue; + + var c = this.$events[event.type]; + + var args = [].slice.call( arguments, 1 ); + args.unshift( event ); + + for ( var j in c ) { + // Pass in a reference to the handler function itself + // So that we can later remove it + args[0].handler = c[j]; + args[0].data = c[j].data; + + if ( c[j].apply( this, args ) === false ) { + event.preventDefault(); + event.stopPropagation(); + returnValue = false; + } + } + + // Clean up added properties in IE to prevent memory leak + if (jQuery.browser.msie) event.target = event.preventDefault = event.stopPropagation = event.handler = event.data = null; + + return returnValue; + }, + + fix: function(event) { + // Fix target property, if necessary + if ( !event.target && event.srcElement ) + event.target = event.srcElement; + + // Calculate pageX/Y if missing and clientX/Y available + if ( event.pageX == undefined && event.clientX != undefined ) { + var e = document.documentElement, b = document.body; + event.pageX = event.clientX + (e.scrollLeft || b.scrollLeft); + event.pageY = event.clientY + (e.scrollTop || b.scrollTop); + } + + // check if target is a textnode (safari) + if (jQuery.browser.safari && event.target.nodeType == 3) { + // store a copy of the original event object + // and clone because target is read only + var originalEvent = event; + event = jQuery.extend({}, originalEvent); + + // get parentnode from textnode + event.target = originalEvent.target.parentNode; + + // add preventDefault and stopPropagation since + // they will not work on the clone + event.preventDefault = function() { + return originalEvent.preventDefault(); + }; + event.stopPropagation = function() { + return originalEvent.stopPropagation(); + }; + } + + // fix preventDefault and stopPropagation + if (!event.preventDefault) + event.preventDefault = function() { + this.returnValue = false; + }; + + if (!event.stopPropagation) + event.stopPropagation = function() { + this.cancelBubble = true; + }; + + return event; + } +}; + +jQuery.fn.extend({ + bind: function( type, data, fn ) { + return this.each(function(){ + jQuery.event.add( this, type, fn || data, data ); + }); + }, + one: function( type, data, fn ) { + return this.each(function(){ + jQuery.event.add( this, type, function(event) { + jQuery(this).unbind(event); + return (fn || data).apply( this, arguments); + }, data); + }); + }, + unbind: function( type, fn ) { + return this.each(function(){ + jQuery.event.remove( this, type, fn ); + }); + }, + trigger: function( type, data ) { + return this.each(function(){ + jQuery.event.trigger( type, data, this ); + }); + }, + toggle: function() { + // Save reference to arguments for access in closure + var a = arguments; + + return this.click(function(e) { + // Figure out which function to execute + this.lastToggle = this.lastToggle == 0 ? 1 : 0; + + // Make sure that clicks stop + e.preventDefault(); + + // and execute the function + return a[this.lastToggle].apply( this, [e] ) || false; + }); + }, + hover: function(f,g) { + + // A private function for handling mouse 'hovering' + function handleHover(e) { + // Check if mouse(over|out) are still within the same parent element + var p = (e.type == "mouseover" ? e.fromElement : e.toElement) || e.relatedTarget; + + // Traverse up the tree + while ( p && p != this ) try { p = p.parentNode } catch(e) { p = this; }; + + // If we actually just moused on to a sub-element, ignore it + if ( p == this ) return false; + + // Execute the right function + return (e.type == "mouseover" ? f : g).apply(this, [e]); + } + + // Bind the function to the two event listeners + return this.mouseover(handleHover).mouseout(handleHover); + }, + ready: function(f) { + // If the DOM is already ready + if ( jQuery.isReady ) + // Execute the function immediately + f.apply( document, [jQuery] ); + + // Otherwise, remember the function for later + else { + // Add the function to the wait list + jQuery.readyList.push( function() { return f.apply(this, [jQuery]) } ); + } + + return this; + } +}); + +jQuery.extend({ + /* + * All the code that makes DOM Ready work nicely. + */ + isReady: false, + readyList: [], + + // Handle when the DOM is ready + ready: function() { + // Make sure that the DOM is not already loaded + if ( !jQuery.isReady ) { + // Remember that the DOM is ready + jQuery.isReady = true; + + // If there are functions bound, to execute + if ( jQuery.readyList ) { + // Execute all of them + jQuery.each( jQuery.readyList, function(){ + this.apply( document ); + }); + + // Reset the list of functions + jQuery.readyList = null; + } + // Remove event lisenter to avoid memory leak + if ( jQuery.browser.mozilla || jQuery.browser.opera ) + document.removeEventListener( "DOMContentLoaded", jQuery.ready, false ); + } + } +}); + +new function(){ + + jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," + + "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," + + "submit,keydown,keypress,keyup,error").split(","), function(i,o){ + + // Handle event binding + jQuery.fn[o] = function(f){ + return f ? this.bind(o, f) : this.trigger(o); + }; + + }); + + // If Mozilla is used + if ( jQuery.browser.mozilla || jQuery.browser.opera ) + // Use the handy event callback + document.addEventListener( "DOMContentLoaded", jQuery.ready, false ); + + // If IE is used, use the excellent hack by Matthias Miller + // http://www.outofhanwell.com/blog/index.php?title=the_window_onload_problem_revisited + else if ( jQuery.browser.msie ) { + + // Only works if you document.write() it + document.write("<\/script>"); + + // Use the defer script hack + var script = document.getElementById("__ie_init"); + + // script does not exist if jQuery is loaded dynamically + if ( script ) + script.onreadystatechange = function() { + if ( this.readyState != "complete" ) return; + this.parentNode.removeChild( this ); + jQuery.ready(); + }; + + // Clear from memory + script = null; + + // If Safari is used + } else if ( jQuery.browser.safari ) + // Continually check to see if the document.readyState is valid + jQuery.safariTimer = setInterval(function(){ + // loaded and complete are both valid states + if ( document.readyState == "loaded" || + document.readyState == "complete" ) { + + // If either one are found, remove the timer + clearInterval( jQuery.safariTimer ); + jQuery.safariTimer = null; + + // and execute any waiting functions + jQuery.ready(); + } + }, 10); + + // A fallback to window.onload, that will always work + jQuery.event.add( window, "load", jQuery.ready ); + +}; + +// Clean up after IE to avoid memory leaks +if (jQuery.browser.msie) + jQuery(window).one("unload", function() { + var global = jQuery.event.global; + for ( var type in global ) { + var els = global[type], i = els.length; + if ( i && type != 'unload' ) + do + jQuery.event.remove(els[i-1], type); + while (--i); + } + }); +jQuery.fn.extend({ + loadIfModified: function( url, params, callback ) { + this.load( url, params, callback, 1 ); + }, + load: function( url, params, callback, ifModified ) { + if ( jQuery.isFunction( url ) ) + return this.bind("load", url); + + callback = callback || function(){}; + + // Default to a GET request + var type = "GET"; + + // If the second parameter was provided + if ( params ) + // If it's a function + if ( jQuery.isFunction( params ) ) { + // We assume that it's the callback + callback = params; + params = null; + + // Otherwise, build a param string + } else { + params = jQuery.param( params ); + type = "POST"; + } + + var self = this; + + // Request the remote document + jQuery.ajax({ + url: url, + type: type, + data: params, + ifModified: ifModified, + complete: function(res, status){ + if ( status == "success" || !ifModified && status == "notmodified" ) + // Inject the HTML into all the matched elements + self.attr("innerHTML", res.responseText) + // Execute all the scripts inside of the newly-injected HTML + .evalScripts() + // Execute callback + .each( callback, [res.responseText, status, res] ); + else + callback.apply( self, [res.responseText, status, res] ); + } + }); + return this; + }, + serialize: function() { + return jQuery.param( this ); + }, + evalScripts: function() { + return this.find("script").each(function(){ + if ( this.src ) + jQuery.getScript( this.src ); + else + jQuery.globalEval( this.text || this.textContent || this.innerHTML || "" ); + }).end(); + } + +}); + +// If IE is used, create a wrapper for the XMLHttpRequest object +if ( !window.XMLHttpRequest ) + XMLHttpRequest = function(){ + return new ActiveXObject("Microsoft.XMLHTTP"); + }; + +// Attach a bunch of functions for handling common AJAX events + +jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){ + jQuery.fn[o] = function(f){ + return this.bind(o, f); + }; +}); + +jQuery.extend({ + get: function( url, data, callback, type, ifModified ) { + // shift arguments if data argument was ommited + if ( jQuery.isFunction( data ) ) { + callback = data; + data = null; + } + + return jQuery.ajax({ + url: url, + data: data, + success: callback, + dataType: type, + ifModified: ifModified + }); + }, + getIfModified: function( url, data, callback, type ) { + return jQuery.get(url, data, callback, type, 1); + }, + getScript: function( url, callback ) { + return jQuery.get(url, null, callback, "script"); + }, + getJSON: function( url, data, callback ) { + return jQuery.get(url, data, callback, "json"); + }, + post: function( url, data, callback, type ) { + if ( jQuery.isFunction( data ) ) { + callback = data; + data = {}; + } + + return jQuery.ajax({ + type: "POST", + url: url, + data: data, + success: callback, + dataType: type + }); + }, + + // timeout (ms) + //timeout: 0, + ajaxTimeout: function( timeout ) { + jQuery.ajaxSettings.timeout = timeout; + }, + ajaxSetup: function( settings ) { + jQuery.extend( jQuery.ajaxSettings, settings ); + }, + + ajaxSettings: { + global: true, + type: "GET", + timeout: 0, + contentType: "application/x-www-form-urlencoded", + processData: true, + async: true, + data: null + }, + + // Last-Modified header cache for next request + lastModified: {}, + ajax: function( s ) { + // TODO introduce global settings, allowing the client to modify them for all requests, not only timeout + s = jQuery.extend({}, jQuery.ajaxSettings, s); + + // if data available + if ( s.data ) { + // convert data if not already a string + if (s.processData && typeof s.data != "string") + s.data = jQuery.param(s.data); + // append data to url for get requests + if( s.type.toLowerCase() == "get" ) { + // "?" + data or "&" + data (in case there are already params) + s.url += ((s.url.indexOf("?") > -1) ? "&" : "?") + s.data; + // IE likes to send both get and post data, prevent this + s.data = null; + } + } + + // Watch for a new set of requests + if ( s.global && ! jQuery.active++ ) + jQuery.event.trigger( "ajaxStart" ); + + var requestDone = false; + + // Create the request object + var xml = new XMLHttpRequest(); + + // Open the socket + xml.open(s.type, s.url, s.async); + + // Set the correct header, if data is being sent + if ( s.data ) + xml.setRequestHeader("Content-Type", s.contentType); + + // Set the If-Modified-Since header, if ifModified mode. + if ( s.ifModified ) + xml.setRequestHeader("If-Modified-Since", + jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" ); + + // Set header so the called script knows that it's an XMLHttpRequest + xml.setRequestHeader("X-Requested-With", "XMLHttpRequest"); + + // Make sure the browser sends the right content length + if ( xml.overrideMimeType ) + xml.setRequestHeader("Connection", "close"); + + // Allow custom headers/mimetypes + if( s.beforeSend ) + s.beforeSend(xml); + + if ( s.global ) + jQuery.event.trigger("ajaxSend", [xml, s]); + + // Wait for a response to come back + var onreadystatechange = function(isTimeout){ + // The transfer is complete and the data is available, or the request timed out + if ( xml && (xml.readyState == 4 || isTimeout == "timeout") ) { + requestDone = true; + + // clear poll interval + if (ival) { + clearInterval(ival); + ival = null; + } + + var status; + try { + status = jQuery.httpSuccess( xml ) && isTimeout != "timeout" ? + s.ifModified && jQuery.httpNotModified( xml, s.url ) ? "notmodified" : "success" : "error"; + // Make sure that the request was successful or notmodified + if ( status != "error" ) { + // Cache Last-Modified header, if ifModified mode. + var modRes; + try { + modRes = xml.getResponseHeader("Last-Modified"); + } catch(e) {} // swallow exception thrown by FF if header is not available + + if ( s.ifModified && modRes ) + jQuery.lastModified[s.url] = modRes; + + // process the data (runs the xml through httpData regardless of callback) + var data = jQuery.httpData( xml, s.dataType ); + + // If a local callback was specified, fire it and pass it the data + if ( s.success ) + s.success( data, status ); + + // Fire the global callback + if( s.global ) + jQuery.event.trigger( "ajaxSuccess", [xml, s] ); + } else + jQuery.handleError(s, xml, status); + } catch(e) { + status = "error"; + jQuery.handleError(s, xml, status, e); + } + + // The request was completed + if( s.global ) + jQuery.event.trigger( "ajaxComplete", [xml, s] ); + + // Handle the global AJAX counter + if ( s.global && ! --jQuery.active ) + jQuery.event.trigger( "ajaxStop" ); + + // Process result + if ( s.complete ) + s.complete(xml, status); + + // Stop memory leaks + if(s.async) + xml = null; + } + }; + + // don't attach the handler to the request, just poll it instead + var ival = setInterval(onreadystatechange, 13); + + // Timeout checker + if ( s.timeout > 0 ) + setTimeout(function(){ + // Check to see if the request is still happening + if ( xml ) { + // Cancel the request + xml.abort(); + + if( !requestDone ) + onreadystatechange( "timeout" ); + } + }, s.timeout); + + // Send the data + try { + xml.send(s.data); + } catch(e) { + jQuery.handleError(s, xml, null, e); + } + + // firefox 1.5 doesn't fire statechange for sync requests + if ( !s.async ) + onreadystatechange(); + + // return XMLHttpRequest to allow aborting the request etc. + return xml; + }, + + handleError: function( s, xml, status, e ) { + // If a local callback was specified, fire it + if ( s.error ) s.error( xml, status, e ); + + // Fire the global callback + if ( s.global ) + jQuery.event.trigger( "ajaxError", [xml, s, e] ); + }, + + // Counter for holding the number of active queries + active: 0, + + // Determines if an XMLHttpRequest was successful or not + httpSuccess: function( r ) { + try { + return !r.status && location.protocol == "file:" || + ( r.status >= 200 && r.status < 300 ) || r.status == 304 || + jQuery.browser.safari && r.status == undefined; + } catch(e){} + return false; + }, + + // Determines if an XMLHttpRequest returns NotModified + httpNotModified: function( xml, url ) { + try { + var xmlRes = xml.getResponseHeader("Last-Modified"); + + // Firefox always returns 200. check Last-Modified date + return xml.status == 304 || xmlRes == jQuery.lastModified[url] || + jQuery.browser.safari && xml.status == undefined; + } catch(e){} + return false; + }, + + /* Get the data out of an XMLHttpRequest. + * Return parsed XML if content-type header is "xml" and type is "xml" or omitted, + * otherwise return plain text. + * (String) data - The type of data that you're expecting back, + * (e.g. "xml", "html", "script") + */ + httpData: function( r, type ) { + var ct = r.getResponseHeader("content-type"); + var data = !type && ct && ct.indexOf("xml") >= 0; + data = type == "xml" || data ? r.responseXML : r.responseText; + + // If the type is "script", eval it in global context + if ( type == "script" ) + jQuery.globalEval( data ); + + // Get the JavaScript object, if JSON is used. + if ( type == "json" ) + eval( "data = " + data ); + + // evaluate scripts within html + if ( type == "html" ) + jQuery("
").html(data).evalScripts(); + + return data; + }, + + // Serialize an array of form elements or a set of + // key/values into a query string + param: function( a ) { + var s = []; + + // If an array was passed in, assume that it is an array + // of form elements + if ( a.constructor == Array || a.jquery ) + // Serialize the form elements + jQuery.each( a, function(){ + s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) ); + }); + + // Otherwise, assume that it's an object of key/value pairs + else + // Serialize the key/values + for ( var j in a ) + // If the value is an array then the key names need to be repeated + if ( a[j] && a[j].constructor == Array ) + jQuery.each( a[j], function(){ + s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) ); + }); + else + s.push( encodeURIComponent(j) + "=" + encodeURIComponent( a[j] ) ); + + // Return the resulting serialization + return s.join("&"); + }, + + // evalulates a script in global context + // not reliable for safari + globalEval: function( data ) { + if ( window.execScript ) + window.execScript( data ); + else if ( jQuery.browser.safari ) + // safari doesn't provide a synchronous global eval + window.setTimeout( data, 0 ); + else + eval.call( window, data ); + } + +}); +jQuery.fn.extend({ + + show: function(speed,callback){ + var hidden = this.filter(":hidden"); + speed ? + hidden.animate({ + height: "show", width: "show", opacity: "show" + }, speed, callback) : + + hidden.each(function(){ + this.style.display = this.oldblock ? this.oldblock : ""; + if ( jQuery.css(this,"display") == "none" ) + this.style.display = "block"; + }); + return this; + }, + + hide: function(speed,callback){ + var visible = this.filter(":visible"); + speed ? + visible.animate({ + height: "hide", width: "hide", opacity: "hide" + }, speed, callback) : + + visible.each(function(){ + this.oldblock = this.oldblock || jQuery.css(this,"display"); + if ( this.oldblock == "none" ) + this.oldblock = "block"; + this.style.display = "none"; + }); + return this; + }, + + // Save the old toggle function + _toggle: jQuery.fn.toggle, + toggle: function( fn, fn2 ){ + var args = arguments; + return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ? + this._toggle( fn, fn2 ) : + this.each(function(){ + jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ] + .apply( jQuery(this), args ); + }); + }, + slideDown: function(speed,callback){ + return this.animate({height: "show"}, speed, callback); + }, + slideUp: function(speed,callback){ + return this.animate({height: "hide"}, speed, callback); + }, + slideToggle: function(speed, callback){ + return this.each(function(){ + var state = jQuery(this).is(":hidden") ? "show" : "hide"; + jQuery(this).animate({height: state}, speed, callback); + }); + }, + fadeIn: function(speed, callback){ + return this.animate({opacity: "show"}, speed, callback); + }, + fadeOut: function(speed, callback){ + return this.animate({opacity: "hide"}, speed, callback); + }, + fadeTo: function(speed,to,callback){ + return this.animate({opacity: to}, speed, callback); + }, + animate: function( prop, speed, easing, callback ) { + return this.queue(function(){ + + this.curAnim = jQuery.extend({}, prop); + var opt = jQuery.speed(speed, easing, callback); + + for ( var p in prop ) { + var e = new jQuery.fx( this, opt, p ); + if ( prop[p].constructor == Number ) + e.custom( e.cur(), prop[p] ); + else + e[ prop[p] ]( prop ); + } + + }); + }, + queue: function(type,fn){ + if ( !fn ) { + fn = type; + type = "fx"; + } + + return this.each(function(){ + if ( !this.queue ) + this.queue = {}; + + if ( !this.queue[type] ) + this.queue[type] = []; + + this.queue[type].push( fn ); + + if ( this.queue[type].length == 1 ) + fn.apply(this); + }); + } + +}); + +jQuery.extend({ + + speed: function(speed, easing, fn) { + var opt = speed && speed.constructor == Object ? speed : { + complete: fn || !fn && easing || + jQuery.isFunction( speed ) && speed, + duration: speed, + easing: fn && easing || easing && easing.constructor != Function && easing + }; + + opt.duration = (opt.duration && opt.duration.constructor == Number ? + opt.duration : + { slow: 600, fast: 200 }[opt.duration]) || 400; + + // Queueing + opt.old = opt.complete; + opt.complete = function(){ + jQuery.dequeue(this, "fx"); + if ( jQuery.isFunction( opt.old ) ) + opt.old.apply( this ); + }; + + return opt; + }, + + easing: {}, + + queue: {}, + + dequeue: function(elem,type){ + type = type || "fx"; + + if ( elem.queue && elem.queue[type] ) { + // Remove self + elem.queue[type].shift(); + + // Get next function + var f = elem.queue[type][0]; + + if ( f ) f.apply( elem ); + } + }, + + /* + * I originally wrote fx() as a clone of moo.fx and in the process + * of making it small in size the code became illegible to sane + * people. You've been warned. + */ + + fx: function( elem, options, prop ){ + + var z = this; + + // The styles + var y = elem.style; + + // Store display property + var oldDisplay = jQuery.css(elem, "display"); + + // Make sure that nothing sneaks out + y.overflow = "hidden"; + + // Simple function for setting a style value + z.a = function(){ + if ( options.step ) + options.step.apply( elem, [ z.now ] ); + + if ( prop == "opacity" ) + jQuery.attr(y, "opacity", z.now); // Let attr handle opacity + else if ( parseInt(z.now) ) // My hate for IE will never die + y[prop] = parseInt(z.now) + "px"; + + y.display = "block"; // Set display property to block for animation + }; + + // Figure out the maximum number to run to + z.max = function(){ + return parseFloat( jQuery.css(elem,prop) ); + }; + + // Get the current size + z.cur = function(){ + var r = parseFloat( jQuery.curCSS(elem, prop) ); + return r && r > -10000 ? r : z.max(); + }; + + // Start an animation from one number to another + z.custom = function(from,to){ + z.startTime = (new Date()).getTime(); + z.now = from; + z.a(); + + z.timer = setInterval(function(){ + z.step(from, to); + }, 13); + }; + + // Simple 'show' function + z.show = function(){ + if ( !elem.orig ) elem.orig = {}; + + // Remember where we started, so that we can go back to it later + elem.orig[prop] = this.cur(); + + options.show = true; + + // Begin the animation + z.custom(0, elem.orig[prop]); + + // Stupid IE, look what you made me do + if ( prop != "opacity" ) + y[prop] = "1px"; + }; + + // Simple 'hide' function + z.hide = function(){ + if ( !elem.orig ) elem.orig = {}; + + // Remember where we started, so that we can go back to it later + elem.orig[prop] = this.cur(); + + options.hide = true; + + // Begin the animation + z.custom(elem.orig[prop], 0); + }; + + //Simple 'toggle' function + z.toggle = function() { + if ( !elem.orig ) elem.orig = {}; + + // Remember where we started, so that we can go back to it later + elem.orig[prop] = this.cur(); + + if(oldDisplay == "none") { + options.show = true; + + // Stupid IE, look what you made me do + if ( prop != "opacity" ) + y[prop] = "1px"; + + // Begin the animation + z.custom(0, elem.orig[prop]); + } else { + options.hide = true; + + // Begin the animation + z.custom(elem.orig[prop], 0); + } + }; + + // Each step of an animation + z.step = function(firstNum, lastNum){ + var t = (new Date()).getTime(); + + if (t > options.duration + z.startTime) { + // Stop the timer + clearInterval(z.timer); + z.timer = null; + + z.now = lastNum; + z.a(); + + if (elem.curAnim) elem.curAnim[ prop ] = true; + + var done = true; + for ( var i in elem.curAnim ) + if ( elem.curAnim[i] !== true ) + done = false; + + if ( done ) { + // Reset the overflow + y.overflow = ""; + + // Reset the display + y.display = oldDisplay; + if (jQuery.css(elem, "display") == "none") + y.display = "block"; + + // Hide the element if the "hide" operation was done + if ( options.hide ) + y.display = "none"; + + // Reset the properties, if the item has been hidden or shown + if ( options.hide || options.show ) + for ( var p in elem.curAnim ) + if (p == "opacity") + jQuery.attr(y, p, elem.orig[p]); + else + y[p] = ""; + } + + // If a callback was provided, execute it + if ( done && jQuery.isFunction( options.complete ) ) + // Execute the complete function + options.complete.apply( elem ); + } else { + var n = t - this.startTime; + // Figure out where in the animation we are and set the number + var p = n / options.duration; + + // If the easing function exists, then use it + z.now = options.easing && jQuery.easing[options.easing] ? + jQuery.easing[options.easing](p, n, firstNum, (lastNum-firstNum), options.duration) : + // else use default linear easing + ((-Math.cos(p*Math.PI)/2) + 0.5) * (lastNum-firstNum) + firstNum; + + // Perform the next step of the animation + z.a(); + } + }; + + } +}); +}