ramaze 0.1.2 → 0.1.3

Sign up to get free protection for your applications and to get access to all the features.
Files changed (96) hide show
  1. data/Rakefile +1 -1
  2. data/doc/AUTHORS +2 -0
  3. data/doc/CHANGELOG +173 -0
  4. data/doc/changes.txt +4184 -0
  5. data/doc/changes.xml +4186 -0
  6. data/doc/meta/announcement.txt +22 -25
  7. data/doc/meta/internals.txt +146 -9
  8. data/examples/blog/template/index.xhtml +5 -2
  9. data/examples/fcgi.rb +13 -0
  10. data/examples/wiktacular/main.rb +8 -0
  11. data/examples/wiktacular/mkd/link/2007-07-20_19-45-51.mkd +1 -0
  12. data/examples/wiktacular/mkd/link/current.mkd +1 -0
  13. data/examples/wiktacular/mkd/main/2007-07-20_16-31-33.mkd +1 -0
  14. data/examples/wiktacular/mkd/main/2007-07-20_19-21-12.mkd +1 -0
  15. data/examples/wiktacular/mkd/main/2007-07-20_19-23-10.mkd +2 -0
  16. data/examples/wiktacular/mkd/main/2007-07-20_19-45-07.mkd +2 -0
  17. data/examples/wiktacular/mkd/main/current.mkd +2 -0
  18. data/examples/wiktacular/mkd/markdown/current.mkd +3 -0
  19. data/examples/wiktacular/mkd/testing/2007-07-20_16-43-46.mkd +2 -0
  20. data/examples/wiktacular/mkd/testing/2007-07-20_19-43-50.mkd +3 -0
  21. data/examples/wiktacular/mkd/testing/2007-07-21_18-46-01.mkd +11 -0
  22. data/examples/wiktacular/mkd/testing/2007-07-21_18-46-32.mkd +13 -0
  23. data/examples/wiktacular/mkd/testing/2007-07-21_18-47-08.mkd +17 -0
  24. data/examples/wiktacular/mkd/testing/2007-07-21_18-47-54.mkd +17 -0
  25. data/examples/wiktacular/mkd/testing/current.mkd +17 -0
  26. data/examples/wiktacular/public/favicon.ico +0 -0
  27. data/examples/wiktacular/public/screen.css +72 -0
  28. data/examples/wiktacular/src/controller.rb +44 -0
  29. data/examples/wiktacular/src/model.rb +92 -0
  30. data/examples/wiktacular/src/page.rb +66 -0
  31. data/examples/wiktacular/template/edit.xhtml +7 -0
  32. data/examples/wiktacular/template/index.xhtml +11 -0
  33. data/examples/wiktacular/template/new.xhtml +7 -0
  34. data/lib/proto/main.rb +2 -0
  35. data/lib/proto/public/error.zmr +3 -0
  36. data/lib/proto/public/js/jquery.js +1755 -1334
  37. data/lib/proto/template/index.xhtml +2 -2
  38. data/lib/ramaze.rb +8 -3
  39. data/lib/ramaze/action/render.rb +11 -0
  40. data/lib/ramaze/adapter/base.rb +11 -7
  41. data/lib/ramaze/cache.rb +25 -10
  42. data/lib/ramaze/cache/memcached.rb +16 -1
  43. data/lib/ramaze/cache/yaml_store.rb +10 -0
  44. data/lib/ramaze/controller.rb +12 -2
  45. data/lib/ramaze/controller/error.rb +9 -3
  46. data/lib/ramaze/controller/resolve.rb +20 -18
  47. data/lib/ramaze/dispatcher.rb +13 -4
  48. data/lib/ramaze/dispatcher/action.rb +7 -3
  49. data/lib/ramaze/dispatcher/error.rb +24 -2
  50. data/lib/ramaze/dispatcher/file.rb +12 -6
  51. data/lib/ramaze/global.rb +0 -3
  52. data/lib/ramaze/global/dsl.rb +9 -0
  53. data/lib/ramaze/global/globalstruct.rb +7 -1
  54. data/lib/ramaze/helper/aspect.rb +4 -2
  55. data/lib/ramaze/helper/cgi.rb +2 -2
  56. data/lib/ramaze/helper/file.rb +3 -0
  57. data/lib/ramaze/helper/link.rb +20 -0
  58. data/lib/ramaze/helper/markaby.rb +3 -0
  59. data/lib/ramaze/helper/pager.rb +10 -17
  60. data/lib/ramaze/helper/partial.rb +9 -3
  61. data/lib/ramaze/inform/analogger.rb +14 -0
  62. data/lib/ramaze/inform/growl.rb +7 -0
  63. data/lib/ramaze/inform/hub.rb +9 -0
  64. data/lib/ramaze/inform/informer.rb +9 -3
  65. data/lib/ramaze/inform/informing.rb +9 -3
  66. data/lib/ramaze/inform/knotify.rb +5 -1
  67. data/lib/ramaze/inform/syslog.rb +3 -0
  68. data/lib/ramaze/inform/xosd.rb +12 -0
  69. data/lib/ramaze/template.rb +3 -0
  70. data/lib/ramaze/template/amrita2.rb +2 -0
  71. data/lib/ramaze/template/erubis.rb +1 -0
  72. data/lib/ramaze/template/ezamar.rb +1 -0
  73. data/lib/ramaze/template/ezamar/element.rb +17 -11
  74. data/lib/ramaze/template/ezamar/engine.rb +5 -0
  75. data/lib/ramaze/template/ezamar/render_partial.rb +4 -2
  76. data/lib/ramaze/template/haml.rb +4 -0
  77. data/lib/ramaze/template/liquid.rb +4 -0
  78. data/lib/ramaze/template/markaby.rb +4 -0
  79. data/lib/ramaze/template/remarkably.rb +4 -0
  80. data/lib/ramaze/tool.rb +10 -0
  81. data/lib/ramaze/tool/localize.rb +1 -1
  82. data/lib/ramaze/trinity/session.rb +8 -1
  83. data/lib/ramaze/version.rb +1 -1
  84. data/rake_tasks/maintaince.rake +2 -2
  85. data/spec/ramaze/action/basics.rb +1 -1
  86. data/spec/ramaze/cache.rb +11 -0
  87. data/spec/ramaze/controller.rb +0 -14
  88. data/spec/ramaze/dispatcher/file.rb +5 -5
  89. data/spec/ramaze/dispatcher/public/favicon.ico +0 -0
  90. data/spec/ramaze/dispatcher/public/test_download.css +141 -0
  91. data/spec/ramaze/error.rb +21 -7
  92. data/spec/ramaze/helper/link.rb +15 -0
  93. data/spec/ramaze/helper/pager.rb +26 -3
  94. data/spec/ramaze/helper/partial.rb +2 -2
  95. metadata +43 -4
  96. data/doc/COPYING.ja +0 -51
data/examples/wiktacular/src/controller.rb ADDED
@@ -0,0 +1,44 @@
1
+ class MainController < Ramaze::Controller
2
+ def index handle = "main"
3
+ @handle = handle
4
+ @entry = WikiEntry.new(handle)
5
+ if @entry.exists?
6
+ @text = EntryView.render(@entry.content)
7
+ @history = @entry.history.map{|f|
8
+ DateTime.strptime(File.basename(f, ".mkd"),
9
+ "%Y-%m-%d_%H-%M-%S")
10
+ }.join("<br />\n")
11
+ else
12
+ @text = "No Entry"
13
+ end
14
+ end
15
+
16
+ def edit handle
17
+ @handle = handle
18
+ @entry = WikiEntry[handle]
19
+ @text = @entry.content
20
+ end
21
+
22
+ def revert handle
23
+ WikiEntry[handle].revert
24
+ redirect Rs(handle)
25
+ end
26
+
27
+ def unrevert handle
28
+ WikiEntry[handle].unrevert
29
+ redirect Rs(handle)
30
+ end
31
+
32
+ def delete handle
33
+ WikiEntry[handle].delete
34
+ redirect_referer
35
+ end
36
+
37
+ def save
38
+ redirect_referer unless request.post?
39
+ handle = request['handle']
40
+ entry = WikiEntry[handle]
41
+ entry.save(request['text'])
42
+ redirect Rs(:index, handle)
43
+ end
44
+ end
data/examples/wiktacular/src/model.rb ADDED
@@ -0,0 +1,92 @@
1
+ require 'fileutils'
2
+ require 'cgi'
3
+
4
+ class WikiEntry
5
+ class << self
6
+ def [](name)
7
+ new(name)
8
+ end
9
+ end
10
+
11
+ attr_reader :history, :current, :name
12
+
13
+ def initialize(name)
14
+ # avoid tampering with the path
15
+ @name = File.basename(File.expand_path(name))
16
+ update
17
+ end
18
+
19
+ def update
20
+ @current = "#{base}/current.mkd"
21
+ @history = Dir["#{base}/*_*.mkd"]
22
+ end
23
+
24
+ def save newtext
25
+ FileUtils.mkdir_p(base)
26
+
27
+ if content != newtext
28
+ history_name = "#{base}/#{timestamp}.mkd"
29
+ FileUtils.mv(@current, history_name) if exists?
30
+ File.open(@current, "w+"){|fp| fp.print(newtext) }
31
+ end
32
+ end
33
+
34
+ def rename to
35
+ FileUtils.mv(base, "mkd/#{to}")
36
+ end
37
+
38
+ def delete
39
+ FileUtils.rm_rf(base)
40
+ end
41
+
42
+ def revert
43
+ return if not exists? or @history.empty?
44
+ FileUtils.mv(@current, @current + ".bak")
45
+ FileUtils.mv(@history.last, @current) unless @history.empty?
46
+ update
47
+ end
48
+
49
+ def unrevert
50
+ bakfile = @current + '.bak'
51
+ return unless File.exists?(bakfile)
52
+ FileUtils.mv(bakfile, @current)
53
+ update
54
+ end
55
+
56
+ def exists?
57
+ File.exists?(@current)
58
+ end
59
+
60
+ def base
61
+ "mkd/#@name"
62
+ end
63
+
64
+ def content
65
+ CGI.unescapeHTML(File.read(@current)) if exists?
66
+ end
67
+
68
+ def timestamp
69
+ Time.now.strftime("%Y-%m-%d_%H-%M-%S")
70
+ end
71
+
72
+ def escape_path(path)
73
+ File.basename(File.expand_path(path))
74
+ end
75
+ end
76
+
77
+ class EntryView
78
+ class << self
79
+ def render content
80
+ mkd2html(content || "No Entry")
81
+ end
82
+
83
+ def mkd2html text
84
+ html = BlueCloth.new(text).to_html
85
+ html.gsub!(/\[\[(.*?)\]\]/) do |m|
86
+ exists = WikiEntry[$1] ? 'exists' : 'nonexists'
87
+ %{<a href="/#{CGI.escape($1)}" class="#{exists}">#{$1}</a>}
88
+ end
89
+ html
90
+ end
91
+ end
92
+ end
data/examples/wiktacular/src/page.rb ADDED
@@ -0,0 +1,66 @@
1
+ class Page < Ezamar::Element
2
+ def head
3
+ %{
4
+ <html>
5
+ <head>
6
+ <title>Wiktacular</title>
7
+ <link rel="stylesheet" type="text/css" media="screen" href="/screen.css" />
8
+ </head>
9
+ <body>
10
+ }
11
+ end
12
+
13
+ def menu
14
+ %{
15
+ <div id="menu">
16
+ <a href="/main">Home</a>
17
+ <a href="/new">New Entry</a>
18
+ </div>
19
+ }
20
+ end
21
+
22
+ def navigation
23
+ nodes = Dir['mkd/*'].map{|f|
24
+ name = File.basename(f)
25
+ %[<a href="/#{name}">#{name}</a>]
26
+ }.join("\n")
27
+ %{
28
+ <div id="navigation">
29
+ <div id="nodes">
30
+ #{nodes}
31
+ </div>
32
+ </div>
33
+ }
34
+ end
35
+
36
+ def main
37
+ %{
38
+ <div id="manipulate">
39
+ <a href="/edit/\#@handle">Edit</a>
40
+ <a href="/delete/\#@handle">Delete</a>
41
+ <a href="/revert/\#@handle">Revert</a>
42
+ <a href="/unrevert/\#@handle">Unrevert</a>
43
+ </div>
44
+ <div id="content">
45
+ #{content}
46
+ </div>
47
+ }
48
+ end
49
+
50
+ def render
51
+ head +
52
+ menu +
53
+ navigation +
54
+ main +
55
+ footer
56
+ end
57
+
58
+
59
+ def footer
60
+ %{
61
+ <div id="copyright">Wiktacular is powered by <a href="http://ramaze.rubyforge.org/">Ramaze</a></div>
62
+ </body>
63
+ </html>
64
+ }
65
+ end
66
+ end
data/examples/wiktacular/template/edit.xhtml ADDED
@@ -0,0 +1,7 @@
1
+ <Page>
2
+ <form method="POST" action="/save" id="edit_entry">
3
+ <input type="text" name="handle" value="#@handle" />
4
+ <textarea name="text">#@text</textarea>
5
+ <input type="submit" />
6
+ </form>
7
+ </Page>
data/examples/wiktacular/template/index.xhtml ADDED
@@ -0,0 +1,11 @@
1
+ <Page>
2
+ <div id="text">
3
+ #@text
4
+ </div>
5
+ <?r if @history ?>
6
+ <div id="history">
7
+ History of this entry:<br />
8
+ #@history
9
+ </div>
10
+ <?r end ?>
11
+ </Page>
data/examples/wiktacular/template/new.xhtml ADDED
@@ -0,0 +1,7 @@
1
+ <Page>
2
+ <form method="POST" action="/save" id="new_entry">
3
+ <input type="text" name="handle" />
4
+ <textarea name="text"></textarea>
5
+ <input type="submit" />
6
+ </form>
7
+ </Page>
data/lib/proto/main.rb CHANGED
@@ -8,3 +8,5 @@ include Ramaze
8
8
  require 'src/controller/main'
9
9
  require 'src/element/page'
10
10
  require 'src/model'
11
+
12
+ Ramaze.start
data/lib/proto/public/error.zmr CHANGED
@@ -7,6 +7,9 @@
7
7
  <body>
8
8
  <h1>#{@title}</h1>
9
9
 
10
+ <p>The backtrace gives filenames and line numbers for all parts of the call stack.<br />
11
+ Click on any of them to view the surrounding source code.</p>
12
+
10
13
  <table class="main">
11
14
  <tr class="head">
12
15
  <td>File</td><td>Line</td><td>Method</td>
data/lib/proto/public/js/jquery.js CHANGED
@@ -1,91 +1,92 @@
1
- /* prevent execution of jQuery if included more then once */
1
+ // prevent execution of jQuery if included more than once
2
2
  if(typeof window.jQuery == "undefined") {
3
3
  /*
4
- * jQuery 1.0.2 - New Wave Javascript
4
+ * jQuery 1.1.3.1 - New Wave Javascript
5
5
  *
6
- * Copyright (c) 2006 John Resig (jquery.com)
6
+ * Copyright (c) 2007 John Resig (jquery.com)
7
7
  * Dual licensed under the MIT (MIT-LICENSE.txt)
8
8
  * and GPL (GPL-LICENSE.txt) licenses.
9
9
  *
10
- * $Date: 2006-10-09 20:23:18 -0400 (Mon, 09 Oct 2006) $
11
- * $Rev: 413 $
10
+ * $Date: 2007-07-05 00:43:24 -0400 (Thu, 05 Jul 2007) $
11
+ * $Rev: 2243 $
12
12
  */
13
13
 
14
14
  // Global undefined variable
15
15
  window.undefined = window.undefined;
16
- jQuery = function(a,c) {
17
-
18
- // Shortcut for document ready (because $(document).each() is silly)
19
- if ( a && typeof a == "function" && jQuery.fn.ready )
20
- return jQuery(document).ready(a);
21
-
22
- // Make sure that a selection was provided
23
- a = a || jQuery.context || document;
24
-
25
- // Watch for when a jQuery object is passed as the selector
26
- if ( a.jquery )
27
- return jQuery( jQuery.merge( a, [] ) );
28
-
29
- // Watch for when a jQuery object is passed at the context
30
- if ( c && c.jquery )
31
- return jQuery( c ).find(a);
32
-
16
+ var jQuery = function(a,c) {
33
17
  // If the context is global, return a new object
34
- if ( window == this )
18
+ if ( window == this || !this.init )
35
19
  return new jQuery(a,c);
36
-
37
- // Handle HTML strings
38
- var m = /^[^<]*(<.+>)[^>]*$/.exec(a);
39
- if ( m ) a = jQuery.clean( [ m[1] ] );
40
-
41
- // Watch for when an array is passed in
42
- this.get( a.constructor == Array || a.length && !a.nodeType && a[0] != undefined && a[0].nodeType ?
43
- // Assume that it is an array of DOM Elements
44
- jQuery.merge( a, [] ) :
45
-
46
- // Find the matching elements and save them for later
47
- jQuery.find( a, c ) );
48
-
49
- // See if an extra function was provided
50
- var fn = arguments[ arguments.length - 1 ];
51
-
52
- // If so, execute it in context
53
- if ( fn && typeof fn == "function" )
54
- this.each(fn);
20
+
21
+ return this.init(a,c);
55
22
  };
56
23
 
57
24
  // Map over the $ in case of overwrite
58
25
  if ( typeof $ != "undefined" )
59
26
  jQuery._$ = $;
60
-
27
+
61
28
  // Map the jQuery namespace to the '$' one
62
29
  var $ = jQuery;
63
30
 
64
31
  jQuery.fn = jQuery.prototype = {
65
- jquery: "1.0.2",
32
+ init: function(a,c) {
33
+ // Make sure that a selection was provided
34
+ a = a || document;
35
+
36
+ // HANDLE: $(function)
37
+ // Shortcut for document ready
38
+ if ( jQuery.isFunction(a) )
39
+ return new jQuery(document)[ jQuery.fn.ready ? "ready" : "load" ]( a );
40
+
41
+ // Handle HTML strings
42
+ if ( typeof a == "string" ) {
43
+ // HANDLE: $(html) -> $(array)
44
+ var m = /^[^<]*(<(.|\s)+>)[^>]*$/.exec(a);
45
+ if ( m )
46
+ a = jQuery.clean( [ m[1] ] );
47
+
48
+ // HANDLE: $(expr)
49
+ else
50
+ return new jQuery( c ).find( a );
51
+ }
52
+
53
+ return this.setArray(
54
+ // HANDLE: $(array)
55
+ a.constructor == Array && a ||
56
+
57
+ // HANDLE: $(arraylike)
58
+ // Watch for when an array-like object is passed as the selector
59
+ (a.jquery || a.length && a != window && !a.nodeType && a[0] != undefined && a[0].nodeType) && jQuery.makeArray( a ) ||
60
+
61
+ // HANDLE: $(*)
62
+ [ a ] );
63
+ },
64
+ jquery: "1.1.3.1",
66
65
 
67
66
  size: function() {
68
67
  return this.length;
69
68
  },
69
+
70
+ length: 0,
70
71
 
71
72
  get: function( num ) {
72
- // Watch for when an array (of elements) is passed in
73
- if ( num && num.constructor == Array ) {
73
+ return num == undefined ?
74
74
 
75
- // Use a tricky hack to make the jQuery object
76
- // look and feel like an array
77
- this.length = 0;
78
- [].push.apply( this, num );
75
+ // Return a 'clean' array
76
+ jQuery.makeArray( this ) :
79
77
 
80
- return this;
81
- } else
82
- return num == undefined ?
83
-
84
- // Return a 'clean' array
85
- jQuery.merge( this, [] ) :
86
-
87
- // Return just the object
88
- this[num];
78
+ // Return just the object
79
+ this[num];
80
+ },
81
+ pushStack: function( a ) {
82
+ var ret = jQuery(a);
83
+ ret.prevObject = this;
84
+ return ret;
85
+ },
86
+ setArray: function( a ) {
87
+ this.length = 0;
88
+ [].push.apply( this, a );
89
+ return this;
89
90
  },
90
91
  each: function( fn, args ) {
91
92
  return jQuery.each( this, fn, args );
@@ -99,52 +100,56 @@ jQuery.fn = jQuery.prototype = {
99
100
  },
100
101
 
101
102
  attr: function( key, value, type ) {
103
+ var obj = key;
104
+
105
+ // Look for the case where we're accessing a style value
106
+ if ( key.constructor == String )
107
+ if ( value == undefined )
108
+ return this.length && jQuery[ type || "attr" ]( this[0], key ) || undefined;
109
+ else {
110
+ obj = {};
111
+ obj[ key ] = value;
112
+ }
113
+
102
114
  // Check to see if we're setting style values
103
- return key.constructor != String || value != undefined ?
104
- this.each(function(){
105
- // See if we're setting a hash of styles
106
- if ( value == undefined )
107
- // Set all the styles
108
- for ( var prop in key )
109
- jQuery.attr(
110
- type ? this.style : this,
111
- prop, key[prop]
112
- );
113
-
114
- // See if we're setting a single key/value style
115
- else
116
- jQuery.attr(
117
- type ? this.style : this,
118
- key, value
119
- );
120
- }) :
121
-
122
- // Look for the case where we're accessing a style value
123
- jQuery[ type || "attr" ]( this[0], key );
115
+ return this.each(function(index){
116
+ // Set all the styles
117
+ for ( var prop in obj )
118
+ jQuery.attr(
119
+ type ? this.style : this,
120
+ prop, jQuery.prop(this, obj[prop], type, index, prop)
121
+ );
122
+ });
124
123
  },
125
124
 
126
125
  css: function( key, value ) {
127
126
  return this.attr( key, value, "curCSS" );
128
127
  },
128
+
129
129
  text: function(e) {
130
- e = e || this;
130
+ if ( typeof e == "string" )
131
+ return this.empty().append( document.createTextNode( e ) );
132
+
131
133
  var t = "";
132
- for ( var j = 0; j < e.length; j++ ) {
133
- var r = e[j].childNodes;
134
- for ( var i = 0; i < r.length; i++ )
135
- if ( r[i].nodeType != 8 )
136
- t += r[i].nodeType != 1 ?
137
- r[i].nodeValue : jQuery.fn.text([ r[i] ]);
138
- }
134
+ jQuery.each( e || this, function(){
135
+ jQuery.each( this.childNodes, function(){
136
+ if ( this.nodeType != 8 )
137
+ t += this.nodeType != 1 ?
138
+ this.nodeValue : jQuery.fn.text([ this ]);
139
+ });
140
+ });
139
141
  return t;
140
142
  },
141
143
 
142
144
  wrap: function() {
143
145
  // The elements to wrap the target around
144
- var a = jQuery.clean(arguments);
146
+ var a, args = arguments;
145
147
 
146
148
  // Wrap each of the matched elements individually
147
149
  return this.each(function(){
150
+ if ( !a )
151
+ a = jQuery.clean(args, this.ownerDocument);
152
+
148
153
  // Clone the structure that we're using to wrap
149
154
  var b = a[0].cloneNode(true);
150
155
 
@@ -159,215 +164,216 @@ jQuery.fn = jQuery.prototype = {
159
164
  b.appendChild( this );
160
165
  });
161
166
  },
162
-
163
167
  append: function() {
164
168
  return this.domManip(arguments, true, 1, function(a){
165
169
  this.appendChild( a );
166
170
  });
167
171
  },
168
-
169
172
  prepend: function() {
170
173
  return this.domManip(arguments, true, -1, function(a){
171
174
  this.insertBefore( a, this.firstChild );
172
175
  });
173
176
  },
174
-
175
177
  before: function() {
176
178
  return this.domManip(arguments, false, 1, function(a){
177
179
  this.parentNode.insertBefore( a, this );
178
180
  });
179
181
  },
180
-
181
182
  after: function() {
182
183
  return this.domManip(arguments, false, -1, function(a){
183
184
  this.parentNode.insertBefore( a, this.nextSibling );
184
185
  });
185
186
  },
186
187
  end: function() {
187
- return this.get( this.stack.pop() );
188
+ return this.prevObject || jQuery([]);
188
189
  },
189
190
  find: function(t) {
190
- return this.pushStack( jQuery.map( this, function(a){
191
- return jQuery.find(t,a);
192
- }), arguments );
191
+ var data = jQuery.map(this, function(a){ return jQuery.find(t,a); });
192
+ return this.pushStack( /[^+>] [^+>]/.test( t ) || t.indexOf("..") > -1 ?
193
+ jQuery.unique( data ) : data );
193
194
  },
194
195
  clone: function(deep) {
195
- return this.pushStack( jQuery.map( this, function(a){
196
+ // Need to remove events on the element and its descendants
197
+ var $this = this.add(this.find("*"));
198
+ $this.each(function() {
199
+ this._$events = {};
200
+ for (var type in this.$events)
201
+ this._$events[type] = jQuery.extend({},this.$events[type]);
202
+ }).unbind();
203
+
204
+ // Do the clone
205
+ var r = this.pushStack( jQuery.map( this, function(a){
196
206
  return a.cloneNode( deep != undefined ? deep : true );
197
- }), arguments );
207
+ }) );
208
+
209
+ // Add the events back to the original and its descendants
210
+ $this.each(function() {
211
+ var events = this._$events;
212
+ for (var type in events)
213
+ for (var handler in events[type])
214
+ jQuery.event.add(this, type, events[type][handler], events[type][handler].data);
215
+ this._$events = null;
216
+ });
217
+
218
+ // Return the cloned set
219
+ return r;
198
220
  },
199
221
 
200
222
  filter: function(t) {
201
223
  return this.pushStack(
202
- t.constructor == Array &&
203
- jQuery.map(this,function(a){
204
- for ( var i = 0; i < t.length; i++ )
205
- if ( jQuery.filter(t[i],[a]).r.length )
206
- return a;
224
+ jQuery.isFunction( t ) &&
225
+ jQuery.grep(this, function(el, index){
226
+ return t.apply(el, [index])
207
227
  }) ||
208
228
 
209
- t.constructor == Boolean &&
210
- ( t ? this.get() : [] ) ||
211
-
212
- typeof t == "function" &&
213
- jQuery.grep( this, t ) ||
214
-
215
- jQuery.filter(t,this).r, arguments );
229
+ jQuery.multiFilter(t,this) );
216
230
  },
217
231
 
218
232
  not: function(t) {
219
- return this.pushStack( t.constructor == String ?
220
- jQuery.filter(t,this,false).r :
221
- jQuery.grep(this,function(a){ return a != t; }), arguments );
233
+ return this.pushStack(
234
+ t.constructor == String &&
235
+ jQuery.multiFilter(t, this, true) ||
236
+
237
+ jQuery.grep(this, function(a) {
238
+ return ( t.constructor == Array || t.jquery )
239
+ ? jQuery.inArray( a, t ) < 0
240
+ : a != t;
241
+ })
242
+ );
222
243
  },
223
244
 
224
245
  add: function(t) {
225
- return this.pushStack( jQuery.merge( this, t.constructor == String ?
226
- jQuery.find(t) : t.constructor == Array ? t : [t] ), arguments );
246
+ return this.pushStack( jQuery.merge(
247
+ this.get(),
248
+ t.constructor == String ?
249
+ jQuery(t).get() :
250
+ t.length != undefined && (!t.nodeName || t.nodeName == "FORM") ?
251
+ t : [t] )
252
+ );
227
253
  },
228
254
  is: function(expr) {
229
- return expr ? jQuery.filter(expr,this).r.length > 0 : false;
255
+ return expr ? jQuery.multiFilter(expr,this).length > 0 : false;
256
+ },
257
+
258
+ val: function( val ) {
259
+ return val == undefined ?
260
+ ( this.length ? this[0].value : null ) :
261
+ this.attr( "value", val );
262
+ },
263
+
264
+ html: function( val ) {
265
+ return val == undefined ?
266
+ ( this.length ? this[0].innerHTML : null ) :
267
+ this.empty().append( val );
230
268
  },
231
269
  domManip: function(args, table, dir, fn){
232
- var clone = this.size() > 1;
233
- var a = jQuery.clean(args);
270
+ var clone = this.length > 1, a;
234
271
 
235
272
  return this.each(function(){
273
+ if ( !a ) {
274
+ a = jQuery.clean(args, this.ownerDocument);
275
+ if ( dir < 0 )
276
+ a.reverse();
277
+ }
278
+
236
279
  var obj = this;
237
280
 
238
- if ( table && this.nodeName.toUpperCase() == "TABLE" && a[0].nodeName.toUpperCase() != "THEAD" ) {
239
- var tbody = this.getElementsByTagName("tbody");
281
+ if ( table && jQuery.nodeName(this, "table") && jQuery.nodeName(a[0], "tr") )
282
+ obj = this.getElementsByTagName("tbody")[0] || this.appendChild(document.createElement("tbody"));
240
283
 
241
- if ( !tbody.length ) {
242
- obj = document.createElement("tbody");
243
- this.appendChild( obj );
244
- } else
245
- obj = tbody[0];
246
- }
284
+ jQuery.each( a, function(){
285
+ fn.apply( obj, [ clone ? this.cloneNode(true) : this ] );
286
+ });
247
287
 
248
- for ( var i = ( dir < 0 ? a.length - 1 : 0 );
249
- i != ( dir < 0 ? dir : a.length ); i += dir ) {
250
- fn.apply( obj, [ clone ? a[i].cloneNode(true) : a[i] ] );
251
- }
252
288
  });
253
- },
254
- pushStack: function(a,args) {
255
- var fn = args && args[args.length-1];
256
- var fn2 = args && args[args.length-2];
257
-
258
- if ( fn && fn.constructor != Function ) fn = null;
259
- if ( fn2 && fn2.constructor != Function ) fn2 = null;
260
-
261
- if ( !fn ) {
262
- if ( !this.stack ) this.stack = [];
263
- this.stack.push( this.get() );
264
- this.get( a );
265
- } else {
266
- var old = this.get();
267
- this.get( a );
289
+ }
290
+ };
268
291
 
269
- if ( fn2 && a.length || !fn2 )
270
- this.each( fn2 || fn ).get( old );
271
- else
272
- this.get( old ).each( fn );
273
- }
292
+ jQuery.extend = jQuery.fn.extend = function() {
293
+ // copy reference to target object
294
+ var target = arguments[0], a = 1;
274
295
 
275
- return this;
296
+ // extend jQuery itself if only one argument is passed
297
+ if ( arguments.length == 1 ) {
298
+ target = this;
299
+ a = 0;
276
300
  }
277
- };
301
+ var prop;
302
+ while ( (prop = arguments[a++]) != null )
303
+ // Extend the base object
304
+ for ( var i in prop ) target[i] = prop[i];
278
305
 
279
- jQuery.extend = jQuery.fn.extend = function(obj,prop) {
280
- if ( !prop ) { prop = obj; obj = this; }
281
- for ( var i in prop ) obj[i] = prop[i];
282
- return obj;
306
+ // Return the modified object
307
+ return target;
283
308
  };
284
309
 
285
310
  jQuery.extend({
286
- init: function(){
287
- jQuery.initDone = true;
288
-
289
- jQuery.each( jQuery.macros.axis, function(i,n){
290
- jQuery.fn[ i ] = function(a) {
291
- var ret = jQuery.map(this,n);
292
- if ( a && a.constructor == String )
293
- ret = jQuery.filter(a,ret).r;
294
- return this.pushStack( ret, arguments );
295
- };
296
- });
297
-
298
- jQuery.each( jQuery.macros.to, function(i,n){
299
- jQuery.fn[ i ] = function(){
300
- var a = arguments;
301
- return this.each(function(){
302
- for ( var j = 0; j < a.length; j++ )
303
- jQuery(a[j])[n]( this );
304
- });
305
- };
306
- });
307
-
308
- jQuery.each( jQuery.macros.each, function(i,n){
309
- jQuery.fn[ i ] = function() {
310
- return this.each( n, arguments );
311
- };
312
- });
313
-
314
- jQuery.each( jQuery.macros.filter, function(i,n){
315
- jQuery.fn[ n ] = function(num,fn) {
316
- return this.filter( ":" + n + "(" + num + ")", fn );
317
- };
318
- });
319
-
320
- jQuery.each( jQuery.macros.attr, function(i,n){
321
- n = n || i;
322
- jQuery.fn[ i ] = function(h) {
323
- return h == undefined ?
324
- this.length ? this[0][n] : null :
325
- this.attr( n, h );
326
- };
327
- });
311
+ noConflict: function() {
312
+ if ( jQuery._$ )
313
+ $ = jQuery._$;
314
+ return jQuery;
315
+ },
328
316
 
329
- jQuery.each( jQuery.macros.css, function(i,n){
330
- jQuery.fn[ n ] = function(h) {
331
- return h == undefined ?
332
- ( this.length ? jQuery.css( this[0], n ) : null ) :
333
- this.css( n, h );
334
- };
335
- });
317
+ // This may seem like some crazy code, but trust me when I say that this
318
+ // is the only cross-browser way to do this. --John
319
+ isFunction: function( fn ) {
320
+ return !!fn && typeof fn != "string" && !fn.nodeName &&
321
+ fn.constructor != Array && /function/i.test( fn + "" );
322
+ },
323
+
324
+ // check if an element is in a XML document
325
+ isXMLDoc: function(elem) {
326
+ return elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
327
+ },
336
328
 
329
+ nodeName: function( elem, name ) {
330
+ return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
337
331
  },
332
+ // args is for internal usage only
338
333
  each: function( obj, fn, args ) {
339
334
  if ( obj.length == undefined )
340
335
  for ( var i in obj )
341
336
  fn.apply( obj[i], args || [i, obj[i]] );
342
337
  else
343
- for ( var i = 0; i < obj.length; i++ )
344
- fn.apply( obj[i], args || [i, obj[i]] );
338
+ for ( var i = 0, ol = obj.length; i < ol; i++ )
339
+ if ( fn.apply( obj[i], args || [i, obj[i]] ) === false ) break;
345
340
  return obj;
346
341
  },
342
+
343
+ prop: function(elem, value, type, index, prop){
344
+ // Handle executable functions
345
+ if ( jQuery.isFunction( value ) )
346
+ value = value.call( elem, [index] );
347
+
348
+ // exclude the following css properties to add px
349
+ var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i;
350
+
351
+ // Handle passing in a number to a CSS property
352
+ return value && value.constructor == Number && type == "curCSS" && !exclude.test(prop) ?
353
+ value + "px" :
354
+ value;
355
+ },
347
356
 
348
357
  className: {
349
- add: function(o,c){
350
- if (jQuery.className.has(o,c)) return;
351
- o.className += ( o.className ? " " : "" ) + c;
358
+ // internal only, use addClass("class")
359
+ add: function( elem, c ){
360
+ jQuery.each( c.split(/\s+/), function(i, cur){
361
+ if ( !jQuery.className.has( elem.className, cur ) )
362
+ elem.className += ( elem.className ? " " : "" ) + cur;
363
+ });
352
364
  },
353
- remove: function(o,c){
354
- if( !c ) {
355
- o.className = "";
356
- } else {
357
- var classes = o.className.split(" ");
358
- for(var i=0; i<classes.length; i++) {
359
- if(classes[i] == c) {
360
- classes.splice(i, 1);
361
- break;
362
- }
363
- }
364
- o.className = classes.join(' ');
365
- }
365
+
366
+ // internal only, use removeClass("class")
367
+ remove: function( elem, c ){
368
+ elem.className = c != undefined ?
369
+ jQuery.grep( elem.className.split(/\s+/), function(cur){
370
+ return !jQuery.className.has( c, cur );
371
+ }).join(" ") : "";
366
372
  },
367
- has: function(e,a) {
368
- if ( e.className != undefined )
369
- e = e.className;
370
- return new RegExp("(^|\\s)" + a + "(\\s|$)").test(e);
373
+
374
+ // internal only, use is(".class")
375
+ has: function( t, c ) {
376
+ return jQuery.inArray( c, (t.className || t).toString().split(/\s+/) ) > -1;
371
377
  }
372
378
  },
373
379
  swap: function(e,o,f) {
@@ -384,28 +390,30 @@ jQuery.extend({
384
390
  if ( p == "height" || p == "width" ) {
385
391
  var old = {}, oHeight, oWidth, d = ["Top","Bottom","Right","Left"];
386
392
 
387
- for ( var i in d ) {
388
- old["padding" + d[i]] = 0;
389
- old["border" + d[i] + "Width"] = 0;
390
- }
393
+ jQuery.each( d, function(){
394
+ old["padding" + this] = 0;
395
+ old["border" + this + "Width"] = 0;
396
+ });
391
397
 
392
398
  jQuery.swap( e, old, function() {
393
- if (jQuery.css(e,"display") != "none") {
399
+ if ( jQuery(e).is(':visible') ) {
394
400
  oHeight = e.offsetHeight;
395
401
  oWidth = e.offsetWidth;
396
402
  } else {
397
- e = jQuery(e.cloneNode(true)).css({
398
- visibility: "hidden", position: "absolute", display: "block", right: "0", left: "0"
399
- }).appendTo(e.parentNode)[0];
400
-
401
- var parPos = jQuery.css(e.parentNode,"position");
402
- if ( parPos == "" || parPos == "static" )
403
+ e = jQuery(e.cloneNode(true))
404
+ .find(":radio").removeAttr("checked").end()
405
+ .css({
406
+ visibility: "hidden", position: "absolute", display: "block", right: "0", left: "0"
407
+ }).appendTo(e.parentNode)[0];
408
+
409
+ var parPos = jQuery.css(e.parentNode,"position") || "static";
410
+ if ( parPos == "static" )
403
411
  e.parentNode.style.position = "relative";
404
412
 
405
413
  oHeight = e.clientHeight;
406
414
  oWidth = e.clientWidth;
407
415
 
408
- if ( parPos == "" || parPos == "static" )
416
+ if ( parPos == "static" )
409
417
  e.parentNode.style.position = "static";
410
418
 
411
419
  e.parentNode.removeChild(e);
@@ -420,434 +428,218 @@ jQuery.extend({
420
428
 
421
429
  curCSS: function(elem, prop, force) {
422
430
  var ret;
423
-
424
- if (prop == 'opacity' && jQuery.browser.msie)
425
- return jQuery.attr(elem.style, 'opacity');
426
431
 
427
- if (!force && elem.style[prop]) {
432
+ if (prop == "opacity" && jQuery.browser.msie) {
433
+ ret = jQuery.attr(elem.style, "opacity");
434
+ return ret == "" ? "1" : ret;
435
+ }
436
+
437
+ if (prop.match(/float/i))
438
+ prop = jQuery.styleFloat;
428
439
 
440
+ if (!force && elem.style[prop])
429
441
  ret = elem.style[prop];
430
442
 
431
- } else if (elem.currentStyle) {
432
-
433
- var newProp = prop.replace(/\-(\w)/g,function(m,c){return c.toUpperCase();});
434
- ret = elem.currentStyle[prop] || elem.currentStyle[newProp];
443
+ else if (document.defaultView && document.defaultView.getComputedStyle) {
435
444
 
436
- } else if (document.defaultView && document.defaultView.getComputedStyle) {
445
+ if (prop.match(/float/i))
446
+ prop = "float";
437
447
 
438
448
  prop = prop.replace(/([A-Z])/g,"-$1").toLowerCase();
439
449
  var cur = document.defaultView.getComputedStyle(elem, null);
440
450
 
441
451
  if ( cur )
442
452
  ret = cur.getPropertyValue(prop);
443
- else if ( prop == 'display' )
444
- ret = 'none';
453
+ else if ( prop == "display" )
454
+ ret = "none";
445
455
  else
446
- jQuery.swap(elem, { display: 'block' }, function() {
447
- ret = document.defaultView.getComputedStyle(this,null).getPropertyValue(prop);
456
+ jQuery.swap(elem, { display: "block" }, function() {
457
+ var c = document.defaultView.getComputedStyle(this, "");
458
+ ret = c && c.getPropertyValue(prop) || "";
448
459
  });
449
460
 
461
+ } else if (elem.currentStyle) {
462
+ var newProp = prop.replace(/\-(\w)/g,function(m,c){return c.toUpperCase();});
463
+ ret = elem.currentStyle[prop] || elem.currentStyle[newProp];
450
464
  }
451
465
 
452
466
  return ret;
453
467
  },
454
-
455
- clean: function(a) {
468
+
469
+ clean: function(a, doc) {
456
470
  var r = [];
457
- for ( var i = 0; i < a.length; i++ ) {
458
- if ( a[i].constructor == String ) {
459
- // trim whitespace, otherwise indexOf won't work as expected
460
- a[i] = jQuery.trim(a[i]);
461
-
462
- var table = "";
463
-
464
- if ( !a[i].indexOf("<thead") || !a[i].indexOf("<tbody") ) {
465
- table = "thead";
466
- a[i] = "<table>" + a[i] + "</table>";
467
- } else if ( !a[i].indexOf("<tr") ) {
468
- table = "tr";
469
- a[i] = "<table>" + a[i] + "</table>";
470
- } else if ( !a[i].indexOf("<td") || !a[i].indexOf("<th") ) {
471
- table = "td";
472
- a[i] = "<table><tbody><tr>" + a[i] + "</tr></tbody></table>";
473
- }
474
-
475
- var div = document.createElement("div");
476
- div.innerHTML = a[i];
477
-
478
- if ( table ) {
479
- div = div.firstChild;
480
- if ( table != "thead" ) div = div.firstChild;
481
- if ( table == "td" ) div = div.firstChild;
482
- }
483
-
484
- for ( var j = 0; j < div.childNodes.length; j++ )
485
- r.push( div.childNodes[j] );
486
- } else if ( a[i].jquery || a[i].length && !a[i].nodeType )
487
- for ( var k = 0; k < a[i].length; k++ )
488
- r.push( a[i][k] );
489
- else if ( a[i] !== null )
490
- r.push( a[i].nodeType ? a[i] : document.createTextNode(a[i].toString()) );
491
- }
492
- return r;
493
- },
494
-
495
- expr: {
496
- "": "m[2]== '*'||a.nodeName.toUpperCase()==m[2].toUpperCase()",
497
- "#": "a.getAttribute('id')&&a.getAttribute('id')==m[2]",
498
- ":": {
499
- // Position Checks
500
- lt: "i<m[3]-0",
501
- gt: "i>m[3]-0",
502
- nth: "m[3]-0==i",
503
- eq: "m[3]-0==i",
504
- first: "i==0",
505
- last: "i==r.length-1",
506
- even: "i%2==0",
507
- odd: "i%2",
508
-
509
- // Child Checks
510
- "nth-child": "jQuery.sibling(a,m[3]).cur",
511
- "first-child": "jQuery.sibling(a,0).cur",
512
- "last-child": "jQuery.sibling(a,0).last",
513
- "only-child": "jQuery.sibling(a).length==1",
514
-
515
- // Parent Checks
516
- parent: "a.childNodes.length",
517
- empty: "!a.childNodes.length",
518
-
519
- // Text Check
520
- contains: "(a.innerText||a.innerHTML).indexOf(m[3])>=0",
521
-
522
- // Visibility
523
- visible: "a.type!='hidden'&&jQuery.css(a,'display')!='none'&&jQuery.css(a,'visibility')!='hidden'",
524
- hidden: "a.type=='hidden'||jQuery.css(a,'display')=='none'||jQuery.css(a,'visibility')=='hidden'",
525
-
526
- // Form attributes
527
- enabled: "!a.disabled",
528
- disabled: "a.disabled",
529
- checked: "a.checked",
530
- selected: "a.selected || jQuery.attr(a, 'selected')",
531
-
532
- // Form elements
533
- text: "a.type=='text'",
534
- radio: "a.type=='radio'",
535
- checkbox: "a.type=='checkbox'",
536
- file: "a.type=='file'",
537
- password: "a.type=='password'",
538
- submit: "a.type=='submit'",
539
- image: "a.type=='image'",
540
- reset: "a.type=='reset'",
541
- button: "a.type=='button'",
542
- input: "a.nodeName.toLowerCase().match(/input|select|textarea|button/)"
543
- },
544
- ".": "jQuery.className.has(a,m[2])",
545
- "@": {
546
- "=": "z==m[4]",
547
- "!=": "z!=m[4]",
548
- "^=": "z && !z.indexOf(m[4])",
549
- "$=": "z && z.substr(z.length - m[4].length,m[4].length)==m[4]",
550
- "*=": "z && z.indexOf(m[4])>=0",
551
- "": "z"
552
- },
553
- "[": "jQuery.find(m[2],a).length"
554
- },
471
+ doc = doc || document;
555
472
 
556
- token: [
557
- "\\.\\.|/\\.\\.", "a.parentNode",
558
- ">|/", "jQuery.sibling(a.firstChild)",
559
- "\\+", "jQuery.sibling(a).next",
560
- "~", function(a){
561
- var r = [];
562
- var s = jQuery.sibling(a);
563
- if ( s.n > 0 )
564
- for ( var i = s.n; i < s.length; i++ )
565
- r.push( s[i] );
566
- return r;
567
- }
568
- ],
569
- find: function( t, context ) {
570
- // Make sure that the context is a DOM Element
571
- if ( context && context.nodeType == undefined )
572
- context = null;
573
-
574
- // Set the correct context (if none is provided)
575
- context = context || jQuery.context || document;
576
-
577
- if ( t.constructor != String ) return [t];
578
-
579
- if ( !t.indexOf("//") ) {
580
- context = context.documentElement;
581
- t = t.substr(2,t.length);
582
- } else if ( !t.indexOf("/") ) {
583
- context = context.documentElement;
584
- t = t.substr(1,t.length);
585
- // FIX Assume the root element is right :(
586
- if ( t.indexOf("/") >= 1 )
587
- t = t.substr(t.indexOf("/"),t.length);
588
- }
589
-
590
- var ret = [context];
591
- var done = [];
592
- var last = null;
593
-
594
- while ( t.length > 0 && last != t ) {
595
- var r = [];
596
- last = t;
597
-
598
- t = jQuery.trim(t).replace( /^\/\//i, "" );
599
-
600
- var foundToken = false;
601
-
602
- for ( var i = 0; i < jQuery.token.length; i += 2 ) {
603
- if ( foundToken ) continue;
473
+ jQuery.each( a, function(i,arg){
474
+ if ( !arg ) return;
604
475
 
605
- var re = new RegExp("^(" + jQuery.token[i] + ")");
606
- var m = re.exec(t);
607
-
608
- if ( m ) {
609
- r = ret = jQuery.map( ret, jQuery.token[i+1] );
610
- t = jQuery.trim( t.replace( re, "" ) );
611
- foundToken = true;
612
- }
613
- }
476
+ if ( arg.constructor == Number )
477
+ arg = arg.toString();
478
+
479
+ // Convert html string into DOM nodes
480
+ if ( typeof arg == "string" ) {
481
+ // Trim whitespace, otherwise indexOf won't work as expected
482
+ var s = jQuery.trim(arg).toLowerCase(), div = doc.createElement("div"), tb = [];
483
+
484
+ var wrap =
485
+ // option or optgroup
486
+ !s.indexOf("<opt") &&
487
+ [1, "<select>", "</select>"] ||
488
+
489
+ !s.indexOf("<leg") &&
490
+ [1, "<fieldset>", "</fieldset>"] ||
491
+
492
+ (!s.indexOf("<thead") || !s.indexOf("<tbody") || !s.indexOf("<tfoot") || !s.indexOf("<colg")) &&
493
+ [1, "<table>", "</table>"] ||
494
+
495
+ !s.indexOf("<tr") &&
496
+ [2, "<table><tbody>", "</tbody></table>"] ||
497
+
498
+ // <thead> matched above
499
+ (!s.indexOf("<td") || !s.indexOf("<th")) &&
500
+ [3, "<table><tbody><tr>", "</tr></tbody></table>"] ||
501
+
502
+ !s.indexOf("<col") &&
503
+ [2, "<table><colgroup>", "</colgroup></table>"] ||
504
+
505
+ [0,"",""];
614
506
 
615
- if ( !foundToken ) {
616
- if ( !t.indexOf(",") || !t.indexOf("|") ) {
617
- if ( ret[0] == context ) ret.shift();
618
- done = jQuery.merge( done, ret );
619
- r = ret = [context];
620
- t = " " + t.substr(1,t.length);
621
- } else {
622
- var re2 = /^([#.]?)([a-z0-9\\*_-]*)/i;
623
- var m = re2.exec(t);
507
+ // Go to html and back, then peel off extra wrappers
508
+ div.innerHTML = wrap[1] + arg + wrap[2];
509
+
510
+ // Move to the right depth
511
+ while ( wrap[0]-- )
512
+ div = div.firstChild;
513
+
514
+ // Remove IE's autoinserted <tbody> from table fragments
515
+ if ( jQuery.browser.msie ) {
516
+
517
+ // String was a <table>, *may* have spurious <tbody>
518
+ if ( !s.indexOf("<table") && s.indexOf("<tbody") < 0 )
519
+ tb = div.firstChild && div.firstChild.childNodes;
520
+
521
+ // String was a bare <thead> or <tfoot>
522
+ else if ( wrap[1] == "<table>" && s.indexOf("<tbody") < 0 )
523
+ tb = div.childNodes;
624
524
 
625
- if ( m[1] == "#" ) {
626
- // Ummm, should make this work in all XML docs
627
- var oid = document.getElementById(m[2]);
628
- r = ret = oid ? [oid] : [];
629
- t = t.replace( re2, "" );
630
- } else {
631
- if ( !m[2] || m[1] == "." ) m[2] = "*";
632
-
633
- for ( var i = 0; i < ret.length; i++ )
634
- r = jQuery.merge( r,
635
- m[2] == "*" ?
636
- jQuery.getAll(ret[i]) :
637
- ret[i].getElementsByTagName(m[2])
638
- );
639
- }
525
+ for ( var n = tb.length-1; n >= 0 ; --n )
526
+ if ( jQuery.nodeName(tb[n], "tbody") && !tb[n].childNodes.length )
527
+ tb[n].parentNode.removeChild(tb[n]);
528
+
640
529
  }
641
-
530
+
531
+ arg = jQuery.makeArray( div.childNodes );
642
532
  }
643
533
 
644
- if ( t ) {
645
- var val = jQuery.filter(t,r);
646
- ret = r = val.r;
647
- t = jQuery.trim(val.t);
648
- }
649
- }
534
+ if ( 0 === arg.length && (!jQuery.nodeName(arg, "form") && !jQuery.nodeName(arg, "select")) )
535
+ return;
650
536
 
651
- if ( ret && ret[0] == context ) ret.shift();
652
- done = jQuery.merge( done, ret );
537
+ if ( arg[0] == undefined || jQuery.nodeName(arg, "form") || arg.options )
538
+ r.push( arg );
539
+ else
540
+ r = jQuery.merge( r, arg );
653
541
 
654
- return done;
655
- },
542
+ });
656
543
 
657
- getAll: function(o,r) {
658
- r = r || [];
659
- var s = o.childNodes;
660
- for ( var i = 0; i < s.length; i++ )
661
- if ( s[i].nodeType == 1 ) {
662
- r.push( s[i] );
663
- jQuery.getAll( s[i], r );
664
- }
665
544
  return r;
666
545
  },
667
-
546
+
668
547
  attr: function(elem, name, value){
669
- var fix = {
670
- "for": "htmlFor",
671
- "class": "className",
672
- "float": "cssFloat",
673
- innerHTML: "innerHTML",
674
- className: "className",
675
- value: "value",
676
- disabled: "disabled",
677
- checked: "checked"
678
- };
679
-
680
- // IE actually uses filters for opacity ... elem is actually elem.style
681
- if (name == "opacity" && jQuery.browser.msie && value != undefined) {
682
- // IE has trouble with opacity if it does not have layout
683
- // Would prefer to check element.hasLayout first but don't have access to the element here
684
- elem['zoom'] = 1;
685
- if (value == 1) // Remove filter to avoid more IE weirdness
686
- return elem["filter"] = elem["filter"].replace(/alpha\([^\)]*\)/gi,"");
687
- else
688
- return elem["filter"] = elem["filter"].replace(/alpha\([^\)]*\)/gi,"") + "alpha(opacity=" + value * 100 + ")";
689
- } else if (name == "opacity" && jQuery.browser.msie) {
690
- return elem["filter"] ? parseFloat( elem["filter"].match(/alpha\(opacity=(.*)\)/)[1] )/100 : 1;
691
- }
548
+ var fix = jQuery.isXMLDoc(elem) ? {} : jQuery.props;
692
549
 
693
- // Mozilla doesn't play well with opacity 1
694
- if (name == "opacity" && jQuery.browser.mozilla && value == 1) value = 0.9999;
695
-
550
+ // Certain attributes only work when accessed via the old DOM 0 way
696
551
  if ( fix[name] ) {
697
552
  if ( value != undefined ) elem[fix[name]] = value;
698
553
  return elem[fix[name]];
699
- } else if( value == undefined && jQuery.browser.msie && elem.nodeName && elem.nodeName.toUpperCase() == 'FORM' && (name == 'action' || name == 'method') ) {
554
+
555
+ } else if ( value == undefined && jQuery.browser.msie && jQuery.nodeName(elem, "form") && (name == "action" || name == "method") )
700
556
  return elem.getAttributeNode(name).nodeValue;
701
- } else if ( elem.getAttribute != undefined ) {
557
+
558
+ // IE elem.getAttribute passes even for style
559
+ else if ( elem.tagName ) {
560
+
561
+
702
562
  if ( value != undefined ) elem.setAttribute( name, value );
703
- return elem.getAttribute( name, 2 );
563
+ if ( jQuery.browser.msie && /href|src/.test(name) && !jQuery.isXMLDoc(elem) )
564
+ return elem.getAttribute( name, 2 );
565
+ return elem.getAttribute( name );
566
+
567
+ // elem is actually elem.style ... set the style
704
568
  } else {
569
+ // IE actually uses filters for opacity
570
+ if ( name == "opacity" && jQuery.browser.msie ) {
571
+ if ( value != undefined ) {
572
+ // IE has trouble with opacity if it does not have layout
573
+ // Force it by setting the zoom level
574
+ elem.zoom = 1;
575
+
576
+ // Set the alpha filter to set the opacity
577
+ elem.filter = (elem.filter || "").replace(/alpha\([^)]*\)/,"") +
578
+ (parseFloat(value).toString() == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
579
+ }
580
+
581
+ return elem.filter ?
582
+ (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100).toString() : "";
583
+ }
705
584
  name = name.replace(/-([a-z])/ig,function(z,b){return b.toUpperCase();});
706
585
  if ( value != undefined ) elem[name] = value;
707
586
  return elem[name];
708
587
  }
709
588
  },
589
+ trim: function(t){
590
+ return t.replace(/^\s+|\s+$/g, "");
591
+ },
710
592
 
711
- // The regular expressions that power the parsing engine
712
- parse: [
713
- // Match: [@value='test'], [@foo]
714
- "\\[ *(@)S *([!*$^=]*) *('?\"?)(.*?)\\4 *\\]",
715
-
716
- // Match: [div], [div p]
717
- "(\\[)\s*(.*?)\s*\\]",
593
+ makeArray: function( a ) {
594
+ var r = [];
718
595
 
719
- // Match: :contains('foo')
720
- "(:)S\\(\"?'?([^\\)]*?)\"?'?\\)",
596
+ // Need to use typeof to fight Safari childNodes crashes
597
+ if ( typeof a != "array" )
598
+ for ( var i = 0, al = a.length; i < al; i++ )
599
+ r.push( a[i] );
600
+ else
601
+ r = a.slice( 0 );
721
602
 
722
- // Match: :even, :last-chlid
723
- "([:.#]*)S"
724
- ],
603
+ return r;
604
+ },
725
605
 
726
- filter: function(t,r,not) {
727
- // Figure out if we're doing regular, or inverse, filtering
728
- var g = not !== false ? jQuery.grep :
729
- function(a,f) {return jQuery.grep(a,f,true);};
730
-
731
- while ( t && /^[a-z[({<*:.#]/i.test(t) ) {
732
-
733
- var p = jQuery.parse;
734
-
735
- for ( var i = 0; i < p.length; i++ ) {
736
-
737
- // Look for, and replace, string-like sequences
738
- // and finally build a regexp out of it
739
- var re = new RegExp(
740
- "^" + p[i].replace("S", "([a-z*_-][a-z0-9_-]*)"), "i" );
741
-
742
- var m = re.exec( t );
743
-
744
- if ( m ) {
745
- // Re-organize the first match
746
- if ( !i )
747
- m = ["",m[1], m[3], m[2], m[5]];
748
-
749
- // Remove what we just matched
750
- t = t.replace( re, "" );
751
-
752
- break;
753
- }
754
- }
755
-
756
- // :not() is a special case that can be optimized by
757
- // keeping it out of the expression list
758
- if ( m[1] == ":" && m[2] == "not" )
759
- r = jQuery.filter(m[3],r,false).r;
760
-
761
- // Otherwise, find the expression to execute
762
- else {
763
- var f = jQuery.expr[m[1]];
764
- if ( f.constructor != String )
765
- f = jQuery.expr[m[1]][m[2]];
766
-
767
- // Build a custom macro to enclose it
768
- eval("f = function(a,i){" +
769
- ( m[1] == "@" ? "z=jQuery.attr(a,m[3]);" : "" ) +
770
- "return " + f + "}");
771
-
772
- // Execute it against the current filter
773
- r = g( r, f );
774
- }
775
- }
776
-
777
- // Return an array of filtered elements (r)
778
- // and the modified expression string (t)
779
- return { r: r, t: t };
780
- },
781
- trim: function(t){
782
- return t.replace(/^\s+|\s+$/g, "");
606
+ inArray: function( b, a ) {
607
+ for ( var i = 0, al = a.length; i < al; i++ )
608
+ if ( a[i] == b )
609
+ return i;
610
+ return -1;
783
611
  },
784
- parents: function( elem ){
785
- var matched = [];
786
- var cur = elem.parentNode;
787
- while ( cur && cur != document ) {
788
- matched.push( cur );
789
- cur = cur.parentNode;
790
- }
791
- return matched;
792
- },
793
- sibling: function(elem, pos, not) {
794
- var elems = [];
795
-
796
- if(elem) {
797
- var siblings = elem.parentNode.childNodes;
798
- for ( var i = 0; i < siblings.length; i++ ) {
799
- if ( not === true && siblings[i] == elem ) continue;
800
-
801
- if ( siblings[i].nodeType == 1 )
802
- elems.push( siblings[i] );
803
- if ( siblings[i] == elem )
804
- elems.n = elems.length - 1;
612
+ merge: function(first, second) {
613
+ // We have to loop this way because IE & Opera overwrite the length
614
+ // expando of getElementsByTagName
615
+ for ( var i = 0; second[i]; i++ )
616
+ first.push(second[i]);
617
+ return first;
618
+ },
619
+ unique: function(first) {
620
+ var r = [], num = jQuery.mergeNum++;
621
+
622
+ for ( var i = 0, fl = first.length; i < fl; i++ )
623
+ if ( num != first[i].mergeNum ) {
624
+ first[i].mergeNum = num;
625
+ r.push(first[i]);
805
626
  }
806
- }
807
627
 
808
- return jQuery.extend( elems, {
809
- last: elems.n == elems.length - 1,
810
- cur: pos == "even" && elems.n % 2 == 0 || pos == "odd" && elems.n % 2 || elems[pos] == elem,
811
- prev: elems[elems.n - 1],
812
- next: elems[elems.n + 1]
813
- });
628
+ return r;
814
629
  },
815
- merge: function(first, second) {
816
- var result = [];
817
630
 
818
- // Move b over to the new array (this helps to avoid
819
- // StaticNodeList instances)
820
- for ( var k = 0; k < first.length; k++ )
821
- result[k] = first[k];
822
-
823
- // Now check for duplicates between a and b and only
824
- // add the unique items
825
- for ( var i = 0; i < second.length; i++ ) {
826
- var noCollision = true;
827
-
828
- // The collision-checking process
829
- for ( var j = 0; j < first.length; j++ )
830
- if ( second[i] == first[j] )
831
- noCollision = false;
832
-
833
- // If the item is unique, add it
834
- if ( noCollision )
835
- result.push( second[i] );
836
- }
837
-
838
- return result;
839
- },
631
+ mergeNum: 0,
840
632
  grep: function(elems, fn, inv) {
841
633
  // If a string is passed in for the function, make a function
842
634
  // for it (a handy shortcut)
843
- if ( fn.constructor == String )
635
+ if ( typeof fn == "string" )
844
636
  fn = new Function("a","i","return " + fn);
845
637
 
846
638
  var result = [];
847
639
 
848
640
  // Go through the array, only saving the items
849
641
  // that pass the validator function
850
- for ( var i = 0; i < elems.length; i++ )
642
+ for ( var i = 0, el = elems.length; i < el; i++ )
851
643
  if ( !inv && fn(elems[i],i) || inv && !fn(elems[i],i) )
852
644
  result.push( elems[i] );
853
645
 
@@ -856,295 +648,866 @@ jQuery.extend({
856
648
  map: function(elems, fn) {
857
649
  // If a string is passed in for the function, make a function
858
650
  // for it (a handy shortcut)
859
- if ( fn.constructor == String )
651
+ if ( typeof fn == "string" )
860
652
  fn = new Function("a","return " + fn);
861
653
 
862
654
  var result = [];
863
655
 
864
656
  // Go through the array, translating each of the items to their
865
657
  // new value (or values).
866
- for ( var i = 0; i < elems.length; i++ ) {
658
+ for ( var i = 0, el = elems.length; i < el; i++ ) {
867
659
  var val = fn(elems[i],i);
868
660
 
869
661
  if ( val !== null && val != undefined ) {
870
662
  if ( val.constructor != Array ) val = [val];
871
- result = jQuery.merge( result, val );
663
+ result = result.concat( val );
872
664
  }
873
665
  }
874
666
 
875
667
  return result;
668
+ }
669
+ });
670
+
671
+ /*
672
+ * Whether the W3C compliant box model is being used.
673
+ *
674
+ * @property
675
+ * @name $.boxModel
676
+ * @type Boolean
677
+ * @cat JavaScript
678
+ */
679
+ new function() {
680
+ var b = navigator.userAgent.toLowerCase();
681
+
682
+ // Figure out what browser is being used
683
+ jQuery.browser = {
684
+ version: (b.match(/.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/) || [])[1],
685
+ safari: /webkit/.test(b),
686
+ opera: /opera/.test(b),
687
+ msie: /msie/.test(b) && !/opera/.test(b),
688
+ mozilla: /mozilla/.test(b) && !/(compatible|webkit)/.test(b)
689
+ };
690
+
691
+ // Check to see if the W3C box model is being used
692
+ jQuery.boxModel = !jQuery.browser.msie || document.compatMode == "CSS1Compat";
693
+
694
+ jQuery.styleFloat = jQuery.browser.msie ? "styleFloat" : "cssFloat",
695
+
696
+ jQuery.props = {
697
+ "for": "htmlFor",
698
+ "class": "className",
699
+ "float": jQuery.styleFloat,
700
+ cssFloat: jQuery.styleFloat,
701
+ styleFloat: jQuery.styleFloat,
702
+ innerHTML: "innerHTML",
703
+ className: "className",
704
+ value: "value",
705
+ disabled: "disabled",
706
+ checked: "checked",
707
+ readonly: "readOnly",
708
+ selected: "selected",
709
+ maxlength: "maxLength"
710
+ };
711
+ };
712
+
713
+ jQuery.each({
714
+ parent: "a.parentNode",
715
+ parents: "jQuery.parents(a)",
716
+ next: "jQuery.nth(a,2,'nextSibling')",
717
+ prev: "jQuery.nth(a,2,'previousSibling')",
718
+ siblings: "jQuery.sibling(a.parentNode.firstChild,a)",
719
+ children: "jQuery.sibling(a.firstChild)"
720
+ }, function(i,n){
721
+ jQuery.fn[ i ] = function(a) {
722
+ var ret = jQuery.map(this,n);
723
+ if ( a && typeof a == "string" )
724
+ ret = jQuery.multiFilter(a,ret);
725
+ return this.pushStack( ret );
726
+ };
727
+ });
728
+
729
+ jQuery.each({
730
+ appendTo: "append",
731
+ prependTo: "prepend",
732
+ insertBefore: "before",
733
+ insertAfter: "after"
734
+ }, function(i,n){
735
+ jQuery.fn[ i ] = function(){
736
+ var a = arguments;
737
+ return this.each(function(){
738
+ for ( var j = 0, al = a.length; j < al; j++ )
739
+ jQuery(a[j])[n]( this );
740
+ });
741
+ };
742
+ });
743
+
744
+ jQuery.each( {
745
+ removeAttr: function( key ) {
746
+ jQuery.attr( this, key, "" );
747
+ this.removeAttribute( key );
748
+ },
749
+ addClass: function(c){
750
+ jQuery.className.add(this,c);
751
+ },
752
+ removeClass: function(c){
753
+ jQuery.className.remove(this,c);
876
754
  },
755
+ toggleClass: function( c ){
756
+ jQuery.className[ jQuery.className.has(this,c) ? "remove" : "add" ](this, c);
757
+ },
758
+ remove: function(a){
759
+ if ( !a || jQuery.filter( a, [this] ).r.length )
760
+ this.parentNode.removeChild( this );
761
+ },
762
+ empty: function() {
763
+ while ( this.firstChild )
764
+ this.removeChild( this.firstChild );
765
+ }
766
+ }, function(i,n){
767
+ jQuery.fn[ i ] = function() {
768
+ return this.each( n, arguments );
769
+ };
770
+ });
877
771
 
878
- /*
879
- * A number of helper functions used for managing events.
880
- * Many of the ideas behind this code orignated from Dean Edwards' addEvent library.
881
- */
882
- event: {
883
-
884
- // Bind an event to an element
885
- // Original by Dean Edwards
886
- add: function(element, type, handler) {
887
- // For whatever reason, IE has trouble passing the window object
888
- // around, causing it to be cloned in the process
889
- if ( jQuery.browser.msie && element.setInterval != undefined )
890
- element = window;
891
-
892
- // Make sure that the function being executed has a unique ID
893
- if ( !handler.guid )
894
- handler.guid = this.guid++;
895
-
896
- // Init the element's event structure
897
- if (!element.events)
898
- element.events = {};
899
-
900
- // Get the current list of functions bound to this event
901
- var handlers = element.events[type];
902
-
903
- // If it hasn't been initialized yet
904
- if (!handlers) {
905
- // Init the event handler queue
906
- handlers = element.events[type] = {};
907
-
908
- // Remember an existing handler, if it's already there
909
- if (element["on" + type])
910
- handlers[0] = element["on" + type];
911
- }
772
+ jQuery.each( [ "eq", "lt", "gt", "contains" ], function(i,n){
773
+ jQuery.fn[ n ] = function(num,fn) {
774
+ return this.filter( ":" + n + "(" + num + ")", fn );
775
+ };
776
+ });
777
+
778
+ jQuery.each( [ "height", "width" ], function(i,n){
779
+ jQuery.fn[ n ] = function(h) {
780
+ return h == undefined ?
781
+ ( this.length ? jQuery.css( this[0], n ) : null ) :
782
+ this.css( n, h.constructor == String ? h : h + "px" );
783
+ };
784
+ });
785
+ jQuery.extend({
786
+ expr: {
787
+ "": "m[2]=='*'||jQuery.nodeName(a,m[2])",
788
+ "#": "a.getAttribute('id')==m[2]",
789
+ ":": {
790
+ // Position Checks
791
+ lt: "i<m[3]-0",
792
+ gt: "i>m[3]-0",
793
+ nth: "m[3]-0==i",
794
+ eq: "m[3]-0==i",
795
+ first: "i==0",
796
+ last: "i==r.length-1",
797
+ even: "i%2==0",
798
+ odd: "i%2",
912
799
 
913
- // Add the function to the element's handler list
914
- handlers[handler.guid] = handler;
800
+ // Child Checks
801
+ "first-child": "a.parentNode.getElementsByTagName('*')[0]==a",
802
+ "last-child": "jQuery.nth(a.parentNode.lastChild,1,'previousSibling')==a",
803
+ "only-child": "!jQuery.nth(a.parentNode.lastChild,2,'previousSibling')",
915
804
 
916
- // And bind the global event handler to the element
917
- element["on" + type] = this.handle;
805
+ // Parent Checks
806
+ parent: "a.firstChild",
807
+ empty: "!a.firstChild",
918
808
 
919
- // Remember the function in a global list (for triggering)
920
- if (!this.global[type])
921
- this.global[type] = [];
922
- this.global[type].push( element );
923
- },
809
+ // Text Check
810
+ contains: "(a.textContent||a.innerText||'').indexOf(m[3])>=0",
924
811
 
925
- guid: 1,
926
- global: {},
812
+ // Visibility
813
+ visible: '"hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden"',
814
+ hidden: '"hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden"',
927
815
 
928
- // Detach an event or set of events from an element
929
- remove: function(element, type, handler) {
930
- if (element.events)
931
- if (type && element.events[type])
932
- if ( handler )
933
- delete element.events[type][handler.guid];
934
- else
935
- for ( var i in element.events[type] )
936
- delete element.events[type][i];
937
- else
938
- for ( var j in element.events )
939
- this.remove( element, j );
816
+ // Form attributes
817
+ enabled: "!a.disabled",
818
+ disabled: "a.disabled",
819
+ checked: "a.checked",
820
+ selected: "a.selected||jQuery.attr(a,'selected')",
821
+
822
+ // Form elements
823
+ text: "'text'==a.type",
824
+ radio: "'radio'==a.type",
825
+ checkbox: "'checkbox'==a.type",
826
+ file: "'file'==a.type",
827
+ password: "'password'==a.type",
828
+ submit: "'submit'==a.type",
829
+ image: "'image'==a.type",
830
+ reset: "'reset'==a.type",
831
+ button: '"button"==a.type||jQuery.nodeName(a,"button")',
832
+ input: "/input|select|textarea|button/i.test(a.nodeName)"
940
833
  },
834
+ "[": "jQuery.find(m[2],a).length"
835
+ },
836
+
837
+ // The regular expressions that power the parsing engine
838
+ parse: [
839
+ // Match: [@value='test'], [@foo]
840
+ /^\[ *(@)([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,
941
841
 
942
- trigger: function(type,data,element) {
943
- // Touch up the incoming data
944
- data = data || [];
842
+ // Match: [div], [div p]
843
+ /^(\[)\s*(.*?(\[.*?\])?[^[]*?)\s*\]/,
945
844
 
946
- // Handle a global trigger
947
- if ( !element ) {
948
- var g = this.global[type];
949
- if ( g )
950
- for ( var i = 0; i < g.length; i++ )
951
- this.trigger( type, data, g[i] );
845
+ // Match: :contains('foo')
846
+ /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,
952
847
 
953
- // Handle triggering a single element
954
- } else if ( element["on" + type] ) {
955
- // Pass along a fake event
956
- data.unshift( this.fix({ type: type, target: element }) );
848
+ // Match: :even, :last-chlid, #id, .class
849
+ new RegExp("^([:.#]*)(" +
850
+ ( jQuery.chars = jQuery.browser.safari && jQuery.browser.version < "3.0.0" ? "\\w" : "(?:[\\w\u0128-\uFFFF*_-]|\\\\.)" ) + "+)")
851
+ ],
957
852
 
958
- // Trigger the event
959
- element["on" + type].apply( element, data );
960
- }
961
- },
853
+ multiFilter: function( expr, elems, not ) {
854
+ var old, cur = [];
855
+
856
+ while ( expr && expr != old ) {
857
+ old = expr;
858
+ var f = jQuery.filter( expr, elems, not );
859
+ expr = f.t.replace(/^\s*,\s*/, "" );
860
+ cur = not ? elems = f.r : jQuery.merge( cur, f.r );
861
+ }
862
+
863
+ return cur;
864
+ },
865
+ find: function( t, context ) {
866
+ // Quickly handle non-string expressions
867
+ if ( typeof t != "string" )
868
+ return [ t ];
869
+
870
+ // Make sure that the context is a DOM Element
871
+ if ( context && !context.nodeType )
872
+ context = null;
873
+
874
+ // Set the correct context (if none is provided)
875
+ context = context || document;
876
+
877
+ // Handle the common XPath // expression
878
+ if ( !t.indexOf("//") ) {
879
+ context = context.documentElement;
880
+ t = t.substr(2,t.length);
881
+
882
+ // And the / root expression
883
+ } else if ( !t.indexOf("/") && !context.ownerDocument ) {
884
+ context = context.documentElement;
885
+ t = t.substr(1,t.length);
886
+ if ( t.indexOf("/") >= 1 )
887
+ t = t.substr(t.indexOf("/"),t.length);
888
+ }
962
889
 
963
- handle: function(event) {
964
- if ( typeof jQuery == "undefined" ) return;
890
+ // Initialize the search
891
+ var ret = [context], done = [], last;
892
+
893
+ // Continue while a selector expression exists, and while
894
+ // we're no longer looping upon ourselves
895
+ while ( t && last != t ) {
896
+ var r = [];
897
+ last = t;
965
898
 
966
- event = event || jQuery.event.fix( window.event );
899
+ t = jQuery.trim(t).replace( /^\/\//, "" );
967
900
 
968
- // If no correct event was found, fail
969
- if ( !event ) return;
901
+ var foundToken = false;
970
902
 
971
- var returnValue = true;
903
+ // An attempt at speeding up child selectors that
904
+ // point to a specific element tag
905
+ var re = new RegExp("^[/>]\\s*(" + jQuery.chars + "+)");
906
+ var m = re.exec(t);
972
907
 
973
- var c = this.events[event.type];
908
+ if ( m ) {
909
+ var nodeName = m[1].toUpperCase();
974
910
 
975
- var args = [].slice.call( arguments, 1 );
976
- args.unshift( event );
911
+ // Perform our own iteration and filter
912
+ for ( var i = 0; ret[i]; i++ )
913
+ for ( var c = ret[i].firstChild; c; c = c.nextSibling )
914
+ if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName.toUpperCase()) )
915
+ r.push( c );
977
916
 
978
- for ( var j in c ) {
979
- if ( c[j].apply( this, args ) === false ) {
980
- event.preventDefault();
981
- event.stopPropagation();
982
- returnValue = false;
917
+ ret = r;
918
+ t = t.replace( re, "" );
919
+ if ( t.indexOf(" ") == 0 ) continue;
920
+ foundToken = true;
921
+ } else {
922
+ re = /^((\/?\.\.)|([>\/+~]))\s*([a-z]*)/i;
923
+
924
+ if ( (m = re.exec(t)) != null ) {
925
+ r = [];
926
+
927
+ var nodeName = m[4], mergeNum = jQuery.mergeNum++;
928
+ m = m[1];
929
+
930
+ for ( var j = 0, rl = ret.length; j < rl; j++ )
931
+ if ( m.indexOf("..") < 0 ) {
932
+ var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild;
933
+ for ( ; n; n = n.nextSibling )
934
+ if ( n.nodeType == 1 ) {
935
+ if ( m == "~" && n.mergeNum == mergeNum ) break;
936
+
937
+ if (!nodeName || n.nodeName.toUpperCase() == nodeName.toUpperCase() ) {
938
+ if ( m == "~" ) n.mergeNum = mergeNum;
939
+ r.push( n );
940
+ }
941
+
942
+ if ( m == "+" ) break;
943
+ }
944
+ } else
945
+ r.push( ret[j].parentNode );
946
+
947
+ ret = r;
948
+
949
+ // And remove the token
950
+ t = jQuery.trim( t.replace( re, "" ) );
951
+ foundToken = true;
983
952
  }
984
953
  }
985
954
 
986
- return returnValue;
987
- },
955
+ // See if there's still an expression, and that we haven't already
956
+ // matched a token
957
+ if ( t && !foundToken ) {
958
+ // Handle multiple expressions
959
+ if ( !t.indexOf(",") ) {
960
+ // Clean the result set
961
+ if ( context == ret[0] ) ret.shift();
962
+
963
+ // Merge the result sets
964
+ done = jQuery.merge( done, ret );
965
+
966
+ // Reset the context
967
+ r = ret = [context];
968
+
969
+ // Touch up the selector string
970
+ t = " " + t.substr(1,t.length);
971
+
972
+ } else {
973
+ // Optomize for the case nodeName#idName
974
+ var re2 = new RegExp("^(" + jQuery.chars + "+)(#)(" + jQuery.chars + "+)");
975
+ var m = re2.exec(t);
976
+
977
+ // Re-organize the results, so that they're consistent
978
+ if ( m ) {
979
+ m = [ 0, m[2], m[3], m[1] ];
980
+
981
+ } else {
982
+ // Otherwise, do a traditional filter check for
983
+ // ID, class, and element selectors
984
+ re2 = new RegExp("^([#.]?)(" + jQuery.chars + "*)");
985
+ m = re2.exec(t);
986
+ }
987
+
988
+ m[2] = m[2].replace(/\\/g, "");
989
+
990
+ var elem = ret[ret.length-1];
991
+
992
+ // Try to do a global search by ID, where we can
993
+ if ( m[1] == "#" && elem && elem.getElementById ) {
994
+ // Optimization for HTML document case
995
+ var oid = elem.getElementById(m[2]);
996
+
997
+ // Do a quick check for the existence of the actual ID attribute
998
+ // to avoid selecting by the name attribute in IE
999
+ // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
1000
+ if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
1001
+ oid = jQuery('[@id="'+m[2]+'"]', elem)[0];
1002
+
1003
+ // Do a quick check for node name (where applicable) so
1004
+ // that div#foo searches will be really fast
1005
+ ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
1006
+ } else {
1007
+ // We need to find all descendant elements
1008
+ for ( var i = 0; ret[i]; i++ ) {
1009
+ // Grab the tag name being searched for
1010
+ var tag = m[1] != "" || m[0] == "" ? "*" : m[2];
1011
+
1012
+ // Handle IE7 being really dumb about <object>s
1013
+ if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
1014
+ tag = "param";
1015
+
1016
+ r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
1017
+ }
1018
+
1019
+ // It's faster to filter by class and be done with it
1020
+ if ( m[1] == "." )
1021
+ r = jQuery.classFilter( r, m[2] );
1022
+
1023
+ // Same with ID filtering
1024
+ if ( m[1] == "#" ) {
1025
+ var tmp = [];
1026
+
1027
+ // Try to find the element with the ID
1028
+ for ( var i = 0; r[i]; i++ )
1029
+ if ( r[i].getAttribute("id") == m[2] ) {
1030
+ tmp = [ r[i] ];
1031
+ break;
1032
+ }
988
1033
 
989
- fix: function(event) {
990
- if ( event ) {
991
- event.preventDefault = function() {
992
- this.returnValue = false;
993
- };
1034
+ r = tmp;
1035
+ }
1036
+
1037
+ ret = r;
1038
+ }
1039
+
1040
+ t = t.replace( re2, "" );
1041
+ }
994
1042
 
995
- event.stopPropagation = function() {
996
- this.cancelBubble = true;
997
- };
998
1043
  }
999
1044
 
1000
- return event;
1045
+ // If a selector string still exists
1046
+ if ( t ) {
1047
+ // Attempt to filter it
1048
+ var val = jQuery.filter(t,r);
1049
+ ret = r = val.r;
1050
+ t = jQuery.trim(val.t);
1051
+ }
1001
1052
  }
1002
1053
 
1003
- }
1004
- });
1005
- new function() {
1006
- var b = navigator.userAgent.toLowerCase();
1054
+ // An error occurred with the selector;
1055
+ // just return an empty set instead
1056
+ if ( t )
1057
+ ret = [];
1007
1058
 
1008
- // Figure out what browser is being used
1009
- jQuery.browser = {
1010
- safari: /webkit/.test(b),
1011
- opera: /opera/.test(b),
1012
- msie: /msie/.test(b) && !/opera/.test(b),
1013
- mozilla: /mozilla/.test(b) && !/(compatible|webkit)/.test(b)
1014
- };
1059
+ // Remove the root context
1060
+ if ( ret && context == ret[0] )
1061
+ ret.shift();
1015
1062
 
1016
- // Check to see if the W3C box model is being used
1017
- jQuery.boxModel = !jQuery.browser.msie || document.compatMode == "CSS1Compat";
1018
- };
1063
+ // And combine the results
1064
+ done = jQuery.merge( done, ret );
1019
1065
 
1020
- jQuery.macros = {
1021
- to: {
1022
- appendTo: "append",
1023
- prependTo: "prepend",
1024
- insertBefore: "before",
1025
- insertAfter: "after"
1066
+ return done;
1026
1067
  },
1027
1068
 
1028
- css: "width,height,top,left,position,float,overflow,color,background".split(","),
1069
+ classFilter: function(r,m,not){
1070
+ m = " " + m + " ";
1071
+ var tmp = [];
1072
+ for ( var i = 0; r[i]; i++ ) {
1073
+ var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
1074
+ if ( !not && pass || not && !pass )
1075
+ tmp.push( r[i] );
1076
+ }
1077
+ return tmp;
1078
+ },
1029
1079
 
1030
- filter: [ "eq", "lt", "gt", "contains" ],
1080
+ filter: function(t,r,not) {
1081
+ var last;
1031
1082
 
1032
- attr: {
1083
+ // Look for common filter expressions
1084
+ while ( t && t != last ) {
1085
+ last = t;
1033
1086
 
1034
- val: "value",
1087
+ var p = jQuery.parse, m;
1035
1088
 
1036
- html: "innerHTML",
1089
+ for ( var i = 0; p[i]; i++ ) {
1090
+ m = p[i].exec( t );
1037
1091
 
1038
- id: null,
1092
+ if ( m ) {
1093
+ // Remove what we just matched
1094
+ t = t.substring( m[0].length );
1039
1095
 
1040
- title: null,
1096
+ m[2] = m[2].replace(/\\/g, "");
1097
+ break;
1098
+ }
1099
+ }
1041
1100
 
1042
- name: null,
1101
+ if ( !m )
1102
+ break;
1043
1103
 
1044
- href: null,
1104
+ // :not() is a special case that can be optimized by
1105
+ // keeping it out of the expression list
1106
+ if ( m[1] == ":" && m[2] == "not" )
1107
+ r = jQuery.filter(m[3], r, true).r;
1108
+
1109
+ // We can get a big speed boost by filtering by class here
1110
+ else if ( m[1] == "." )
1111
+ r = jQuery.classFilter(r, m[2], not);
1112
+
1113
+ else if ( m[1] == "@" ) {
1114
+ var tmp = [], type = m[3];
1115
+
1116
+ for ( var i = 0, rl = r.length; i < rl; i++ ) {
1117
+ var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];
1118
+
1119
+ if ( z == null || /href|src/.test(m[2]) )
1120
+ z = jQuery.attr(a,m[2]) || '';
1121
+
1122
+ if ( (type == "" && !!z ||
1123
+ type == "=" && z == m[5] ||
1124
+ type == "!=" && z != m[5] ||
1125
+ type == "^=" && z && !z.indexOf(m[5]) ||
1126
+ type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
1127
+ (type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
1128
+ tmp.push( a );
1129
+ }
1130
+
1131
+ r = tmp;
1132
+
1133
+ // We can get a speed boost by handling nth-child here
1134
+ } else if ( m[1] == ":" && m[2] == "nth-child" ) {
1135
+ var num = jQuery.mergeNum++, tmp = [],
1136
+ test = /(\d*)n\+?(\d*)/.exec(
1137
+ m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
1138
+ !/\D/.test(m[3]) && "n+" + m[3] || m[3]),
1139
+ first = (test[1] || 1) - 0, last = test[2] - 0;
1140
+
1141
+ for ( var i = 0, rl = r.length; i < rl; i++ ) {
1142
+ var node = r[i], parentNode = node.parentNode;
1143
+
1144
+ if ( num != parentNode.mergeNum ) {
1145
+ var c = 1;
1146
+
1147
+ for ( var n = parentNode.firstChild; n; n = n.nextSibling )
1148
+ if ( n.nodeType == 1 )
1149
+ n.nodeIndex = c++;
1150
+
1151
+ parentNode.mergeNum = num;
1152
+ }
1153
+
1154
+ var add = false;
1155
+
1156
+ if ( first == 1 ) {
1157
+ if ( last == 0 || node.nodeIndex == last )
1158
+ add = true;
1159
+ } else if ( (node.nodeIndex + last) % first == 0 )
1160
+ add = true;
1161
+
1162
+ if ( add ^ not )
1163
+ tmp.push( node );
1164
+ }
1165
+
1166
+ r = tmp;
1167
+
1168
+ // Otherwise, find the expression to execute
1169
+ } else {
1170
+ var f = jQuery.expr[m[1]];
1171
+ if ( typeof f != "string" )
1172
+ f = jQuery.expr[m[1]][m[2]];
1173
+
1174
+ // Build a custom macro to enclose it
1175
+ eval("f = function(a,i){return " + f + "}");
1045
1176
 
1046
- src: null,
1177
+ // Execute it against the current filter
1178
+ r = jQuery.grep( r, f, not );
1179
+ }
1180
+ }
1047
1181
 
1048
- rel: null
1182
+ // Return an array of filtered elements (r)
1183
+ // and the modified expression string (t)
1184
+ return { r: r, t: t };
1049
1185
  },
1186
+ parents: function( elem ){
1187
+ var matched = [];
1188
+ var cur = elem.parentNode;
1189
+ while ( cur && cur != document ) {
1190
+ matched.push( cur );
1191
+ cur = cur.parentNode;
1192
+ }
1193
+ return matched;
1194
+ },
1195
+ nth: function(cur,result,dir,elem){
1196
+ result = result || 1;
1197
+ var num = 0;
1050
1198
 
1051
- axis: {
1199
+ for ( ; cur; cur = cur[dir] )
1200
+ if ( cur.nodeType == 1 && ++num == result )
1201
+ break;
1052
1202
 
1053
- parent: "a.parentNode",
1203
+ return cur;
1204
+ },
1205
+ sibling: function( n, elem ) {
1206
+ var r = [];
1054
1207
 
1055
- ancestors: jQuery.parents,
1208
+ for ( ; n; n = n.nextSibling ) {
1209
+ if ( n.nodeType == 1 && (!elem || n != elem) )
1210
+ r.push( n );
1211
+ }
1056
1212
 
1057
- parents: jQuery.parents,
1213
+ return r;
1214
+ }
1215
+ });
1216
+ /*
1217
+ * A number of helper functions used for managing events.
1218
+ * Many of the ideas behind this code orignated from
1219
+ * Dean Edwards' addEvent library.
1220
+ */
1221
+ jQuery.event = {
1222
+
1223
+ // Bind an event to an element
1224
+ // Original by Dean Edwards
1225
+ add: function(element, type, handler, data) {
1226
+ // For whatever reason, IE has trouble passing the window object
1227
+ // around, causing it to be cloned in the process
1228
+ if ( jQuery.browser.msie && element.setInterval != undefined )
1229
+ element = window;
1230
+
1231
+ // Make sure that the function being executed has a unique ID
1232
+ if ( !handler.guid )
1233
+ handler.guid = this.guid++;
1234
+
1235
+ // if data is passed, bind to handler
1236
+ if( data != undefined ) {
1237
+ // Create temporary function pointer to original handler
1238
+ var fn = handler;
1239
+
1240
+ // Create unique handler function, wrapped around original handler
1241
+ handler = function() {
1242
+ // Pass arguments and context to original handler
1243
+ return fn.apply(this, arguments);
1244
+ };
1058
1245
 
1059
- next: "jQuery.sibling(a).next",
1246
+ // Store data in unique handler
1247
+ handler.data = data;
1060
1248
 
1061
- prev: "jQuery.sibling(a).prev",
1249
+ // Set the guid of unique handler to the same of original handler, so it can be removed
1250
+ handler.guid = fn.guid;
1251
+ }
1062
1252
 
1063
- siblings: "jQuery.sibling(a, null, true)",
1253
+ // Init the element's event structure
1254
+ if (!element.$events)
1255
+ element.$events = {};
1256
+
1257
+ if (!element.$handle)
1258
+ element.$handle = function() {
1259
+ // returned undefined or false
1260
+ var val;
1261
+
1262
+ // Handle the second event of a trigger and when
1263
+ // an event is called after a page has unloaded
1264
+ if ( typeof jQuery == "undefined" || jQuery.event.triggered )
1265
+ return val;
1266
+
1267
+ val = jQuery.event.handle.apply(element, arguments);
1268
+
1269
+ return val;
1270
+ };
1064
1271
 
1065
- children: "jQuery.sibling(a.firstChild)"
1272
+ // Get the current list of functions bound to this event
1273
+ var handlers = element.$events[type];
1274
+
1275
+ // Init the event handler queue
1276
+ if (!handlers) {
1277
+ handlers = element.$events[type] = {};
1278
+
1279
+ // And bind the global event handler to the element
1280
+ if (element.addEventListener)
1281
+ element.addEventListener(type, element.$handle, false);
1282
+ else
1283
+ element.attachEvent("on" + type, element.$handle);
1284
+ }
1285
+
1286
+ // Add the function to the element's handler list
1287
+ handlers[handler.guid] = handler;
1288
+
1289
+ // Remember the function in a global list (for triggering)
1290
+ if (!this.global[type])
1291
+ this.global[type] = [];
1292
+ // Only add the element to the global list once
1293
+ if (jQuery.inArray(element, this.global[type]) == -1)
1294
+ this.global[type].push( element );
1066
1295
  },
1067
1296
 
1068
- each: {
1069
- removeAttr: function( key ) {
1070
- this.removeAttribute( key );
1071
- },
1072
- show: function(){
1073
- this.style.display = this.oldblock ? this.oldblock : "";
1074
- if ( jQuery.css(this,"display") == "none" )
1075
- this.style.display = "block";
1076
- },
1077
- hide: function(){
1078
- this.oldblock = this.oldblock || jQuery.css(this,"display");
1079
- if ( this.oldblock == "none" )
1080
- this.oldblock = "block";
1081
- this.style.display = "none";
1082
- },
1083
- toggle: function(){
1084
- jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ].apply( jQuery(this), arguments );
1085
- },
1086
- addClass: function(c){
1087
- jQuery.className.add(this,c);
1088
- },
1089
- removeClass: function(c){
1090
- jQuery.className.remove(this,c);
1091
- },
1092
- toggleClass: function( c ){
1093
- jQuery.className[ jQuery.className.has(this,c) ? "remove" : "add" ](this,c);
1094
- },
1297
+ guid: 1,
1298
+ global: {},
1095
1299
 
1096
- remove: function(a){
1097
- if ( !a || jQuery.filter( a, [this] ).r )
1098
- this.parentNode.removeChild( this );
1099
- },
1100
- empty: function(){
1101
- while ( this.firstChild )
1102
- this.removeChild( this.firstChild );
1103
- },
1104
- bind: function( type, fn ) {
1105
- if ( fn.constructor == String )
1106
- fn = new Function("e", ( !fn.indexOf(".") ? "jQuery(this)" : "return " ) + fn);
1107
- jQuery.event.add( this, type, fn );
1108
- },
1300
+ // Detach an event or set of events from an element
1301
+ remove: function(element, type, handler) {
1302
+ var events = element.$events, ret, index;
1109
1303
 
1110
- unbind: function( type, fn ) {
1111
- jQuery.event.remove( this, type, fn );
1112
- },
1113
- trigger: function( type, data ) {
1114
- jQuery.event.trigger( type, data, this );
1304
+ if ( events ) {
1305
+ // type is actually an event object here
1306
+ if ( type && type.type ) {
1307
+ handler = type.handler;
1308
+ type = type.type;
1309
+ }
1310
+
1311
+ if ( !type ) {
1312
+ for ( type in events )
1313
+ this.remove( element, type );
1314
+
1315
+ } else if ( events[type] ) {
1316
+ // remove the given handler for the given type
1317
+ if ( handler )
1318
+ delete events[type][handler.guid];
1319
+
1320
+ // remove all handlers for the given type
1321
+ else
1322
+ for ( handler in element.$events[type] )
1323
+ delete events[type][handler];
1324
+
1325
+ // remove generic event handler if no more handlers exist
1326
+ for ( ret in events[type] ) break;
1327
+ if ( !ret ) {
1328
+ if (element.removeEventListener)
1329
+ element.removeEventListener(type, element.$handle, false);
1330
+ else
1331
+ element.detachEvent("on" + type, element.$handle);
1332
+ ret = null;
1333
+ delete events[type];
1334
+
1335
+ // Remove element from the global event type cache
1336
+ while ( this.global[type] && ( (index = jQuery.inArray(element, this.global[type])) >= 0 ) )
1337
+ delete this.global[type][index];
1338
+ }
1339
+ }
1340
+
1341
+ // Remove the expando if it's no longer used
1342
+ for ( ret in events ) break;
1343
+ if ( !ret )
1344
+ element.$handle = element.$events = null;
1345
+ }
1346
+ },
1347
+
1348
+ trigger: function(type, data, element) {
1349
+ // Clone the incoming data, if any
1350
+ data = jQuery.makeArray(data || []);
1351
+
1352
+ // Handle a global trigger
1353
+ if ( !element )
1354
+ jQuery.each( this.global[type] || [], function(){
1355
+ jQuery.event.trigger( type, data, this );
1356
+ });
1357
+
1358
+ // Handle triggering a single element
1359
+ else {
1360
+ var val, ret, fn = jQuery.isFunction( element[ type ] || null );
1361
+
1362
+ // Pass along a fake event
1363
+ data.unshift( this.fix({ type: type, target: element }) );
1364
+
1365
+ // Trigger the event
1366
+ if ( jQuery.isFunction(element.$handle) && (val = element.$handle.apply( element, data )) !== false )
1367
+ this.triggered = true;
1368
+
1369
+ if ( fn && val !== false && !jQuery.nodeName(element, 'a') )
1370
+ element[ type ]();
1371
+
1372
+ this.triggered = false;
1373
+ }
1374
+ },
1375
+
1376
+ handle: function(event) {
1377
+ // returned undefined or false
1378
+ var val;
1379
+
1380
+ // Empty object is for triggered events with no data
1381
+ event = jQuery.event.fix( event || window.event || {} );
1382
+
1383
+ var c = this.$events && this.$events[event.type], args = [].slice.call( arguments, 1 );
1384
+ args.unshift( event );
1385
+
1386
+ for ( var j in c ) {
1387
+ // Pass in a reference to the handler function itself
1388
+ // So that we can later remove it
1389
+ args[0].handler = c[j];
1390
+ args[0].data = c[j].data;
1391
+
1392
+ if ( c[j].apply( this, args ) === false ) {
1393
+ event.preventDefault();
1394
+ event.stopPropagation();
1395
+ val = false;
1396
+ }
1397
+ }
1398
+
1399
+ // Clean up added properties in IE to prevent memory leak
1400
+ if (jQuery.browser.msie)
1401
+ event.target = event.preventDefault = event.stopPropagation =
1402
+ event.handler = event.data = null;
1403
+
1404
+ return val;
1405
+ },
1406
+
1407
+ fix: function(event) {
1408
+ // store a copy of the original event object
1409
+ // and clone to set read-only properties
1410
+ var originalEvent = event;
1411
+ event = jQuery.extend({}, originalEvent);
1412
+
1413
+ // add preventDefault and stopPropagation since
1414
+ // they will not work on the clone
1415
+ event.preventDefault = function() {
1416
+ // if preventDefault exists run it on the original event
1417
+ if (originalEvent.preventDefault)
1418
+ return originalEvent.preventDefault();
1419
+ // otherwise set the returnValue property of the original event to false (IE)
1420
+ originalEvent.returnValue = false;
1421
+ };
1422
+ event.stopPropagation = function() {
1423
+ // if stopPropagation exists run it on the original event
1424
+ if (originalEvent.stopPropagation)
1425
+ return originalEvent.stopPropagation();
1426
+ // otherwise set the cancelBubble property of the original event to true (IE)
1427
+ originalEvent.cancelBubble = true;
1428
+ };
1429
+
1430
+ // Fix target property, if necessary
1431
+ if ( !event.target && event.srcElement )
1432
+ event.target = event.srcElement;
1433
+
1434
+ // check if target is a textnode (safari)
1435
+ if (jQuery.browser.safari && event.target.nodeType == 3)
1436
+ event.target = originalEvent.target.parentNode;
1437
+
1438
+ // Add relatedTarget, if necessary
1439
+ if ( !event.relatedTarget && event.fromElement )
1440
+ event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
1441
+
1442
+ // Calculate pageX/Y if missing and clientX/Y available
1443
+ if ( event.pageX == null && event.clientX != null ) {
1444
+ var e = document.documentElement, b = document.body;
1445
+ event.pageX = event.clientX + (e && e.scrollLeft || b.scrollLeft);
1446
+ event.pageY = event.clientY + (e && e.scrollTop || b.scrollTop);
1115
1447
  }
1448
+
1449
+ // Add which for key events
1450
+ if ( !event.which && (event.charCode || event.keyCode) )
1451
+ event.which = event.charCode || event.keyCode;
1452
+
1453
+ // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
1454
+ if ( !event.metaKey && event.ctrlKey )
1455
+ event.metaKey = event.ctrlKey;
1456
+
1457
+ // Add which for click: 1 == left; 2 == middle; 3 == right
1458
+ // Note: button is not normalized, so don't use it
1459
+ if ( !event.which && event.button )
1460
+ event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
1461
+
1462
+ return event;
1116
1463
  }
1117
1464
  };
1118
1465
 
1119
- jQuery.init();
1120
1466
  jQuery.fn.extend({
1467
+ bind: function( type, data, fn ) {
1468
+ return type == "unload" ? this.one(type, data, fn) : this.each(function(){
1469
+ jQuery.event.add( this, type, fn || data, fn && data );
1470
+ });
1471
+ },
1472
+ one: function( type, data, fn ) {
1473
+ return this.each(function(){
1474
+ jQuery.event.add( this, type, function(event) {
1475
+ jQuery(this).unbind(event);
1476
+ return (fn || data).apply( this, arguments);
1477
+ }, fn && data);
1478
+ });
1479
+ },
1480
+ unbind: function( type, fn ) {
1481
+ return this.each(function(){
1482
+ jQuery.event.remove( this, type, fn );
1483
+ });
1484
+ },
1485
+ trigger: function( type, data ) {
1486
+ return this.each(function(){
1487
+ jQuery.event.trigger( type, data, this );
1488
+ });
1489
+ },
1490
+ toggle: function() {
1491
+ // Save reference to arguments for access in closure
1492
+ var a = arguments;
1121
1493
 
1122
- // We're overriding the old toggle function, so
1123
- // remember it for later
1124
- _toggle: jQuery.fn.toggle,
1125
- toggle: function(a,b) {
1126
- // If two functions are passed in, we're
1127
- // toggling on a click
1128
- return a && b && a.constructor == Function && b.constructor == Function ? this.click(function(e){
1494
+ return this.click(function(e) {
1129
1495
  // Figure out which function to execute
1130
- this.last = this.last == a ? b : a;
1496
+ this.lastToggle = 0 == this.lastToggle ? 1 : 0;
1131
1497
 
1132
1498
  // Make sure that clicks stop
1133
1499
  e.preventDefault();
1134
1500
 
1135
1501
  // and execute the function
1136
- return this.last.apply( this, [e] ) || false;
1137
- }) :
1138
-
1139
- // Otherwise, execute the old toggle function
1140
- this._toggle.apply( this, arguments );
1502
+ return a[this.lastToggle].apply( this, [e] ) || false;
1503
+ });
1141
1504
  },
1142
1505
  hover: function(f,g) {
1143
1506
 
1144
- // A private function for haandling mouse 'hovering'
1507
+ // A private function for handling mouse 'hovering'
1145
1508
  function handleHover(e) {
1146
1509
  // Check if mouse(over|out) are still within the same parent element
1147
- var p = (e.type == "mouseover" ? e.fromElement : e.toElement) || e.relatedTarget;
1510
+ var p = e.relatedTarget;
1148
1511
 
1149
1512
  // Traverse up the tree
1150
1513
  while ( p && p != this ) try { p = p.parentNode } catch(e) { p = this; };
@@ -1163,13 +1526,12 @@ jQuery.fn.extend({
1163
1526
  // If the DOM is already ready
1164
1527
  if ( jQuery.isReady )
1165
1528
  // Execute the function immediately
1166
- f.apply( document );
1529
+ f.apply( document, [jQuery] );
1167
1530
 
1168
1531
  // Otherwise, remember the function for later
1169
- else {
1532
+ else
1170
1533
  // Add the function to the wait list
1171
- jQuery.readyList.push( f );
1172
- }
1534
+ jQuery.readyList.push( function() { return f.apply(this, [jQuery]) } );
1173
1535
 
1174
1536
  return this;
1175
1537
  }
@@ -1192,67 +1554,45 @@ jQuery.extend({
1192
1554
  // If there are functions bound, to execute
1193
1555
  if ( jQuery.readyList ) {
1194
1556
  // Execute all of them
1195
- for ( var i = 0; i < jQuery.readyList.length; i++ )
1196
- jQuery.readyList[i].apply( document );
1557
+ jQuery.each( jQuery.readyList, function(){
1558
+ this.apply( document );
1559
+ });
1197
1560
 
1198
1561
  // Reset the list of functions
1199
1562
  jQuery.readyList = null;
1200
1563
  }
1201
- // Remove event lisenter to avoid memory leak
1564
+ // Remove event listener to avoid memory leak
1202
1565
  if ( jQuery.browser.mozilla || jQuery.browser.opera )
1203
1566
  document.removeEventListener( "DOMContentLoaded", jQuery.ready, false );
1567
+
1568
+ // Remove script element used by IE hack
1569
+ if( !window.frames.length ) // don't remove if frames are present (#1187)
1570
+ jQuery(window).load(function(){ jQuery("#__ie_init").remove(); });
1204
1571
  }
1205
1572
  }
1206
1573
  });
1207
1574
 
1208
1575
  new function(){
1209
1576
 
1210
- var e = ("blur,focus,load,resize,scroll,unload,click,dblclick," +
1211
- "mousedown,mouseup,mousemove,mouseover,mouseout,change,reset,select," +
1212
- "submit,keydown,keypress,keyup,error").split(",");
1213
-
1214
- // Go through all the event names, but make sure that
1215
- // it is enclosed properly
1216
- for ( var i = 0; i < e.length; i++ ) new function(){
1217
-
1218
- var o = e[i];
1577
+ jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
1578
+ "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
1579
+ "submit,keydown,keypress,keyup,error").split(","), function(i,o){
1219
1580
 
1220
1581
  // Handle event binding
1221
1582
  jQuery.fn[o] = function(f){
1222
1583
  return f ? this.bind(o, f) : this.trigger(o);
1223
1584
  };
1224
-
1225
- // Handle event unbinding
1226
- jQuery.fn["un"+o] = function(f){ return this.unbind(o, f); };
1227
-
1228
- // Finally, handle events that only fire once
1229
- jQuery.fn["one"+o] = function(f){
1230
- // Attach the event listener
1231
- return this.each(function(){
1232
-
1233
- var count = 0;
1234
-
1235
- // Add the event
1236
- jQuery.event.add( this, o, function(e){
1237
- // If this function has already been executed, stop
1238
- if ( count++ ) return;
1239
-
1240
- // And execute the bound function
1241
- return f.apply(this, [e]);
1242
- });
1243
- });
1244
- };
1245
1585
 
1246
- };
1586
+ });
1247
1587
 
1248
1588
  // If Mozilla is used
1249
- if ( jQuery.browser.mozilla || jQuery.browser.opera ) {
1589
+ if ( jQuery.browser.mozilla || jQuery.browser.opera )
1250
1590
  // Use the handy event callback
1251
1591
  document.addEventListener( "DOMContentLoaded", jQuery.ready, false );
1252
1592
 
1253
1593
  // If IE is used, use the excellent hack by Matthias Miller
1254
1594
  // http://www.outofhanwell.com/blog/index.php?title=the_window_onload_problem_revisited
1255
- } else if ( jQuery.browser.msie ) {
1595
+ else if ( jQuery.browser.msie ) {
1256
1596
 
1257
1597
  // Only works if you document.write() it
1258
1598
  document.write("<scr" + "ipt id=__ie_init defer=true " +
@@ -1260,17 +1600,19 @@ new function(){
1260
1600
 
1261
1601
  // Use the defer script hack
1262
1602
  var script = document.getElementById("__ie_init");
1263
- script.onreadystatechange = function() {
1264
- if ( this.readyState != "complete" ) return;
1265
- this.parentNode.removeChild( this );
1266
- jQuery.ready();
1267
- };
1603
+
1604
+ // script does not exist if jQuery is loaded dynamically
1605
+ if ( script )
1606
+ script.onreadystatechange = function() {
1607
+ if ( this.readyState != "complete" ) return;
1608
+ jQuery.ready();
1609
+ };
1268
1610
 
1269
1611
  // Clear from memory
1270
1612
  script = null;
1271
1613
 
1272
1614
  // If Safari is used
1273
- } else if ( jQuery.browser.safari ) {
1615
+ } else if ( jQuery.browser.safari )
1274
1616
  // Continually check to see if the document.readyState is valid
1275
1617
  jQuery.safariTimer = setInterval(function(){
1276
1618
  // loaded and complete are both valid states
@@ -1284,8 +1626,7 @@ new function(){
1284
1626
  // and execute any waiting functions
1285
1627
  jQuery.ready();
1286
1628
  }
1287
- }, 10);
1288
- }
1629
+ }, 10);
1289
1630
 
1290
1631
  // A fallback to window.onload, that will always work
1291
1632
  jQuery.event.add( window, "load", jQuery.ready );
@@ -1293,72 +1634,483 @@ new function(){
1293
1634
  };
1294
1635
 
1295
1636
  // Clean up after IE to avoid memory leaks
1296
- if (jQuery.browser.msie) jQuery(window).unload(function() {
1297
- var event = jQuery.event, global = event.global;
1298
- for (var type in global) {
1299
- var els = global[type], i = els.length;
1300
- if (i>0) do if (type != 'unload') event.remove(els[i-1], type); while (--i);
1637
+ if (jQuery.browser.msie)
1638
+ jQuery(window).one("unload", function() {
1639
+ var global = jQuery.event.global;
1640
+ for ( var type in global ) {
1641
+ var els = global[type], i = els.length;
1642
+ if ( i && type != 'unload' )
1643
+ do
1644
+ els[i-1] && jQuery.event.remove(els[i-1], type);
1645
+ while (--i);
1646
+ }
1647
+ });
1648
+ jQuery.fn.extend({
1649
+ loadIfModified: function( url, params, callback ) {
1650
+ this.load( url, params, callback, 1 );
1651
+ },
1652
+ load: function( url, params, callback, ifModified ) {
1653
+ if ( jQuery.isFunction( url ) )
1654
+ return this.bind("load", url);
1655
+
1656
+ callback = callback || function(){};
1657
+
1658
+ // Default to a GET request
1659
+ var type = "GET";
1660
+
1661
+ // If the second parameter was provided
1662
+ if ( params )
1663
+ // If it's a function
1664
+ if ( jQuery.isFunction( params ) ) {
1665
+ // We assume that it's the callback
1666
+ callback = params;
1667
+ params = null;
1668
+
1669
+ // Otherwise, build a param string
1670
+ } else {
1671
+ params = jQuery.param( params );
1672
+ type = "POST";
1673
+ }
1674
+
1675
+ var self = this;
1676
+
1677
+ // Request the remote document
1678
+ jQuery.ajax({
1679
+ url: url,
1680
+ type: type,
1681
+ data: params,
1682
+ ifModified: ifModified,
1683
+ complete: function(res, status){
1684
+ if ( status == "success" || !ifModified && status == "notmodified" )
1685
+ // Inject the HTML into all the matched elements
1686
+ self.attr("innerHTML", res.responseText)
1687
+ // Execute all the scripts inside of the newly-injected HTML
1688
+ .evalScripts()
1689
+ // Execute callback
1690
+ .each( callback, [res.responseText, status, res] );
1691
+ else
1692
+ callback.apply( self, [res.responseText, status, res] );
1693
+ }
1694
+ });
1695
+ return this;
1696
+ },
1697
+ serialize: function() {
1698
+ return jQuery.param( this );
1699
+ },
1700
+ evalScripts: function() {
1701
+ return this.find("script").each(function(){
1702
+ if ( this.src )
1703
+ jQuery.getScript( this.src );
1704
+ else
1705
+ jQuery.globalEval( this.text || this.textContent || this.innerHTML || "" );
1706
+ }).end();
1301
1707
  }
1708
+
1302
1709
  });
1303
- jQuery.fn.extend({
1304
1710
 
1305
- // overwrite the old show method
1306
- _show: jQuery.fn.show,
1711
+ // Attach a bunch of functions for handling common AJAX events
1307
1712
 
1308
- show: function(speed,callback){
1309
- return speed ? this.animate({
1310
- height: "show", width: "show", opacity: "show"
1311
- }, speed, callback) : this._show();
1713
+ jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
1714
+ jQuery.fn[o] = function(f){
1715
+ return this.bind(o, f);
1716
+ };
1717
+ });
1718
+
1719
+ jQuery.extend({
1720
+ get: function( url, data, callback, type, ifModified ) {
1721
+ // shift arguments if data argument was ommited
1722
+ if ( jQuery.isFunction( data ) ) {
1723
+ callback = data;
1724
+ data = null;
1725
+ }
1726
+
1727
+ return jQuery.ajax({
1728
+ type: "GET",
1729
+ url: url,
1730
+ data: data,
1731
+ success: callback,
1732
+ dataType: type,
1733
+ ifModified: ifModified
1734
+ });
1735
+ },
1736
+ getIfModified: function( url, data, callback, type ) {
1737
+ return jQuery.get(url, data, callback, type, 1);
1738
+ },
1739
+ getScript: function( url, callback ) {
1740
+ return jQuery.get(url, null, callback, "script");
1741
+ },
1742
+ getJSON: function( url, data, callback ) {
1743
+ return jQuery.get(url, data, callback, "json");
1744
+ },
1745
+ post: function( url, data, callback, type ) {
1746
+ if ( jQuery.isFunction( data ) ) {
1747
+ callback = data;
1748
+ data = {};
1749
+ }
1750
+
1751
+ return jQuery.ajax({
1752
+ type: "POST",
1753
+ url: url,
1754
+ data: data,
1755
+ success: callback,
1756
+ dataType: type
1757
+ });
1758
+ },
1759
+ ajaxTimeout: function( timeout ) {
1760
+ jQuery.ajaxSettings.timeout = timeout;
1761
+ },
1762
+ ajaxSetup: function( settings ) {
1763
+ jQuery.extend( jQuery.ajaxSettings, settings );
1764
+ },
1765
+
1766
+ ajaxSettings: {
1767
+ global: true,
1768
+ type: "GET",
1769
+ timeout: 0,
1770
+ contentType: "application/x-www-form-urlencoded",
1771
+ processData: true,
1772
+ async: true,
1773
+ data: null
1774
+ },
1775
+
1776
+ // Last-Modified header cache for next request
1777
+ lastModified: {},
1778
+ ajax: function( s ) {
1779
+ // TODO introduce global settings, allowing the client to modify them for all requests, not only timeout
1780
+ s = jQuery.extend({}, jQuery.ajaxSettings, s);
1781
+
1782
+ // if data available
1783
+ if ( s.data ) {
1784
+ // convert data if not already a string
1785
+ if (s.processData && typeof s.data != "string")
1786
+ s.data = jQuery.param(s.data);
1787
+ // append data to url for get requests
1788
+ if( s.type.toLowerCase() == "get" ) {
1789
+ // "?" + data or "&" + data (in case there are already params)
1790
+ s.url += ((s.url.indexOf("?") > -1) ? "&" : "?") + s.data;
1791
+ // IE likes to send both get and post data, prevent this
1792
+ s.data = null;
1793
+ }
1794
+ }
1795
+
1796
+ // Watch for a new set of requests
1797
+ if ( s.global && ! jQuery.active++ )
1798
+ jQuery.event.trigger( "ajaxStart" );
1799
+
1800
+ var requestDone = false;
1801
+
1802
+ // Create the request object; Microsoft failed to properly
1803
+ // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
1804
+ var xml = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
1805
+
1806
+ // Open the socket
1807
+ xml.open(s.type, s.url, s.async);
1808
+
1809
+ // Set the correct header, if data is being sent
1810
+ if ( s.data )
1811
+ xml.setRequestHeader("Content-Type", s.contentType);
1812
+
1813
+ // Set the If-Modified-Since header, if ifModified mode.
1814
+ if ( s.ifModified )
1815
+ xml.setRequestHeader("If-Modified-Since",
1816
+ jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
1817
+
1818
+ // Set header so the called script knows that it's an XMLHttpRequest
1819
+ xml.setRequestHeader("X-Requested-With", "XMLHttpRequest");
1820
+
1821
+ // Allow custom headers/mimetypes
1822
+ if( s.beforeSend )
1823
+ s.beforeSend(xml);
1824
+
1825
+ if ( s.global )
1826
+ jQuery.event.trigger("ajaxSend", [xml, s]);
1827
+
1828
+ // Wait for a response to come back
1829
+ var onreadystatechange = function(isTimeout){
1830
+ // The transfer is complete and the data is available, or the request timed out
1831
+ if ( xml && (xml.readyState == 4 || isTimeout == "timeout") ) {
1832
+ requestDone = true;
1833
+
1834
+ // clear poll interval
1835
+ if (ival) {
1836
+ clearInterval(ival);
1837
+ ival = null;
1838
+ }
1839
+
1840
+ var status;
1841
+ try {
1842
+ status = jQuery.httpSuccess( xml ) && isTimeout != "timeout" ?
1843
+ s.ifModified && jQuery.httpNotModified( xml, s.url ) ? "notmodified" : "success" : "error";
1844
+ // Make sure that the request was successful or notmodified
1845
+ if ( status != "error" ) {
1846
+ // Cache Last-Modified header, if ifModified mode.
1847
+ var modRes;
1848
+ try {
1849
+ modRes = xml.getResponseHeader("Last-Modified");
1850
+ } catch(e) {} // swallow exception thrown by FF if header is not available
1851
+
1852
+ if ( s.ifModified && modRes )
1853
+ jQuery.lastModified[s.url] = modRes;
1854
+
1855
+ // process the data (runs the xml through httpData regardless of callback)
1856
+ var data = jQuery.httpData( xml, s.dataType );
1857
+
1858
+ // If a local callback was specified, fire it and pass it the data
1859
+ if ( s.success )
1860
+ s.success( data, status );
1861
+
1862
+ // Fire the global callback
1863
+ if( s.global )
1864
+ jQuery.event.trigger( "ajaxSuccess", [xml, s] );
1865
+ } else
1866
+ jQuery.handleError(s, xml, status);
1867
+ } catch(e) {
1868
+ status = "error";
1869
+ jQuery.handleError(s, xml, status, e);
1870
+ }
1871
+
1872
+ // The request was completed
1873
+ if( s.global )
1874
+ jQuery.event.trigger( "ajaxComplete", [xml, s] );
1875
+
1876
+ // Handle the global AJAX counter
1877
+ if ( s.global && ! --jQuery.active )
1878
+ jQuery.event.trigger( "ajaxStop" );
1879
+
1880
+ // Process result
1881
+ if ( s.complete )
1882
+ s.complete(xml, status);
1883
+
1884
+ // Stop memory leaks
1885
+ if(s.async)
1886
+ xml = null;
1887
+ }
1888
+ };
1889
+
1890
+ // don't attach the handler to the request, just poll it instead
1891
+ var ival = setInterval(onreadystatechange, 13);
1892
+
1893
+ // Timeout checker
1894
+ if ( s.timeout > 0 )
1895
+ setTimeout(function(){
1896
+ // Check to see if the request is still happening
1897
+ if ( xml ) {
1898
+ // Cancel the request
1899
+ xml.abort();
1900
+
1901
+ if( !requestDone )
1902
+ onreadystatechange( "timeout" );
1903
+ }
1904
+ }, s.timeout);
1905
+
1906
+ // Send the data
1907
+ try {
1908
+ xml.send(s.data);
1909
+ } catch(e) {
1910
+ jQuery.handleError(s, xml, null, e);
1911
+ }
1912
+
1913
+ // firefox 1.5 doesn't fire statechange for sync requests
1914
+ if ( !s.async )
1915
+ onreadystatechange();
1916
+
1917
+ // return XMLHttpRequest to allow aborting the request etc.
1918
+ return xml;
1919
+ },
1920
+
1921
+ handleError: function( s, xml, status, e ) {
1922
+ // If a local callback was specified, fire it
1923
+ if ( s.error ) s.error( xml, status, e );
1924
+
1925
+ // Fire the global callback
1926
+ if ( s.global )
1927
+ jQuery.event.trigger( "ajaxError", [xml, s, e] );
1928
+ },
1929
+
1930
+ // Counter for holding the number of active queries
1931
+ active: 0,
1932
+
1933
+ // Determines if an XMLHttpRequest was successful or not
1934
+ httpSuccess: function( r ) {
1935
+ try {
1936
+ return !r.status && location.protocol == "file:" ||
1937
+ ( r.status >= 200 && r.status < 300 ) || r.status == 304 ||
1938
+ jQuery.browser.safari && r.status == undefined;
1939
+ } catch(e){}
1940
+ return false;
1941
+ },
1942
+
1943
+ // Determines if an XMLHttpRequest returns NotModified
1944
+ httpNotModified: function( xml, url ) {
1945
+ try {
1946
+ var xmlRes = xml.getResponseHeader("Last-Modified");
1947
+
1948
+ // Firefox always returns 200. check Last-Modified date
1949
+ return xml.status == 304 || xmlRes == jQuery.lastModified[url] ||
1950
+ jQuery.browser.safari && xml.status == undefined;
1951
+ } catch(e){}
1952
+ return false;
1953
+ },
1954
+
1955
+ /* Get the data out of an XMLHttpRequest.
1956
+ * Return parsed XML if content-type header is "xml" and type is "xml" or omitted,
1957
+ * otherwise return plain text.
1958
+ * (String) data - The type of data that you're expecting back,
1959
+ * (e.g. "xml", "html", "script")
1960
+ */
1961
+ httpData: function( r, type ) {
1962
+ var ct = r.getResponseHeader("content-type");
1963
+ var data = !type && ct && ct.indexOf("xml") >= 0;
1964
+ data = type == "xml" || data ? r.responseXML : r.responseText;
1965
+
1966
+ // If the type is "script", eval it in global context
1967
+ if ( type == "script" )
1968
+ jQuery.globalEval( data );
1969
+
1970
+ // Get the JavaScript object, if JSON is used.
1971
+ if ( type == "json" )
1972
+ data = eval("(" + data + ")");
1973
+
1974
+ // evaluate scripts within html
1975
+ if ( type == "html" )
1976
+ jQuery("<div>").html(data).evalScripts();
1977
+
1978
+ return data;
1979
+ },
1980
+
1981
+ // Serialize an array of form elements or a set of
1982
+ // key/values into a query string
1983
+ param: function( a ) {
1984
+ var s = [];
1985
+
1986
+ // If an array was passed in, assume that it is an array
1987
+ // of form elements
1988
+ if ( a.constructor == Array || a.jquery )
1989
+ // Serialize the form elements
1990
+ jQuery.each( a, function(){
1991
+ s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
1992
+ });
1993
+
1994
+ // Otherwise, assume that it's an object of key/value pairs
1995
+ else
1996
+ // Serialize the key/values
1997
+ for ( var j in a )
1998
+ // If the value is an array then the key names need to be repeated
1999
+ if ( a[j] && a[j].constructor == Array )
2000
+ jQuery.each( a[j], function(){
2001
+ s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) );
2002
+ });
2003
+ else
2004
+ s.push( encodeURIComponent(j) + "=" + encodeURIComponent( a[j] ) );
2005
+
2006
+ // Return the resulting serialization
2007
+ return s.join("&");
1312
2008
  },
1313
2009
 
1314
- // Overwrite the old hide method
1315
- _hide: jQuery.fn.hide,
2010
+ // evalulates a script in global context
2011
+ // not reliable for safari
2012
+ globalEval: function( data ) {
2013
+ if ( window.execScript )
2014
+ window.execScript( data );
2015
+ else if ( jQuery.browser.safari )
2016
+ // safari doesn't provide a synchronous global eval
2017
+ window.setTimeout( data, 0 );
2018
+ else
2019
+ eval.call( window, data );
2020
+ }
2021
+
2022
+ });
2023
+ jQuery.fn.extend({
2024
+
2025
+ show: function(speed,callback){
2026
+ return speed ?
2027
+ this.animate({
2028
+ height: "show", width: "show", opacity: "show"
2029
+ }, speed, callback) :
2030
+
2031
+ this.filter(":hidden").each(function(){
2032
+ this.style.display = this.oldblock ? this.oldblock : "";
2033
+ if ( jQuery.css(this,"display") == "none" )
2034
+ this.style.display = "block";
2035
+ }).end();
2036
+ },
1316
2037
 
1317
2038
  hide: function(speed,callback){
1318
- return speed ? this.animate({
1319
- height: "hide", width: "hide", opacity: "hide"
1320
- }, speed, callback) : this._hide();
2039
+ return speed ?
2040
+ this.animate({
2041
+ height: "hide", width: "hide", opacity: "hide"
2042
+ }, speed, callback) :
2043
+
2044
+ this.filter(":visible").each(function(){
2045
+ this.oldblock = this.oldblock || jQuery.css(this,"display");
2046
+ if ( this.oldblock == "none" )
2047
+ this.oldblock = "block";
2048
+ this.style.display = "none";
2049
+ }).end();
1321
2050
  },
1322
2051
 
2052
+ // Save the old toggle function
2053
+ _toggle: jQuery.fn.toggle,
2054
+ toggle: function( fn, fn2 ){
2055
+ return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
2056
+ this._toggle( fn, fn2 ) :
2057
+ fn ?
2058
+ this.animate({
2059
+ height: "toggle", width: "toggle", opacity: "toggle"
2060
+ }, fn, fn2) :
2061
+ this.each(function(){
2062
+ jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
2063
+ });
2064
+ },
1323
2065
  slideDown: function(speed,callback){
1324
2066
  return this.animate({height: "show"}, speed, callback);
1325
2067
  },
1326
-
1327
2068
  slideUp: function(speed,callback){
1328
2069
  return this.animate({height: "hide"}, speed, callback);
1329
2070
  },
1330
-
1331
- slideToggle: function(speed,callback){
1332
- return this.each(function(){
1333
- var state = jQuery(this).is(":hidden") ? "show" : "hide";
1334
- jQuery(this).animate({height: state}, speed, callback);
1335
- });
2071
+ slideToggle: function(speed, callback){
2072
+ return this.animate({height: "toggle"}, speed, callback);
1336
2073
  },
1337
-
1338
- fadeIn: function(speed,callback){
2074
+ fadeIn: function(speed, callback){
1339
2075
  return this.animate({opacity: "show"}, speed, callback);
1340
2076
  },
1341
-
1342
- fadeOut: function(speed,callback){
2077
+ fadeOut: function(speed, callback){
1343
2078
  return this.animate({opacity: "hide"}, speed, callback);
1344
2079
  },
1345
-
1346
2080
  fadeTo: function(speed,to,callback){
1347
2081
  return this.animate({opacity: to}, speed, callback);
1348
2082
  },
1349
- animate: function(prop,speed,callback) {
2083
+ animate: function( prop, speed, easing, callback ) {
1350
2084
  return this.queue(function(){
1351
-
1352
- this.curAnim = prop;
2085
+ var hidden = jQuery(this).is(":hidden"),
2086
+ opt = jQuery.speed(speed, easing, callback),
2087
+ self = this;
1353
2088
 
1354
2089
  for ( var p in prop ) {
1355
- var e = new jQuery.fx( this, jQuery.speed(speed,callback), p );
1356
- if ( prop[p].constructor == Number )
1357
- e.custom( e.cur(), prop[p] );
1358
- else
1359
- e[ prop[p] ]( prop );
2090
+ if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
2091
+ return jQuery.isFunction(opt.complete) && opt.complete.apply(this);
2092
+
2093
+ if ( p == "height" || p == "width" ) {
2094
+ // Store display property
2095
+ opt.display = jQuery.css(this, "display");
2096
+
2097
+ // Make sure that nothing sneaks out
2098
+ opt.overflow = this.style.overflow;
2099
+ }
1360
2100
  }
2101
+
2102
+ if ( opt.overflow != null )
2103
+ this.style.overflow = "hidden";
2104
+
2105
+ this.curAnim = jQuery.extend({}, prop);
1361
2106
 
2107
+ jQuery.each( prop, function(name, val){
2108
+ var e = new jQuery.fx( self, opt, name );
2109
+ if ( val.constructor == Number )
2110
+ e.custom( e.cur(), val );
2111
+ else
2112
+ e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
2113
+ });
1362
2114
  });
1363
2115
  },
1364
2116
  queue: function(type,fn){
@@ -1384,53 +2136,37 @@ jQuery.fn.extend({
1384
2136
  });
1385
2137
 
1386
2138
  jQuery.extend({
1387
-
1388
- setAuto: function(e,p) {
1389
- if ( e.notAuto ) return;
1390
-
1391
- if ( p == "height" && e.scrollHeight != parseInt(jQuery.curCSS(e,p)) ) return;
1392
- if ( p == "width" && e.scrollWidth != parseInt(jQuery.curCSS(e,p)) ) return;
1393
-
1394
- // Remember the original height
1395
- var a = e.style[p];
1396
-
1397
- // Figure out the size of the height right now
1398
- var o = jQuery.curCSS(e,p,1);
1399
-
1400
- if ( p == "height" && e.scrollHeight != o ||
1401
- p == "width" && e.scrollWidth != o ) return;
1402
-
1403
- // Set the height to auto
1404
- e.style[p] = e.currentStyle ? "" : "auto";
1405
-
1406
- // See what the size of "auto" is
1407
- var n = jQuery.curCSS(e,p,1);
1408
-
1409
- // Revert back to the original size
1410
- if ( o != n && n != "auto" ) {
1411
- e.style[p] = a;
1412
- e.notAuto = true;
1413
- }
1414
- },
1415
2139
 
1416
- speed: function(s,o) {
1417
- o = o || {};
1418
-
1419
- if ( o.constructor == Function )
1420
- o = { complete: o };
1421
-
1422
- var ss = { slow: 600, fast: 200 };
1423
- o.duration = (s && s.constructor == Number ? s : ss[s]) || 400;
2140
+ speed: function(speed, easing, fn) {
2141
+ var opt = speed && speed.constructor == Object ? speed : {
2142
+ complete: fn || !fn && easing ||
2143
+ jQuery.isFunction( speed ) && speed,
2144
+ duration: speed,
2145
+ easing: fn && easing || easing && easing.constructor != Function && easing || (jQuery.easing.swing ? "swing" : "linear")
2146
+ };
2147
+
2148
+ opt.duration = (opt.duration && opt.duration.constructor == Number ?
2149
+ opt.duration :
2150
+ { slow: 600, fast: 200 }[opt.duration]) || 400;
1424
2151
 
1425
2152
  // Queueing
1426
- o.oldComplete = o.complete;
1427
- o.complete = function(){
2153
+ opt.old = opt.complete;
2154
+ opt.complete = function(){
1428
2155
  jQuery.dequeue(this, "fx");
1429
- if ( o.oldComplete && o.oldComplete.constructor == Function )
1430
- o.oldComplete.apply( this );
2156
+ if ( jQuery.isFunction( opt.old ) )
2157
+ opt.old.apply( this );
1431
2158
  };
1432
2159
 
1433
- return o;
2160
+ return opt;
2161
+ },
2162
+
2163
+ easing: {
2164
+ linear: function( p, n, firstNum, diff ) {
2165
+ return firstNum + diff * p;
2166
+ },
2167
+ swing: function( p, n, firstNum, diff ) {
2168
+ return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
2169
+ }
1434
2170
  },
1435
2171
 
1436
2172
  queue: {},
@@ -1449,6 +2185,8 @@ jQuery.extend({
1449
2185
  }
1450
2186
  },
1451
2187
 
2188
+ timers: [],
2189
+
1452
2190
  /*
1453
2191
  * I originally wrote fx() as a clone of moo.fx and in the process
1454
2192
  * of making it small in size the code became illegible to sane
@@ -1456,468 +2194,151 @@ jQuery.extend({
1456
2194
  */
1457
2195
 
1458
2196
  fx: function( elem, options, prop ){
1459
-
2197
+
1460
2198
  var z = this;
1461
-
1462
- // The users options
1463
- z.o = {
1464
- duration: options.duration || 400,
1465
- complete: options.complete,
1466
- step: options.step
1467
- };
1468
-
1469
- // The element
1470
- z.el = elem;
1471
-
2199
+
1472
2200
  // The styles
1473
- var y = z.el.style;
1474
-
2201
+ var y = elem.style;
2202
+
1475
2203
  // Simple function for setting a style value
1476
2204
  z.a = function(){
1477
2205
  if ( options.step )
1478
2206
  options.step.apply( elem, [ z.now ] );
1479
-
2207
+
1480
2208
  if ( prop == "opacity" )
1481
2209
  jQuery.attr(y, "opacity", z.now); // Let attr handle opacity
1482
- else if ( parseInt(z.now) ) // My hate for IE will never die
2210
+ else {
1483
2211
  y[prop] = parseInt(z.now) + "px";
1484
-
1485
- y.display = "block";
2212
+ y.display = "block"; // Set display property to block for animation
2213
+ }
1486
2214
  };
1487
-
2215
+
1488
2216
  // Figure out the maximum number to run to
1489
2217
  z.max = function(){
1490
- return parseFloat( jQuery.css(z.el,prop) );
2218
+ return parseFloat( jQuery.css(elem,prop) );
1491
2219
  };
1492
-
2220
+
1493
2221
  // Get the current size
1494
2222
  z.cur = function(){
1495
- var r = parseFloat( jQuery.curCSS(z.el, prop) );
2223
+ var r = parseFloat( jQuery.curCSS(elem, prop) );
1496
2224
  return r && r > -10000 ? r : z.max();
1497
2225
  };
1498
-
2226
+
1499
2227
  // Start an animation from one number to another
1500
2228
  z.custom = function(from,to){
1501
2229
  z.startTime = (new Date()).getTime();
1502
2230
  z.now = from;
1503
2231
  z.a();
1504
-
1505
- z.timer = setInterval(function(){
1506
- z.step(from, to);
1507
- }, 13);
2232
+
2233
+ jQuery.timers.push(function(){
2234
+ return z.step(from, to);
2235
+ });
2236
+
2237
+ if ( jQuery.timers.length == 1 ) {
2238
+ var timer = setInterval(function(){
2239
+ var timers = jQuery.timers;
2240
+
2241
+ for ( var i = 0; i < timers.length; i++ )
2242
+ if ( !timers[i]() )
2243
+ timers.splice(i--, 1);
2244
+
2245
+ if ( !timers.length )
2246
+ clearInterval( timer );
2247
+ }, 13);
2248
+ }
1508
2249
  };
1509
-
2250
+
1510
2251
  // Simple 'show' function
1511
- z.show = function( p ){
1512
- if ( !z.el.orig ) z.el.orig = {};
2252
+ z.show = function(){
2253
+ if ( !elem.orig ) elem.orig = {};
1513
2254
 
1514
2255
  // Remember where we started, so that we can go back to it later
1515
- z.el.orig[prop] = this.cur();
1516
-
2256
+ elem.orig[prop] = jQuery.attr( elem.style, prop );
2257
+
2258
+ options.show = true;
2259
+
1517
2260
  // Begin the animation
1518
- if (prop == "opacity")
1519
- z.custom(z.el.orig[prop], 1);
1520
- else
1521
- z.custom(0, z.el.orig[prop]);
2261
+ z.custom(0, this.cur());
1522
2262
 
1523
- // Stupid IE, look what you made me do
2263
+ // Make sure that we start at a small width/height to avoid any
2264
+ // flash of content
1524
2265
  if ( prop != "opacity" )
1525
2266
  y[prop] = "1px";
2267
+
2268
+ // Start by showing the element
2269
+ jQuery(elem).show();
1526
2270
  };
1527
-
2271
+
1528
2272
  // Simple 'hide' function
1529
2273
  z.hide = function(){
1530
- if ( !z.el.orig ) z.el.orig = {};
2274
+ if ( !elem.orig ) elem.orig = {};
1531
2275
 
1532
2276
  // Remember where we started, so that we can go back to it later
1533
- z.el.orig[prop] = this.cur();
2277
+ elem.orig[prop] = jQuery.attr( elem.style, prop );
1534
2278
 
1535
- z.o.hide = true;
2279
+ options.hide = true;
1536
2280
 
1537
2281
  // Begin the animation
1538
- z.custom(z.el.orig[prop], 0);
2282
+ z.custom(this.cur(), 0);
1539
2283
  };
1540
-
1541
- // Remember the overflow of the element
1542
- if ( !z.el.oldOverlay )
1543
- z.el.oldOverflow = jQuery.css( z.el, "overflow" );
1544
-
1545
- // Make sure that nothing sneaks out
1546
- y.overflow = "hidden";
1547
-
2284
+
1548
2285
  // Each step of an animation
1549
2286
  z.step = function(firstNum, lastNum){
1550
2287
  var t = (new Date()).getTime();
1551
-
1552
- if (t > z.o.duration + z.startTime) {
1553
- // Stop the timer
1554
- clearInterval(z.timer);
1555
- z.timer = null;
1556
2288
 
2289
+ if (t > options.duration + z.startTime) {
1557
2290
  z.now = lastNum;
1558
2291
  z.a();
1559
2292
 
1560
- z.el.curAnim[ prop ] = true;
1561
-
2293
+ if (elem.curAnim) elem.curAnim[ prop ] = true;
2294
+
1562
2295
  var done = true;
1563
- for ( var i in z.el.curAnim )
1564
- if ( z.el.curAnim[i] !== true )
2296
+ for ( var i in elem.curAnim )
2297
+ if ( elem.curAnim[i] !== true )
1565
2298
  done = false;
1566
-
2299
+
1567
2300
  if ( done ) {
1568
- // Reset the overflow
1569
- y.overflow = z.el.oldOverflow;
1570
-
1571
- // Hide the element if the "hide" operation was done
1572
- if ( z.o.hide )
1573
- y.display = 'none';
2301
+ if ( options.display != null ) {
2302
+ // Reset the overflow
2303
+ y.overflow = options.overflow;
1574
2304
 
1575
- // Reset the property, if the item has been hidden
1576
- if ( z.o.hide ) {
1577
- for ( var p in z.el.curAnim ) {
1578
- if (p == "opacity" && jQuery.browser.msie)
1579
- jQuery.attr(y, p, z.el.orig[p]);
1580
- else
1581
- y[ p ] = z.el.orig[p] + "px";
1582
-
1583
- // set its height and/or width to auto
1584
- if ( p == 'height' || p == 'width' )
1585
- jQuery.setAuto( z.el, p );
1586
- }
2305
+ // Reset the display
2306
+ y.display = options.display;
2307
+ if ( jQuery.css(elem, "display") == "none" )
2308
+ y.display = "block";
1587
2309
  }
2310
+
2311
+ // Hide the element if the "hide" operation was done
2312
+ if ( options.hide )
2313
+ y.display = "none";
2314
+
2315
+ // Reset the properties, if the item has been hidden or shown
2316
+ if ( options.hide || options.show )
2317
+ for ( var p in elem.curAnim )
2318
+ jQuery.attr(y, p, elem.orig[p]);
1588
2319
  }
1589
2320
 
1590
2321
  // If a callback was provided, execute it
1591
- if( done && z.o.complete && z.o.complete.constructor == Function )
2322
+ if ( done && jQuery.isFunction( options.complete ) )
1592
2323
  // Execute the complete function
1593
- z.o.complete.apply( z.el );
2324
+ options.complete.apply( elem );
2325
+
2326
+ return false;
1594
2327
  } else {
2328
+ var n = t - this.startTime;
1595
2329
  // Figure out where in the animation we are and set the number
1596
- var p = (t - this.startTime) / z.o.duration;
1597
- z.now = ((-Math.cos(p*Math.PI)/2) + 0.5) * (lastNum-firstNum) + firstNum;
1598
-
2330
+ var p = n / options.duration;
2331
+
2332
+ // Perform the easing function, defaults to swing
2333
+ z.now = jQuery.easing[options.easing](p, n, firstNum, (lastNum-firstNum), options.duration);
2334
+
1599
2335
  // Perform the next step of the animation
1600
2336
  z.a();
1601
2337
  }
1602
- };
1603
-
1604
- }
1605
-
1606
- });
1607
- jQuery.fn.extend({
1608
- loadIfModified: function( url, params, callback ) {
1609
- this.load( url, params, callback, 1 );
1610
- },
1611
- load: function( url, params, callback, ifModified ) {
1612
- if ( url.constructor == Function )
1613
- return this.bind("load", url);
1614
-
1615
- callback = callback || function(){};
1616
-
1617
- // Default to a GET request
1618
- var type = "GET";
1619
-
1620
- // If the second parameter was provided
1621
- if ( params ) {
1622
- // If it's a function
1623
- if ( params.constructor == Function ) {
1624
- // We assume that it's the callback
1625
- callback = params;
1626
- params = null;
1627
-
1628
- // Otherwise, build a param string
1629
- } else {
1630
- params = jQuery.param( params );
1631
- type = "POST";
1632
- }
1633
- }
1634
-
1635
- var self = this;
1636
-
1637
- // Request the remote document
1638
- jQuery.ajax( type, url, params,function(res, status){
1639
-
1640
- if ( status == "success" || !ifModified && status == "notmodified" ) {
1641
- // Inject the HTML into all the matched elements
1642
- self.html(res.responseText).each( callback, [res.responseText, status] );
1643
-
1644
- // Execute all the scripts inside of the newly-injected HTML
1645
- jQuery("script", self).each(function(){
1646
- if ( this.src )
1647
- jQuery.getScript( this.src );
1648
- else
1649
- eval.call( window, this.text || this.textContent || this.innerHTML || "" );
1650
- });
1651
- } else
1652
- callback.apply( self, [res.responseText, status] );
1653
-
1654
- }, ifModified);
1655
-
1656
- return this;
1657
- },
1658
- serialize: function() {
1659
- return jQuery.param( this );
1660
- }
1661
-
1662
- });
1663
-
1664
- // If IE is used, create a wrapper for the XMLHttpRequest object
1665
- if ( jQuery.browser.msie && typeof XMLHttpRequest == "undefined" )
1666
- XMLHttpRequest = function(){
1667
- return new ActiveXObject(
1668
- navigator.userAgent.indexOf("MSIE 5") >= 0 ?
1669
- "Microsoft.XMLHTTP" : "Msxml2.XMLHTTP"
1670
- );
1671
- };
1672
-
1673
- // Attach a bunch of functions for handling common AJAX events
1674
-
1675
-
1676
-
1677
- new function(){
1678
- var e = "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess".split(",");
1679
-
1680
- for ( var i = 0; i < e.length; i++ ) new function(){
1681
- var o = e[i];
1682
- jQuery.fn[o] = function(f){
1683
- return this.bind(o, f);
1684
- };
1685
- };
1686
- };
1687
-
1688
- jQuery.extend({
1689
- get: function( url, data, callback, type, ifModified ) {
1690
- if ( data.constructor == Function ) {
1691
- type = callback;
1692
- callback = data;
1693
- data = null;
1694
- }
1695
-
1696
- // append ? + data or & + data, in case there are already params
1697
- if ( data ) url += ((url.indexOf("?") > -1) ? "&" : "?") + jQuery.param(data);
1698
-
1699
- // Build and start the HTTP Request
1700
- jQuery.ajax( "GET", url, null, function(r, status) {
1701
- if ( callback ) callback( jQuery.httpData(r,type), status );
1702
- }, ifModified);
1703
- },
1704
- getIfModified: function( url, data, callback, type ) {
1705
- jQuery.get(url, data, callback, type, 1);
1706
- },
1707
- getScript: function( url, callback ) {
1708
- jQuery.get(url, callback, "script");
1709
- },
1710
- getJSON: function( url, data, callback ) {
1711
- if(callback)
1712
- jQuery.get(url, data, callback, "json");
1713
- else {
1714
- jQuery.get(url, data, "json");
1715
- }
1716
- },
1717
- post: function( url, data, callback, type ) {
1718
- // Build and start the HTTP Request
1719
- jQuery.ajax( "POST", url, jQuery.param(data), function(r, status) {
1720
- if ( callback ) callback( jQuery.httpData(r,type), status );
1721
- });
1722
- },
1723
-
1724
- // timeout (ms)
1725
- timeout: 0,
1726
- ajaxTimeout: function(timeout) {
1727
- jQuery.timeout = timeout;
1728
- },
1729
-
1730
- // Last-Modified header cache for next request
1731
- lastModified: {},
1732
- ajax: function( type, url, data, ret, ifModified ) {
1733
- // If only a single argument was passed in,
1734
- // assume that it is a object of key/value pairs
1735
- if ( !url ) {
1736
- ret = type.complete;
1737
- var success = type.success;
1738
- var error = type.error;
1739
- var dataType = type.dataType;
1740
- var global = typeof type.global == "boolean" ? type.global : true;
1741
- var timeout = typeof type.timeout == "number" ? type.timeout : jQuery.timeout;
1742
- var ifModified = type.ifModified || false;
1743
- data = type.data;
1744
- url = type.url;
1745
- type = type.type;
1746
- }
1747
-
1748
- // Watch for a new set of requests
1749
- if ( global && ! jQuery.active++ )
1750
- jQuery.event.trigger( "ajaxStart" );
1751
-
1752
- var requestDone = false;
1753
-
1754
- // Create the request object
1755
- var xml = new XMLHttpRequest();
1756
-
1757
- // Open the socket
1758
- xml.open(type || "GET", url, true);
1759
-
1760
- // Set the correct header, if data is being sent
1761
- if ( data )
1762
- xml.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
1763
-
1764
- // Set the If-Modified-Since header, if ifModified mode.
1765
- if ( ifModified )
1766
- xml.setRequestHeader("If-Modified-Since",
1767
- jQuery.lastModified[url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
1768
-
1769
- // Set header so the called script knows that it's an XMLHttpRequest
1770
- xml.setRequestHeader("X-Requested-With", "XMLHttpRequest");
1771
-
1772
- // Make sure the browser sends the right content length
1773
- if ( xml.overrideMimeType )
1774
- xml.setRequestHeader("Connection", "close");
1775
-
1776
- // Wait for a response to come back
1777
- var onreadystatechange = function(istimeout){
1778
- // The transfer is complete and the data is available, or the request timed out
1779
- if ( xml && (xml.readyState == 4 || istimeout == "timeout") ) {
1780
- requestDone = true;
1781
2338
 
1782
- var status = jQuery.httpSuccess( xml ) && istimeout != "timeout" ?
1783
- ifModified && jQuery.httpNotModified( xml, url ) ? "notmodified" : "success" : "error";
1784
-
1785
- // Make sure that the request was successful or notmodified
1786
- if ( status != "error" ) {
1787
- // Cache Last-Modified header, if ifModified mode.
1788
- var modRes;
1789
- try {
1790
- modRes = xml.getResponseHeader("Last-Modified");
1791
- } catch(e) {} // swallow exception thrown by FF if header is not available
1792
-
1793
- if ( ifModified && modRes )
1794
- jQuery.lastModified[url] = modRes;
1795
-
1796
- // If a local callback was specified, fire it
1797
- if ( success )
1798
- success( jQuery.httpData( xml, dataType ), status );
1799
-
1800
- // Fire the global callback
1801
- if( global )
1802
- jQuery.event.trigger( "ajaxSuccess" );
1803
-
1804
- // Otherwise, the request was not successful
1805
- } else {
1806
- // If a local callback was specified, fire it
1807
- if ( error ) error( xml, status );
1808
-
1809
- // Fire the global callback
1810
- if( global )
1811
- jQuery.event.trigger( "ajaxError" );
1812
- }
1813
-
1814
- // The request was completed
1815
- if( global )
1816
- jQuery.event.trigger( "ajaxComplete" );
1817
-
1818
- // Handle the global AJAX counter
1819
- if ( global && ! --jQuery.active )
1820
- jQuery.event.trigger( "ajaxStop" );
1821
-
1822
- // Process result
1823
- if ( ret ) ret(xml, status);
1824
-
1825
- // Stop memory leaks
1826
- xml.onreadystatechange = function(){};
1827
- xml = null;
1828
-
1829
- }
2339
+ return true;
1830
2340
  };
1831
- xml.onreadystatechange = onreadystatechange;
1832
-
1833
- // Timeout checker
1834
- if(timeout > 0)
1835
- setTimeout(function(){
1836
- // Check to see if the request is still happening
1837
- if (xml) {
1838
- // Cancel the request
1839
- xml.abort();
1840
-
1841
- if ( !requestDone ) onreadystatechange( "timeout" );
1842
-
1843
- // Clear from memory
1844
- xml = null;
1845
- }
1846
- }, timeout);
1847
-
1848
- // Send the data
1849
- xml.send(data);
1850
- },
1851
-
1852
- // Counter for holding the number of active queries
1853
- active: 0,
1854
-
1855
- // Determines if an XMLHttpRequest was successful or not
1856
- httpSuccess: function(r) {
1857
- try {
1858
- return !r.status && location.protocol == "file:" ||
1859
- ( r.status >= 200 && r.status < 300 ) || r.status == 304 ||
1860
- jQuery.browser.safari && r.status == undefined;
1861
- } catch(e){}
1862
-
1863
- return false;
1864
- },
1865
-
1866
- // Determines if an XMLHttpRequest returns NotModified
1867
- httpNotModified: function(xml, url) {
1868
- try {
1869
- var xmlRes = xml.getResponseHeader("Last-Modified");
1870
-
1871
- // Firefox always returns 200. check Last-Modified date
1872
- return xml.status == 304 || xmlRes == jQuery.lastModified[url] ||
1873
- jQuery.browser.safari && xml.status == undefined;
1874
- } catch(e){}
1875
-
1876
- return false;
1877
- },
1878
-
1879
- /* Get the data out of an XMLHttpRequest.
1880
- * Return parsed XML if content-type header is "xml" and type is "xml" or omitted,
1881
- * otherwise return plain text.
1882
- * (String) data - The type of data that you're expecting back,
1883
- * (e.g. "xml", "html", "script")
1884
- */
1885
- httpData: function(r,type) {
1886
- var ct = r.getResponseHeader("content-type");
1887
- var data = !type && ct && ct.indexOf("xml") >= 0;
1888
- data = type == "xml" || data ? r.responseXML : r.responseText;
1889
-
1890
- // If the type is "script", eval it
1891
- if ( type == "script" ) eval.call( window, data );
1892
-
1893
- // Get the JavaScript object, if JSON is used.
1894
- if ( type == "json" ) eval( "data = " + data );
1895
-
1896
- return data;
1897
- },
1898
2341
 
1899
- // Serialize an array of form elements or a set of
1900
- // key/values into a query string
1901
- param: function(a) {
1902
- var s = [];
1903
-
1904
- // If an array was passed in, assume that it is an array
1905
- // of form elements
1906
- if ( a.constructor == Array || a.jquery ) {
1907
- // Serialize the form elements
1908
- for ( var i = 0; i < a.length; i++ )
1909
- s.push( a[i].name + "=" + encodeURIComponent( a[i].value ) );
1910
-
1911
- // Otherwise, assume that it's an object of key/value pairs
1912
- } else {
1913
- // Serialize the key/values
1914
- for ( var j in a )
1915
- s.push( j + "=" + encodeURIComponent( a[j] ) );
1916
- }
1917
-
1918
- // Return the resulting serialization
1919
- return s.join("&");
1920
2342
  }
1921
-
1922
2343
  });
1923
- } // close: if(typeof window.jQuery == "undefined") {
2344
+ }