nitro-auth 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/CHANGELOG +12 -0
- data/LICENSE +31 -0
- data/README +115 -0
- data/TODO +7 -0
- data/examples/basic/public/error.xhtml +81 -0
- data/examples/basic/public/js/behaviour.js +254 -0
- data/examples/basic/public/js/controls.js +446 -0
- data/examples/basic/public/js/dragdrop.js +537 -0
- data/examples/basic/public/js/effects.js +612 -0
- data/examples/basic/public/js/prototype.js +1038 -0
- data/examples/basic/public/register.xhtml +65 -0
- data/examples/basic/run.rb +32 -0
- data/examples/basic/src/basic.rb +4 -0
- data/examples/basic/src/basic/auth_controller.rb +9 -0
- data/examples/basic/src/basic/controller.rb +29 -0
- data/examples/basic/src/basic/site.rb +13 -0
- data/examples/basic/src/basic/user.rb +22 -0
- data/examples/basic/src/basic/view/index.xhtml +35 -0
- data/lib/nitro/auth.rb +41 -0
- data/lib/nitro/auth/auth_controller.rb +199 -0
- data/lib/nitro/auth/controller.rb +166 -0
- data/lib/nitro/auth/model/user.rb +147 -0
- data/lib/nitro/auth/util/crypt.rb +55 -0
- data/lib/nitro/auth/view/access_denied.xhtml +13 -0
- data/lib/nitro/auth/view/login.xhtml +38 -0
- data/lib/nitro/auth/view/logout.xhtml +16 -0
- data/lib/nitro/auth/view/register.xhtml +51 -0
- metadata +90 -0
@@ -0,0 +1,446 @@
|
|
1
|
+
// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
|
2
|
+
// (c) 2005 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
|
3
|
+
//
|
4
|
+
// Permission is hereby granted, free of charge, to any person obtaining
|
5
|
+
// a copy of this software and associated documentation files (the
|
6
|
+
// "Software"), to deal in the Software without restriction, including
|
7
|
+
// without limitation the rights to use, copy, modify, merge, publish,
|
8
|
+
// distribute, sublicense, and/or sell copies of the Software, and to
|
9
|
+
// permit persons to whom the Software is furnished to do so, subject to
|
10
|
+
// the following conditions:
|
11
|
+
//
|
12
|
+
// The above copyright notice and this permission notice shall be
|
13
|
+
// included in all copies or substantial portions of the Software.
|
14
|
+
//
|
15
|
+
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
16
|
+
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
17
|
+
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
18
|
+
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
19
|
+
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
20
|
+
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
21
|
+
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
22
|
+
|
23
|
+
Element.collectTextNodesIgnoreClass = function(element, ignoreclass) {
|
24
|
+
var children = $(element).childNodes;
|
25
|
+
var text = "";
|
26
|
+
var classtest = new RegExp("^([^ ]+ )*" + ignoreclass+ "( [^ ]+)*$","i");
|
27
|
+
|
28
|
+
for (var i = 0; i < children.length; i++) {
|
29
|
+
if(children[i].nodeType==3) {
|
30
|
+
text+=children[i].nodeValue;
|
31
|
+
} else {
|
32
|
+
if((!children[i].className.match(classtest)) && children[i].hasChildNodes())
|
33
|
+
text += Element.collectTextNodesIgnoreClass(children[i], ignoreclass);
|
34
|
+
}
|
35
|
+
}
|
36
|
+
|
37
|
+
return text;
|
38
|
+
}
|
39
|
+
|
40
|
+
// Autocompleter.Base handles all the autocompletion functionality
|
41
|
+
// that's independent of the data source for autocompletion. This
|
42
|
+
// includes drawing the autocompletion menu, observing keyboard
|
43
|
+
// and mouse events, and similar.
|
44
|
+
//
|
45
|
+
// Specific autocompleters need to provide, at the very least,
|
46
|
+
// a getUpdatedChoices function that will be invoked every time
|
47
|
+
// the text inside the monitored textbox changes. This method
|
48
|
+
// should get the text for which to provide autocompletion by
|
49
|
+
// invoking this.getEntry(), NOT by directly accessing
|
50
|
+
// this.element.value. This is to allow incremental tokenized
|
51
|
+
// autocompletion. Specific auto-completion logic (AJAX, etc)
|
52
|
+
// belongs in getUpdatedChoices.
|
53
|
+
//
|
54
|
+
// Tokenized incremental autocompletion is enabled automatically
|
55
|
+
// when an autocompleter is instantiated with the 'tokens' option
|
56
|
+
// in the options parameter, e.g.:
|
57
|
+
// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
|
58
|
+
// will incrementally autocomplete with a comma as the token.
|
59
|
+
// Additionally, ',' in the above example can be replaced with
|
60
|
+
// a token array, e.g. { tokens: new Array (',', '\n') } which
|
61
|
+
// enables autocompletion on multiple tokens. This is most
|
62
|
+
// useful when one of the tokens is \n (a newline), as it
|
63
|
+
// allows smart autocompletion after linebreaks.
|
64
|
+
|
65
|
+
var Autocompleter = {}
|
66
|
+
Autocompleter.Base = function() {};
|
67
|
+
Autocompleter.Base.prototype = {
|
68
|
+
base_initialize: function(element, update, options) {
|
69
|
+
this.element = $(element);
|
70
|
+
this.update = $(update);
|
71
|
+
this.has_focus = false;
|
72
|
+
this.changed = false;
|
73
|
+
this.active = false;
|
74
|
+
this.index = 0;
|
75
|
+
this.entry_count = 0;
|
76
|
+
|
77
|
+
if (this.setOptions)
|
78
|
+
this.setOptions(options);
|
79
|
+
else
|
80
|
+
this.options = {}
|
81
|
+
|
82
|
+
this.options.tokens = this.options.tokens || new Array();
|
83
|
+
this.options.frequency = this.options.frequency || 0.4;
|
84
|
+
this.options.min_chars = this.options.min_chars || 1;
|
85
|
+
this.options.onShow = this.options.onShow ||
|
86
|
+
function(element, update){
|
87
|
+
if(!update.style.position || update.style.position=='absolute') {
|
88
|
+
update.style.position = 'absolute';
|
89
|
+
var offsets = Position.cumulativeOffset(element);
|
90
|
+
update.style.left = offsets[0] + 'px';
|
91
|
+
update.style.top = (offsets[1] + element.offsetHeight) + 'px';
|
92
|
+
update.style.width = element.offsetWidth + 'px';
|
93
|
+
}
|
94
|
+
new Effect.Appear(update,{duration:0.15});
|
95
|
+
};
|
96
|
+
this.options.onHide = this.options.onHide ||
|
97
|
+
function(element, update){ new Effect.Fade(update,{duration:0.15}) };
|
98
|
+
|
99
|
+
if(this.options.indicator)
|
100
|
+
this.indicator = $(this.options.indicator);
|
101
|
+
|
102
|
+
if (typeof(this.options.tokens) == 'string')
|
103
|
+
this.options.tokens = new Array(this.options.tokens);
|
104
|
+
|
105
|
+
this.observer = null;
|
106
|
+
|
107
|
+
Element.hide(this.update);
|
108
|
+
|
109
|
+
Event.observe(this.element, "blur", this.onBlur.bindAsEventListener(this));
|
110
|
+
Event.observe(this.element, "keypress", this.onKeyPress.bindAsEventListener(this));
|
111
|
+
},
|
112
|
+
|
113
|
+
show: function() {
|
114
|
+
if(this.update.style.display=='none') this.options.onShow(this.element, this.update);
|
115
|
+
if(!this.iefix && (navigator.appVersion.indexOf('MSIE')>0) && this.update.style.position=='absolute') {
|
116
|
+
new Insertion.After(this.update,
|
117
|
+
'<iframe id="' + this.update.id + '_iefix" '+
|
118
|
+
'style="display:none;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
|
119
|
+
'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
|
120
|
+
this.iefix = $(this.update.id+'_iefix');
|
121
|
+
}
|
122
|
+
if(this.iefix) {
|
123
|
+
Position.clone(this.update, this.iefix);
|
124
|
+
this.iefix.style.zIndex = 1;
|
125
|
+
this.update.style.zIndex = 2;
|
126
|
+
Element.show(this.iefix);
|
127
|
+
}
|
128
|
+
},
|
129
|
+
|
130
|
+
hide: function() {
|
131
|
+
if(this.update.style.display=='') this.options.onHide(this.element, this.update);
|
132
|
+
if(this.iefix) Element.hide(this.iefix);
|
133
|
+
},
|
134
|
+
|
135
|
+
startIndicator: function() {
|
136
|
+
if(this.indicator) Element.show(this.indicator);
|
137
|
+
},
|
138
|
+
|
139
|
+
stopIndicator: function() {
|
140
|
+
if(this.indicator) Element.hide(this.indicator);
|
141
|
+
},
|
142
|
+
|
143
|
+
onKeyPress: function(event) {
|
144
|
+
if(this.active)
|
145
|
+
switch(event.keyCode) {
|
146
|
+
case Event.KEY_TAB:
|
147
|
+
case Event.KEY_RETURN:
|
148
|
+
this.select_entry();
|
149
|
+
Event.stop(event);
|
150
|
+
case Event.KEY_ESC:
|
151
|
+
this.hide();
|
152
|
+
this.active = false;
|
153
|
+
return;
|
154
|
+
case Event.KEY_LEFT:
|
155
|
+
case Event.KEY_RIGHT:
|
156
|
+
return;
|
157
|
+
case Event.KEY_UP:
|
158
|
+
this.mark_previous();
|
159
|
+
this.render();
|
160
|
+
if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
|
161
|
+
return;
|
162
|
+
case Event.KEY_DOWN:
|
163
|
+
this.mark_next();
|
164
|
+
this.render();
|
165
|
+
if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
|
166
|
+
return;
|
167
|
+
}
|
168
|
+
else
|
169
|
+
if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN)
|
170
|
+
return;
|
171
|
+
|
172
|
+
this.changed = true;
|
173
|
+
this.has_focus = true;
|
174
|
+
|
175
|
+
if(this.observer) clearTimeout(this.observer);
|
176
|
+
this.observer =
|
177
|
+
setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
|
178
|
+
},
|
179
|
+
|
180
|
+
onHover: function(event) {
|
181
|
+
var element = Event.findElement(event, 'LI');
|
182
|
+
if(this.index != element.autocompleteIndex)
|
183
|
+
{
|
184
|
+
this.index = element.autocompleteIndex;
|
185
|
+
this.render();
|
186
|
+
}
|
187
|
+
Event.stop(event);
|
188
|
+
},
|
189
|
+
|
190
|
+
onClick: function(event) {
|
191
|
+
var element = Event.findElement(event, 'LI');
|
192
|
+
this.index = element.autocompleteIndex;
|
193
|
+
this.select_entry();
|
194
|
+
Event.stop(event);
|
195
|
+
},
|
196
|
+
|
197
|
+
onBlur: function(event) {
|
198
|
+
// needed to make click events working
|
199
|
+
setTimeout(this.hide.bind(this), 250);
|
200
|
+
this.has_focus = false;
|
201
|
+
this.active = false;
|
202
|
+
},
|
203
|
+
|
204
|
+
render: function() {
|
205
|
+
if(this.entry_count > 0) {
|
206
|
+
for (var i = 0; i < this.entry_count; i++)
|
207
|
+
this.index==i ?
|
208
|
+
Element.addClassName(this.get_entry(i),"selected") :
|
209
|
+
Element.removeClassName(this.get_entry(i),"selected");
|
210
|
+
|
211
|
+
if(this.has_focus) {
|
212
|
+
if(this.get_current_entry().scrollIntoView)
|
213
|
+
this.get_current_entry().scrollIntoView(false);
|
214
|
+
|
215
|
+
this.show();
|
216
|
+
this.active = true;
|
217
|
+
}
|
218
|
+
} else this.hide();
|
219
|
+
},
|
220
|
+
|
221
|
+
mark_previous: function() {
|
222
|
+
if(this.index > 0) this.index--
|
223
|
+
else this.index = this.entry_count-1;
|
224
|
+
},
|
225
|
+
|
226
|
+
mark_next: function() {
|
227
|
+
if(this.index < this.entry_count-1) this.index++
|
228
|
+
else this.index = 0;
|
229
|
+
},
|
230
|
+
|
231
|
+
get_entry: function(index) {
|
232
|
+
return this.update.firstChild.childNodes[index];
|
233
|
+
},
|
234
|
+
|
235
|
+
get_current_entry: function() {
|
236
|
+
return this.get_entry(this.index);
|
237
|
+
},
|
238
|
+
|
239
|
+
select_entry: function() {
|
240
|
+
this.active = false;
|
241
|
+
value = Element.collectTextNodesIgnoreClass(this.get_current_entry(), 'informal').unescapeHTML();
|
242
|
+
this.updateElement(value);
|
243
|
+
this.element.focus();
|
244
|
+
},
|
245
|
+
|
246
|
+
updateElement: function(value) {
|
247
|
+
var last_token_pos = this.findLastToken();
|
248
|
+
if (last_token_pos != -1) {
|
249
|
+
var new_value = this.element.value.substr(0, last_token_pos + 1);
|
250
|
+
var whitespace = this.element.value.substr(last_token_pos + 1).match(/^\s+/);
|
251
|
+
if (whitespace)
|
252
|
+
new_value += whitespace[0];
|
253
|
+
this.element.value = new_value + value;
|
254
|
+
} else {
|
255
|
+
this.element.value = value;
|
256
|
+
}
|
257
|
+
},
|
258
|
+
|
259
|
+
updateChoices: function(choices) {
|
260
|
+
if(!this.changed && this.has_focus) {
|
261
|
+
this.update.innerHTML = choices;
|
262
|
+
Element.cleanWhitespace(this.update);
|
263
|
+
Element.cleanWhitespace(this.update.firstChild);
|
264
|
+
|
265
|
+
if(this.update.firstChild && this.update.firstChild.childNodes) {
|
266
|
+
this.entry_count =
|
267
|
+
this.update.firstChild.childNodes.length;
|
268
|
+
for (var i = 0; i < this.entry_count; i++) {
|
269
|
+
entry = this.get_entry(i);
|
270
|
+
entry.autocompleteIndex = i;
|
271
|
+
this.addObservers(entry);
|
272
|
+
}
|
273
|
+
} else {
|
274
|
+
this.entry_count = 0;
|
275
|
+
}
|
276
|
+
|
277
|
+
this.stopIndicator();
|
278
|
+
|
279
|
+
this.index = 0;
|
280
|
+
this.render();
|
281
|
+
}
|
282
|
+
},
|
283
|
+
|
284
|
+
addObservers: function(element) {
|
285
|
+
Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
|
286
|
+
Event.observe(element, "click", this.onClick.bindAsEventListener(this));
|
287
|
+
},
|
288
|
+
|
289
|
+
onObserverEvent: function() {
|
290
|
+
this.changed = false;
|
291
|
+
if(this.getEntry().length>=this.options.min_chars) {
|
292
|
+
this.startIndicator();
|
293
|
+
this.getUpdatedChoices();
|
294
|
+
} else {
|
295
|
+
this.active = false;
|
296
|
+
this.hide();
|
297
|
+
}
|
298
|
+
},
|
299
|
+
|
300
|
+
getEntry: function() {
|
301
|
+
var token_pos = this.findLastToken();
|
302
|
+
if (token_pos != -1)
|
303
|
+
var ret = this.element.value.substr(token_pos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
|
304
|
+
else
|
305
|
+
var ret = this.element.value;
|
306
|
+
|
307
|
+
return /\n/.test(ret) ? '' : ret;
|
308
|
+
},
|
309
|
+
|
310
|
+
findLastToken: function() {
|
311
|
+
var last_token_pos = -1;
|
312
|
+
|
313
|
+
for (var i=0; i<this.options.tokens.length; i++) {
|
314
|
+
var this_token_pos = this.element.value.lastIndexOf(this.options.tokens[i]);
|
315
|
+
if (this_token_pos > last_token_pos)
|
316
|
+
last_token_pos = this_token_pos;
|
317
|
+
}
|
318
|
+
return last_token_pos;
|
319
|
+
}
|
320
|
+
}
|
321
|
+
|
322
|
+
Ajax.Autocompleter = Class.create();
|
323
|
+
Ajax.Autocompleter.prototype = Object.extend(new Autocompleter.Base(),
|
324
|
+
Object.extend(new Ajax.Base(), {
|
325
|
+
initialize: function(element, update, url, options) {
|
326
|
+
this.base_initialize(element, update, options);
|
327
|
+
this.options.asynchronous = true;
|
328
|
+
this.options.onComplete = this.onComplete.bind(this)
|
329
|
+
this.options.method = 'post';
|
330
|
+
this.options.defaultParams = this.options.parameters || null;
|
331
|
+
this.url = url;
|
332
|
+
},
|
333
|
+
|
334
|
+
getUpdatedChoices: function() {
|
335
|
+
entry = encodeURIComponent(this.element.name) + '=' +
|
336
|
+
encodeURIComponent(this.getEntry());
|
337
|
+
|
338
|
+
this.options.parameters = this.options.callback ?
|
339
|
+
this.options.callback(this.element, entry) : entry;
|
340
|
+
|
341
|
+
if(this.options.defaultParams)
|
342
|
+
this.options.parameters += '&' + this.options.defaultParams;
|
343
|
+
|
344
|
+
new Ajax.Request(this.url, this.options);
|
345
|
+
},
|
346
|
+
|
347
|
+
onComplete: function(request) {
|
348
|
+
this.updateChoices(request.responseText);
|
349
|
+
}
|
350
|
+
|
351
|
+
}));
|
352
|
+
|
353
|
+
// The local array autocompleter. Used when you'd prefer to
|
354
|
+
// inject an array of autocompletion options into the page, rather
|
355
|
+
// than sending out Ajax queries, which can be quite slow sometimes.
|
356
|
+
//
|
357
|
+
// The constructor takes four parameters. The first two are, as usual,
|
358
|
+
// the id of the monitored textbox, and id of the autocompletion menu.
|
359
|
+
// The third is the array you want to autocomplete from, and the fourth
|
360
|
+
// is the options block.
|
361
|
+
//
|
362
|
+
// Extra local autocompletion options:
|
363
|
+
// - choices - How many autocompletion choices to offer
|
364
|
+
//
|
365
|
+
// - partial_search - If false, the autocompleter will match entered
|
366
|
+
// text only at the beginning of strings in the
|
367
|
+
// autocomplete array. Defaults to true, which will
|
368
|
+
// match text at the beginning of any *word* in the
|
369
|
+
// strings in the autocomplete array. If you want to
|
370
|
+
// search anywhere in the string, additionally set
|
371
|
+
// the option full_search to true (default: off).
|
372
|
+
//
|
373
|
+
// - full_search - Search anywhere in autocomplete array strings.
|
374
|
+
//
|
375
|
+
// - partial_chars - How many characters to enter before triggering
|
376
|
+
// a partial match (unlike min_chars, which defines
|
377
|
+
// how many characters are required to do any match
|
378
|
+
// at all). Defaults to 2.
|
379
|
+
//
|
380
|
+
// - ignore_case - Whether to ignore case when autocompleting.
|
381
|
+
// Defaults to true.
|
382
|
+
//
|
383
|
+
// It's possible to pass in a custom function as the 'selector'
|
384
|
+
// option, if you prefer to write your own autocompletion logic.
|
385
|
+
// In that case, the other options above will not apply unless
|
386
|
+
// you support them.
|
387
|
+
|
388
|
+
Autocompleter.Local = Class.create();
|
389
|
+
Autocompleter.Local.prototype = Object.extend(new Autocompleter.Base(), {
|
390
|
+
initialize: function(element, update, array, options) {
|
391
|
+
this.base_initialize(element, update, options);
|
392
|
+
this.options.array = array;
|
393
|
+
},
|
394
|
+
|
395
|
+
getUpdatedChoices: function() {
|
396
|
+
this.updateChoices(this.options.selector(this));
|
397
|
+
},
|
398
|
+
|
399
|
+
setOptions: function(options) {
|
400
|
+
this.options = Object.extend({
|
401
|
+
choices: 10,
|
402
|
+
partial_search: true,
|
403
|
+
partial_chars: 2,
|
404
|
+
ignore_case: true,
|
405
|
+
full_search: false,
|
406
|
+
selector: function(instance) {
|
407
|
+
var ret = new Array(); // Beginning matches
|
408
|
+
var partial = new Array(); // Inside matches
|
409
|
+
var entry = instance.getEntry();
|
410
|
+
var count = 0;
|
411
|
+
|
412
|
+
for (var i = 0; i < instance.options.array.length &&
|
413
|
+
ret.length < instance.options.choices ; i++) {
|
414
|
+
var elem = instance.options.array[i];
|
415
|
+
var found_pos = instance.options.ignore_case ?
|
416
|
+
elem.toLowerCase().indexOf(entry.toLowerCase()) :
|
417
|
+
elem.indexOf(entry);
|
418
|
+
|
419
|
+
while (found_pos != -1) {
|
420
|
+
if (found_pos == 0 && elem.length != entry.length) {
|
421
|
+
ret.push("<li><strong>" + elem.substr(0, entry.length) + "</strong>" +
|
422
|
+
elem.substr(entry.length) + "</li>");
|
423
|
+
break;
|
424
|
+
} else if (entry.length >= instance.options.partial_chars &&
|
425
|
+
instance.options.partial_search && found_pos != -1) {
|
426
|
+
if (instance.options.full_search || /\s/.test(elem.substr(found_pos-1,1))) {
|
427
|
+
partial.push("<li>" + elem.substr(0, found_pos) + "<strong>" +
|
428
|
+
elem.substr(found_pos, entry.length) + "</strong>" + elem.substr(
|
429
|
+
found_pos + entry.length) + "</li>");
|
430
|
+
break;
|
431
|
+
}
|
432
|
+
}
|
433
|
+
|
434
|
+
found_pos = instance.options.ignore_case ?
|
435
|
+
elem.toLowerCase().indexOf(entry.toLowerCase(), found_pos + 1) :
|
436
|
+
elem.indexOf(entry, found_pos + 1);
|
437
|
+
|
438
|
+
}
|
439
|
+
}
|
440
|
+
if (partial.length)
|
441
|
+
ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
|
442
|
+
return "<ul>" + ret.join('') + "</ul>";
|
443
|
+
}
|
444
|
+
}, options || {});
|
445
|
+
}
|
446
|
+
});
|
@@ -0,0 +1,537 @@
|
|
1
|
+
// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
|
2
|
+
//
|
3
|
+
// Element.Class part Copyright (c) 2005 by Rick Olson
|
4
|
+
//
|
5
|
+
// Permission is hereby granted, free of charge, to any person obtaining
|
6
|
+
// a copy of this software and associated documentation files (the
|
7
|
+
// "Software"), to deal in the Software without restriction, including
|
8
|
+
// without limitation the rights to use, copy, modify, merge, publish,
|
9
|
+
// distribute, sublicense, and/or sell copies of the Software, and to
|
10
|
+
// permit persons to whom the Software is furnished to do so, subject to
|
11
|
+
// the following conditions:
|
12
|
+
//
|
13
|
+
// The above copyright notice and this permission notice shall be
|
14
|
+
// included in all copies or substantial portions of the Software.
|
15
|
+
//
|
16
|
+
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
17
|
+
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
18
|
+
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
19
|
+
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
20
|
+
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
21
|
+
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
22
|
+
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
23
|
+
|
24
|
+
Element.Class = {
|
25
|
+
// Element.toggleClass(element, className) toggles the class being on/off
|
26
|
+
// Element.toggleClass(element, className1, className2) toggles between both classes,
|
27
|
+
// defaulting to className1 if neither exist
|
28
|
+
toggle: function(element, className) {
|
29
|
+
if(Element.Class.has(element, className)) {
|
30
|
+
Element.Class.remove(element, className);
|
31
|
+
if(arguments.length == 3) Element.Class.add(element, arguments[2]);
|
32
|
+
} else {
|
33
|
+
Element.Class.add(element, className);
|
34
|
+
if(arguments.length == 3) Element.Class.remove(element, arguments[2]);
|
35
|
+
}
|
36
|
+
},
|
37
|
+
|
38
|
+
// gets space-delimited classnames of an element as an array
|
39
|
+
get: function(element) {
|
40
|
+
element = $(element);
|
41
|
+
return element.className.split(' ');
|
42
|
+
},
|
43
|
+
|
44
|
+
// functions adapted from original functions by Gavin Kistner
|
45
|
+
remove: function(element) {
|
46
|
+
element = $(element);
|
47
|
+
var regEx;
|
48
|
+
for(var i = 1; i < arguments.length; i++) {
|
49
|
+
regEx = new RegExp("^" + arguments[i] + "\\b\\s*|\\s*\\b" + arguments[i] + "\\b", 'g');
|
50
|
+
element.className = element.className.replace(regEx, '')
|
51
|
+
}
|
52
|
+
},
|
53
|
+
|
54
|
+
add: function(element) {
|
55
|
+
element = $(element);
|
56
|
+
for(var i = 1; i < arguments.length; i++) {
|
57
|
+
Element.Class.remove(element, arguments[i]);
|
58
|
+
element.className += (element.className.length > 0 ? ' ' : '') + arguments[i];
|
59
|
+
}
|
60
|
+
},
|
61
|
+
|
62
|
+
// returns true if all given classes exist in said element
|
63
|
+
has: function(element) {
|
64
|
+
element = $(element);
|
65
|
+
if(!element || !element.className) return false;
|
66
|
+
var regEx;
|
67
|
+
for(var i = 1; i < arguments.length; i++) {
|
68
|
+
regEx = new RegExp("\\b" + arguments[i] + "\\b");
|
69
|
+
if(!regEx.test(element.className)) return false;
|
70
|
+
}
|
71
|
+
return true;
|
72
|
+
},
|
73
|
+
|
74
|
+
// expects arrays of strings and/or strings as optional paramters
|
75
|
+
// Element.Class.has_any(element, ['classA','classB','classC'], 'classD')
|
76
|
+
has_any: function(element) {
|
77
|
+
element = $(element);
|
78
|
+
if(!element || !element.className) return false;
|
79
|
+
var regEx;
|
80
|
+
for(var i = 1; i < arguments.length; i++) {
|
81
|
+
if((typeof arguments[i] == 'object') &&
|
82
|
+
(arguments[i].constructor == Array)) {
|
83
|
+
for(var j = 0; j < arguments[i].length; j++) {
|
84
|
+
regEx = new RegExp("\\b" + arguments[i][j] + "\\b");
|
85
|
+
if(regEx.test(element.className)) return true;
|
86
|
+
}
|
87
|
+
} else {
|
88
|
+
regEx = new RegExp("\\b" + arguments[i] + "\\b");
|
89
|
+
if(regEx.test(element.className)) return true;
|
90
|
+
}
|
91
|
+
}
|
92
|
+
return false;
|
93
|
+
},
|
94
|
+
|
95
|
+
childrenWith: function(element, className) {
|
96
|
+
var children = $(element).getElementsByTagName('*');
|
97
|
+
var elements = new Array();
|
98
|
+
|
99
|
+
for (var i = 0; i < children.length; i++) {
|
100
|
+
if (Element.Class.has(children[i], className)) {
|
101
|
+
elements.push(children[i]);
|
102
|
+
break;
|
103
|
+
}
|
104
|
+
}
|
105
|
+
|
106
|
+
return elements;
|
107
|
+
}
|
108
|
+
}
|
109
|
+
|
110
|
+
/*--------------------------------------------------------------------------*/
|
111
|
+
|
112
|
+
var Droppables = {
|
113
|
+
drops: false,
|
114
|
+
|
115
|
+
remove: function(element) {
|
116
|
+
for(var i = 0; i < this.drops.length; i++)
|
117
|
+
if(this.drops[i].element == element)
|
118
|
+
this.drops.splice(i,1);
|
119
|
+
},
|
120
|
+
|
121
|
+
add: function(element) {
|
122
|
+
var element = $(element);
|
123
|
+
var options = Object.extend({
|
124
|
+
greedy: true,
|
125
|
+
hoverclass: null
|
126
|
+
}, arguments[1] || {});
|
127
|
+
|
128
|
+
// cache containers
|
129
|
+
if(options.containment) {
|
130
|
+
options._containers = new Array();
|
131
|
+
var containment = options.containment;
|
132
|
+
if((typeof containment == 'object') &&
|
133
|
+
(containment.constructor == Array)) {
|
134
|
+
for(var i=0; i<containment.length; i++)
|
135
|
+
options._containers.push($(containment[i]));
|
136
|
+
} else {
|
137
|
+
options._containers.push($(containment));
|
138
|
+
}
|
139
|
+
options._containers_length =
|
140
|
+
options._containers.length-1;
|
141
|
+
}
|
142
|
+
|
143
|
+
Element.makePositioned(element); // fix IE
|
144
|
+
|
145
|
+
options.element = element;
|
146
|
+
|
147
|
+
// activate the droppable
|
148
|
+
if(!this.drops) this.drops = [];
|
149
|
+
this.drops.push(options);
|
150
|
+
},
|
151
|
+
|
152
|
+
is_contained: function(element, drop) {
|
153
|
+
var containers = drop._containers;
|
154
|
+
var parentNode = element.parentNode;
|
155
|
+
var i = drop._containers_length;
|
156
|
+
do { if(parentNode==containers[i]) return true; } while (i--);
|
157
|
+
return false;
|
158
|
+
},
|
159
|
+
|
160
|
+
is_affected: function(pX, pY, element, drop) {
|
161
|
+
return (
|
162
|
+
(drop.element!=element) &&
|
163
|
+
((!drop._containers) ||
|
164
|
+
this.is_contained(element, drop)) &&
|
165
|
+
((!drop.accept) ||
|
166
|
+
(Element.Class.has_any(element, drop.accept))) &&
|
167
|
+
Position.within(drop.element, pX, pY) );
|
168
|
+
},
|
169
|
+
|
170
|
+
deactivate: function(drop) {
|
171
|
+
Element.Class.remove(drop.element, drop.hoverclass);
|
172
|
+
this.last_active = null;
|
173
|
+
},
|
174
|
+
|
175
|
+
activate: function(drop) {
|
176
|
+
if(this.last_active) this.deactivate(this.last_active);
|
177
|
+
if(drop.hoverclass) {
|
178
|
+
Element.Class.add(drop.element, drop.hoverclass);
|
179
|
+
this.last_active = drop;
|
180
|
+
}
|
181
|
+
},
|
182
|
+
|
183
|
+
show: function(event, element) {
|
184
|
+
if(!this.drops) return;
|
185
|
+
var pX = Event.pointerX(event);
|
186
|
+
var pY = Event.pointerY(event);
|
187
|
+
Position.prepare();
|
188
|
+
|
189
|
+
var i = this.drops.length-1; do {
|
190
|
+
var drop = this.drops[i];
|
191
|
+
if(this.is_affected(pX, pY, element, drop)) {
|
192
|
+
if(drop.onHover)
|
193
|
+
drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
|
194
|
+
if(drop.greedy) {
|
195
|
+
this.activate(drop);
|
196
|
+
return;
|
197
|
+
}
|
198
|
+
}
|
199
|
+
} while (i--);
|
200
|
+
},
|
201
|
+
|
202
|
+
fire: function(event, element) {
|
203
|
+
if(!this.last_active) return;
|
204
|
+
Position.prepare();
|
205
|
+
|
206
|
+
if (this.is_affected(Event.pointerX(event), Event.pointerY(event), element, this.last_active))
|
207
|
+
if (this.last_active.onDrop)
|
208
|
+
this.last_active.onDrop(element, this.last_active);
|
209
|
+
|
210
|
+
},
|
211
|
+
|
212
|
+
reset: function() {
|
213
|
+
if(this.last_active)
|
214
|
+
this.deactivate(this.last_active);
|
215
|
+
}
|
216
|
+
}
|
217
|
+
|
218
|
+
Draggables = {
|
219
|
+
observers: new Array(),
|
220
|
+
addObserver: function(observer) {
|
221
|
+
this.observers.push(observer);
|
222
|
+
},
|
223
|
+
removeObserver: function(element) { // element instead of obsever fixes mem leaks
|
224
|
+
for(var i = 0; i < this.observers.length; i++)
|
225
|
+
if(this.observers[i].element && (this.observers[i].element == element))
|
226
|
+
this.observers.splice(i,1);
|
227
|
+
},
|
228
|
+
notify: function(eventName, draggable) { // 'onStart', 'onEnd'
|
229
|
+
for(var i = 0; i < this.observers.length; i++)
|
230
|
+
this.observers[i][eventName](draggable);
|
231
|
+
}
|
232
|
+
}
|
233
|
+
|
234
|
+
/*--------------------------------------------------------------------------*/
|
235
|
+
|
236
|
+
Draggable = Class.create();
|
237
|
+
Draggable.prototype = {
|
238
|
+
initialize: function(element) {
|
239
|
+
var options = Object.extend({
|
240
|
+
handle: false,
|
241
|
+
starteffect: function(element) {
|
242
|
+
new Effect.Opacity(element, {duration:0.2, from:1.0, to:0.7});
|
243
|
+
},
|
244
|
+
reverteffect: function(element, top_offset, left_offset) {
|
245
|
+
new Effect.MoveBy(element, -top_offset, -left_offset, {duration:0.4});
|
246
|
+
},
|
247
|
+
endeffect: function(element) {
|
248
|
+
new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0});
|
249
|
+
},
|
250
|
+
zindex: 1000,
|
251
|
+
revert: false
|
252
|
+
}, arguments[1] || {});
|
253
|
+
|
254
|
+
this.element = $(element);
|
255
|
+
this.handle = options.handle ? $(options.handle) : this.element;
|
256
|
+
|
257
|
+
Element.makePositioned(this.element); // fix IE
|
258
|
+
|
259
|
+
this.offsetX = 0;
|
260
|
+
this.offsetY = 0;
|
261
|
+
this.originalLeft = this.currentLeft();
|
262
|
+
this.originalTop = this.currentTop();
|
263
|
+
this.originalX = this.element.offsetLeft;
|
264
|
+
this.originalY = this.element.offsetTop;
|
265
|
+
this.originalZ = parseInt(this.element.style.zIndex || "0");
|
266
|
+
|
267
|
+
this.options = options;
|
268
|
+
|
269
|
+
this.active = false;
|
270
|
+
this.dragging = false;
|
271
|
+
|
272
|
+
this.eventMouseDown = this.startDrag.bindAsEventListener(this);
|
273
|
+
this.eventMouseUp = this.endDrag.bindAsEventListener(this);
|
274
|
+
this.eventMouseMove = this.update.bindAsEventListener(this);
|
275
|
+
this.eventKeypress = this.keyPress.bindAsEventListener(this);
|
276
|
+
|
277
|
+
Event.observe(this.handle, "mousedown", this.eventMouseDown);
|
278
|
+
Event.observe(document, "mouseup", this.eventMouseUp);
|
279
|
+
Event.observe(document, "mousemove", this.eventMouseMove);
|
280
|
+
Event.observe(document, "keypress", this.eventKeypress);
|
281
|
+
},
|
282
|
+
destroy: function() {
|
283
|
+
Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
|
284
|
+
Event.stopObserving(document, "mouseup", this.eventMouseUp);
|
285
|
+
Event.stopObserving(document, "mousemove", this.eventMouseMove);
|
286
|
+
Event.stopObserving(document, "keypress", this.eventKeypress);
|
287
|
+
},
|
288
|
+
currentLeft: function() {
|
289
|
+
return parseInt(this.element.style.left || '0');
|
290
|
+
},
|
291
|
+
currentTop: function() {
|
292
|
+
return parseInt(this.element.style.top || '0')
|
293
|
+
},
|
294
|
+
startDrag: function(event) {
|
295
|
+
if(Event.isLeftClick(event)) {
|
296
|
+
this.active = true;
|
297
|
+
|
298
|
+
var style = this.element.style;
|
299
|
+
this.originalY = this.element.offsetTop - this.currentTop() - this.originalTop;
|
300
|
+
this.originalX = this.element.offsetLeft - this.currentLeft() - this.originalLeft;
|
301
|
+
this.offsetY = event.clientY - this.originalY - this.originalTop;
|
302
|
+
this.offsetX = event.clientX - this.originalX - this.originalLeft;
|
303
|
+
|
304
|
+
Event.stop(event);
|
305
|
+
}
|
306
|
+
},
|
307
|
+
finishDrag: function(event, success) {
|
308
|
+
this.active = false;
|
309
|
+
this.dragging = false;
|
310
|
+
|
311
|
+
if(success) Droppables.fire(event, this.element);
|
312
|
+
Draggables.notify('onEnd', this);
|
313
|
+
|
314
|
+
var revert = this.options.revert;
|
315
|
+
if(revert && typeof revert == 'function') revert = revert(this.element);
|
316
|
+
|
317
|
+
if(revert && this.options.reverteffect) {
|
318
|
+
this.options.reverteffect(this.element,
|
319
|
+
this.currentTop()-this.originalTop,
|
320
|
+
this.currentLeft()-this.originalLeft);
|
321
|
+
} else {
|
322
|
+
this.originalLeft = this.currentLeft();
|
323
|
+
this.originalTop = this.currentTop();
|
324
|
+
}
|
325
|
+
|
326
|
+
this.element.style.zIndex = this.originalZ;
|
327
|
+
|
328
|
+
if(this.options.endeffect)
|
329
|
+
this.options.endeffect(this.element);
|
330
|
+
|
331
|
+
Droppables.reset();
|
332
|
+
},
|
333
|
+
keyPress: function(event) {
|
334
|
+
if(this.active) {
|
335
|
+
if(event.keyCode==Event.KEY_ESC) {
|
336
|
+
this.finishDrag(event, false);
|
337
|
+
Event.stop(event);
|
338
|
+
}
|
339
|
+
}
|
340
|
+
},
|
341
|
+
endDrag: function(event) {
|
342
|
+
if(this.active && this.dragging) {
|
343
|
+
this.finishDrag(event, true);
|
344
|
+
Event.stop(event);
|
345
|
+
}
|
346
|
+
this.active = false;
|
347
|
+
this.dragging = false;
|
348
|
+
},
|
349
|
+
draw: function(event) {
|
350
|
+
var style = this.element.style;
|
351
|
+
this.originalX = this.element.offsetLeft - this.currentLeft() - this.originalLeft;
|
352
|
+
this.originalY = this.element.offsetTop - this.currentTop() - this.originalTop;
|
353
|
+
if((!this.options.constraint) || (this.options.constraint=='horizontal'))
|
354
|
+
style.left = ((event.clientX - this.originalX) - this.offsetX) + "px";
|
355
|
+
if((!this.options.constraint) || (this.options.constraint=='vertical'))
|
356
|
+
style.top = ((event.clientY - this.originalY) - this.offsetY) + "px";
|
357
|
+
if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
|
358
|
+
},
|
359
|
+
update: function(event) {
|
360
|
+
if(this.active) {
|
361
|
+
if(!this.dragging) {
|
362
|
+
var style = this.element.style;
|
363
|
+
this.dragging = true;
|
364
|
+
if(style.position=="") style.position = "relative";
|
365
|
+
style.zIndex = this.options.zindex;
|
366
|
+
Draggables.notify('onStart', this);
|
367
|
+
if(this.options.starteffect) this.options.starteffect(this.element);
|
368
|
+
}
|
369
|
+
|
370
|
+
Droppables.show(event, this.element);
|
371
|
+
this.draw(event);
|
372
|
+
if(this.options.change) this.options.change(this);
|
373
|
+
|
374
|
+
// fix AppleWebKit rendering
|
375
|
+
if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
|
376
|
+
|
377
|
+
Event.stop(event);
|
378
|
+
}
|
379
|
+
}
|
380
|
+
}
|
381
|
+
|
382
|
+
/*--------------------------------------------------------------------------*/
|
383
|
+
|
384
|
+
SortableObserver = Class.create();
|
385
|
+
SortableObserver.prototype = {
|
386
|
+
initialize: function(element, observer) {
|
387
|
+
this.element = $(element);
|
388
|
+
this.observer = observer;
|
389
|
+
this.lastValue = Sortable.serialize(this.element);
|
390
|
+
},
|
391
|
+
onStart: function() {
|
392
|
+
this.lastValue = Sortable.serialize(this.element);
|
393
|
+
},
|
394
|
+
onEnd: function() {
|
395
|
+
if(this.lastValue != Sortable.serialize(this.element))
|
396
|
+
this.observer(this.element)
|
397
|
+
}
|
398
|
+
}
|
399
|
+
|
400
|
+
Sortable = {
|
401
|
+
sortables: new Array(),
|
402
|
+
options: function(element){
|
403
|
+
var element = $(element);
|
404
|
+
for(var i=0;i<this.sortables.length;i++)
|
405
|
+
if(this.sortables[i].element == element)
|
406
|
+
return this.sortables[i];
|
407
|
+
return null;
|
408
|
+
},
|
409
|
+
destroy: function(element){
|
410
|
+
var element = $(element);
|
411
|
+
for(var i=0;i<this.sortables.length;i++) {
|
412
|
+
if(this.sortables[i].element == element) {
|
413
|
+
var s = this.sortables[i];
|
414
|
+
Draggables.removeObserver(s.element);
|
415
|
+
for(var j=0;j<s.droppables.length;j++)
|
416
|
+
Droppables.remove(s.droppables[j]);
|
417
|
+
for(var j=0;j<s.draggables.length;j++)
|
418
|
+
s.draggables[j].destroy();
|
419
|
+
this.sortables.splice(i,1);
|
420
|
+
}
|
421
|
+
}
|
422
|
+
},
|
423
|
+
create: function(element) {
|
424
|
+
var element = $(element);
|
425
|
+
var options = Object.extend({
|
426
|
+
element: element,
|
427
|
+
tag: 'li', // assumes li children, override with tag: 'tagname'
|
428
|
+
overlap: 'vertical', // one of 'vertical', 'horizontal'
|
429
|
+
constraint: 'vertical', // one of 'vertical', 'horizontal', false
|
430
|
+
containment: element, // also takes array of elements (or id's); or false
|
431
|
+
handle: false, // or a CSS class
|
432
|
+
only: false,
|
433
|
+
hoverclass: null,
|
434
|
+
onChange: function() {},
|
435
|
+
onUpdate: function() {}
|
436
|
+
}, arguments[1] || {});
|
437
|
+
|
438
|
+
// clear any old sortable with same element
|
439
|
+
this.destroy(element);
|
440
|
+
|
441
|
+
// build options for the draggables
|
442
|
+
var options_for_draggable = {
|
443
|
+
revert: true,
|
444
|
+
constraint: options.constraint,
|
445
|
+
handle: handle };
|
446
|
+
if(options.starteffect)
|
447
|
+
options_for_draggable.starteffect = options.starteffect;
|
448
|
+
if(options.reverteffect)
|
449
|
+
options_for_draggable.reverteffect = options.reverteffect;
|
450
|
+
if(options.endeffect)
|
451
|
+
options_for_draggable.endeffect = options.endeffect;
|
452
|
+
if(options.zindex)
|
453
|
+
options_for_draggable.zindex = options.zindex;
|
454
|
+
|
455
|
+
// build options for the droppables
|
456
|
+
var options_for_droppable = {
|
457
|
+
overlap: options.overlap,
|
458
|
+
containment: options.containment,
|
459
|
+
hoverclass: options.hoverclass,
|
460
|
+
onHover: function(element, dropon, overlap) {
|
461
|
+
if(overlap>0.5) {
|
462
|
+
if(dropon.previousSibling != element) {
|
463
|
+
var oldParentNode = element.parentNode;
|
464
|
+
element.style.visibility = "hidden"; // fix gecko rendering
|
465
|
+
dropon.parentNode.insertBefore(element, dropon);
|
466
|
+
if(dropon.parentNode!=oldParentNode && oldParentNode.sortable)
|
467
|
+
oldParentNode.sortable.onChange(element);
|
468
|
+
if(dropon.parentNode.sortable)
|
469
|
+
dropon.parentNode.sortable.onChange(element);
|
470
|
+
}
|
471
|
+
} else {
|
472
|
+
var nextElement = dropon.nextSibling || null;
|
473
|
+
if(nextElement != element) {
|
474
|
+
var oldParentNode = element.parentNode;
|
475
|
+
element.style.visibility = "hidden"; // fix gecko rendering
|
476
|
+
dropon.parentNode.insertBefore(element, nextElement);
|
477
|
+
if(dropon.parentNode!=oldParentNode && oldParentNode.sortable)
|
478
|
+
oldParentNode.sortable.onChange(element);
|
479
|
+
if(dropon.parentNode.sortable)
|
480
|
+
dropon.parentNode.sortable.onChange(element);
|
481
|
+
}
|
482
|
+
}
|
483
|
+
}
|
484
|
+
}
|
485
|
+
|
486
|
+
// fix for gecko engine
|
487
|
+
Element.cleanWhitespace(element);
|
488
|
+
|
489
|
+
options.draggables = [];
|
490
|
+
options.droppables = [];
|
491
|
+
|
492
|
+
// make it so
|
493
|
+
var elements = element.childNodes;
|
494
|
+
for (var i = 0; i < elements.length; i++)
|
495
|
+
if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() &&
|
496
|
+
(!options.only || (Element.Class.has(elements[i], options.only)))) {
|
497
|
+
|
498
|
+
// handles are per-draggable
|
499
|
+
var handle = options.handle ?
|
500
|
+
Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i];
|
501
|
+
|
502
|
+
options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle })));
|
503
|
+
|
504
|
+
Droppables.add(elements[i], options_for_droppable);
|
505
|
+
options.droppables.push(elements[i]);
|
506
|
+
|
507
|
+
}
|
508
|
+
|
509
|
+
// keep reference
|
510
|
+
this.sortables.push(options);
|
511
|
+
|
512
|
+
// for onupdate
|
513
|
+
Draggables.addObserver(new SortableObserver(element, options.onUpdate));
|
514
|
+
|
515
|
+
},
|
516
|
+
serialize: function(element) {
|
517
|
+
var element = $(element);
|
518
|
+
var sortableOptions = this.options(element);
|
519
|
+
var options = Object.extend({
|
520
|
+
tag: sortableOptions.tag,
|
521
|
+
only: sortableOptions.only,
|
522
|
+
name: element.id
|
523
|
+
}, arguments[1] || {});
|
524
|
+
|
525
|
+
var items = $(element).childNodes;
|
526
|
+
var queryComponents = new Array();
|
527
|
+
|
528
|
+
for(var i=0; i<items.length; i++)
|
529
|
+
if(items[i].tagName && items[i].tagName==options.tag.toUpperCase() &&
|
530
|
+
(!options.only || (Element.Class.has(items[i], options.only))))
|
531
|
+
queryComponents.push(
|
532
|
+
encodeURIComponent(options.name) + "[]=" +
|
533
|
+
encodeURIComponent(items[i].id.split("_")[1]));
|
534
|
+
|
535
|
+
return queryComponents.join("&");
|
536
|
+
}
|
537
|
+
}
|