You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jspwiki.apache.org by br...@apache.org on 2009/09/26 15:23:59 UTC
svn commit: r819135 [4/4] - in
/incubator/jspwiki/trunk/src/WebContent/scripts: dialog.js
jspwiki-common.js jspwiki-commonstyles.js jspwiki-edit.js jspwiki-prefs.js
mootools-core.js mootools-more.js mootools.js stripes-support.js
Added: incubator/jspwiki/trunk/src/WebContent/scripts/mootools-more.js
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/src/WebContent/scripts/mootools-more.js?rev=819135&view=auto
==============================================================================
--- incubator/jspwiki/trunk/src/WebContent/scripts/mootools-more.js (added)
+++ incubator/jspwiki/trunk/src/WebContent/scripts/mootools-more.js Sat Sep 26 13:23:58 2009
@@ -0,0 +1,782 @@
+//MooTools More, <http://mootools.net/more>. Copyright (c) 2006-2009 Aaron Newton <http://clientcide.com/>, Valerio Proietti <http://mad4milk.net> & the MooTools team <http://mootools.net/developers>, MIT Style License.
+
+MooTools.More = {
+ 'version': '1.2.3.1'
+};
+
+/*
+Script: Fx.Elements.js
+ Effect to change any number of CSS properties of any number of Elements.
+
+ License:
+ MIT-style license.
+
+ Authors:
+ Valerio Proietti
+*/
+
+Fx.Elements = new Class({
+
+ Extends: Fx.CSS,
+
+ initialize: function(elements, options){
+ this.elements = this.subject = $$(elements);
+ this.parent(options);
+ },
+
+ compute: function(from, to, delta){
+ var now = {};
+ for (var i in from){
+ var iFrom = from[i], iTo = to[i], iNow = now[i] = {};
+ for (var p in iFrom) iNow[p] = this.parent(iFrom[p], iTo[p], delta);
+ }
+ return now;
+ },
+
+ set: function(now){
+ for (var i in now){
+ var iNow = now[i];
+ for (var p in iNow) this.render(this.elements[i], p, iNow[p], this.options.unit);
+ }
+ return this;
+ },
+
+ start: function(obj){
+ if (!this.check(obj)) return this;
+ var from = {}, to = {};
+ for (var i in obj){
+ var iProps = obj[i], iFrom = from[i] = {}, iTo = to[i] = {};
+ for (var p in iProps){
+ var parsed = this.prepare(this.elements[i], p, iProps[p]);
+ iFrom[p] = parsed.from;
+ iTo[p] = parsed.to;
+ }
+ }
+ return this.parent(from, to);
+ }
+
+});
+
+/*
+Script: Fx.Accordion.js
+ An Fx.Elements extension which allows you to easily create accordion type controls.
+
+ License:
+ MIT-style license.
+
+ Authors:
+ Valerio Proietti
+*/
+
+var Accordion = Fx.Accordion = new Class({
+
+ Extends: Fx.Elements,
+
+ options: {/*
+ onActive: $empty(toggler, section),
+ onBackground: $empty(toggler, section),*/
+ display: 0,
+ show: false,
+ height: true,
+ width: false,
+ opacity: true,
+ fixedHeight: false,
+ fixedWidth: false,
+ wait: false,
+ alwaysHide: false,
+ trigger: 'click',
+ initialDisplayFx: true
+ },
+
+ initialize: function(){
+ var params = Array.link(arguments, {'container': Element.type, 'options': Object.type, 'togglers': $defined, 'elements': $defined});
+ this.parent(params.elements, params.options);
+ this.togglers = $$(params.togglers);
+ this.container = document.id(params.container);
+ this.previous = -1;
+ if (this.options.alwaysHide) this.options.wait = true;
+ if ($chk(this.options.show)){
+ this.options.display = false;
+ this.previous = this.options.show;
+ }
+ if (this.options.start){
+ this.options.display = false;
+ this.options.show = false;
+ }
+ this.effects = {};
+ if (this.options.opacity) this.effects.opacity = 'fullOpacity';
+ if (this.options.width) this.effects.width = this.options.fixedWidth ? 'fullWidth' : 'offsetWidth';
+ if (this.options.height) this.effects.height = this.options.fixedHeight ? 'fullHeight' : 'scrollHeight';
+ for (var i = 0, l = this.togglers.length; i < l; i++) this.addSection(this.togglers[i], this.elements[i]);
+ this.elements.each(function(el, i){
+ if (this.options.show === i){
+ this.fireEvent('active', [this.togglers[i], el]);
+ } else {
+ for (var fx in this.effects) el.setStyle(fx, 0);
+ }
+ }, this);
+ if ($chk(this.options.display)) this.display(this.options.display, this.options.initialDisplayFx);
+ },
+
+ addSection: function(toggler, element){
+ toggler = document.id(toggler);
+ element = document.id(element);
+ var test = this.togglers.contains(toggler);
+ this.togglers.include(toggler);
+ this.elements.include(element);
+ var idx = this.togglers.indexOf(toggler);
+ toggler.addEvent(this.options.trigger, this.display.bind(this, idx));
+ if (this.options.height) element.setStyles({'padding-top': 0, 'border-top': 'none', 'padding-bottom': 0, 'border-bottom': 'none'});
+ if (this.options.width) element.setStyles({'padding-left': 0, 'border-left': 'none', 'padding-right': 0, 'border-right': 'none'});
+ element.fullOpacity = 1;
+ if (this.options.fixedWidth) element.fullWidth = this.options.fixedWidth;
+ if (this.options.fixedHeight) element.fullHeight = this.options.fixedHeight;
+ element.setStyle('overflow', 'hidden');
+ if (!test){
+ for (var fx in this.effects) element.setStyle(fx, 0);
+ }
+ return this;
+ },
+
+ display: function(index, useFx){
+ useFx = $pick(useFx, true);
+ index = ($type(index) == 'element') ? this.elements.indexOf(index) : index;
+ if ((this.timer && this.options.wait) || (index === this.previous && !this.options.alwaysHide)) return this;
+ this.previous = index;
+ var obj = {};
+ this.elements.each(function(el, i){
+ obj[i] = {};
+ var hide = (i != index) || (this.options.alwaysHide && (el.offsetHeight > 0));
+ this.fireEvent(hide ? 'background' : 'active', [this.togglers[i], el]);
+ for (var fx in this.effects) obj[i][fx] = hide ? 0 : el[this.effects[fx]];
+ }, this);
+ return useFx ? this.start(obj) : this.set(obj);
+ }
+
+});
+
+/*
+Script: Drag.js
+ The base Drag Class. Can be used to drag and resize Elements using mouse events.
+
+ License:
+ MIT-style license.
+
+ Authors:
+ Valerio Proietti
+ Tom Occhinno
+ Jan Kassens
+*/
+
+var Drag = new Class({
+
+ Implements: [Events, Options],
+
+ options: {/*
+ onBeforeStart: $empty(thisElement),
+ onStart: $empty(thisElement, event),
+ onSnap: $empty(thisElement)
+ onDrag: $empty(thisElement, event),
+ onCancel: $empty(thisElement),
+ onComplete: $empty(thisElement, event),*/
+ snap: 6,
+ unit: 'px',
+ grid: false,
+ style: true,
+ limit: false,
+ handle: false,
+ invert: false,
+ preventDefault: false,
+ modifiers: {x: 'left', y: 'top'}
+ },
+
+ initialize: function(){
+ var params = Array.link(arguments, {'options': Object.type, 'element': $defined});
+ this.element = document.id(params.element);
+ this.document = this.element.getDocument();
+ this.setOptions(params.options || {});
+ var htype = $type(this.options.handle);
+ this.handles = ((htype == 'array' || htype == 'collection') ? $$(this.options.handle) : document.id(this.options.handle)) || this.element;
+ this.mouse = {'now': {}, 'pos': {}};
+ this.value = {'start': {}, 'now': {}};
+
+ this.selection = (Browser.Engine.trident) ? 'selectstart' : 'mousedown';
+
+ this.bound = {
+ start: this.start.bind(this),
+ check: this.check.bind(this),
+ drag: this.drag.bind(this),
+ stop: this.stop.bind(this),
+ cancel: this.cancel.bind(this),
+ eventStop: $lambda(false)
+ };
+ this.attach();
+ },
+
+ attach: function(){
+ this.handles.addEvent('mousedown', this.bound.start);
+ return this;
+ },
+
+ detach: function(){
+ this.handles.removeEvent('mousedown', this.bound.start);
+ return this;
+ },
+
+ start: function(event){
+ if (this.options.preventDefault) event.preventDefault();
+ this.mouse.start = event.page;
+ this.fireEvent('beforeStart', this.element);
+ var limit = this.options.limit;
+ this.limit = {x: [], y: []};
+ for (var z in this.options.modifiers){
+ if (!this.options.modifiers[z]) continue;
+ if (this.options.style) this.value.now[z] = this.element.getStyle(this.options.modifiers[z]).toInt();
+ else this.value.now[z] = this.element[this.options.modifiers[z]];
+ if (this.options.invert) this.value.now[z] *= -1;
+ this.mouse.pos[z] = event.page[z] - this.value.now[z];
+ if (limit && limit[z]){
+ for (var i = 2; i--; i){
+ if ($chk(limit[z][i])) this.limit[z][i] = $lambda(limit[z][i])();
+ }
+ }
+ }
+ if ($type(this.options.grid) == 'number') this.options.grid = {x: this.options.grid, y: this.options.grid};
+ this.document.addEvents({mousemove: this.bound.check, mouseup: this.bound.cancel});
+ this.document.addEvent(this.selection, this.bound.eventStop);
+ },
+
+ check: function(event){
+ if (this.options.preventDefault) event.preventDefault();
+ var distance = Math.round(Math.sqrt(Math.pow(event.page.x - this.mouse.start.x, 2) + Math.pow(event.page.y - this.mouse.start.y, 2)));
+ if (distance > this.options.snap){
+ this.cancel();
+ this.document.addEvents({
+ mousemove: this.bound.drag,
+ mouseup: this.bound.stop
+ });
+ this.fireEvent('start', [this.element, event]).fireEvent('snap', this.element);
+ }
+ },
+
+ drag: function(event){
+ if (this.options.preventDefault) event.preventDefault();
+ this.mouse.now = event.page;
+ for (var z in this.options.modifiers){
+ if (!this.options.modifiers[z]) continue;
+ this.value.now[z] = this.mouse.now[z] - this.mouse.pos[z];
+ if (this.options.invert) this.value.now[z] *= -1;
+ if (this.options.limit && this.limit[z]){
+ if ($chk(this.limit[z][1]) && (this.value.now[z] > this.limit[z][1])){
+ this.value.now[z] = this.limit[z][1];
+ } else if ($chk(this.limit[z][0]) && (this.value.now[z] < this.limit[z][0])){
+ this.value.now[z] = this.limit[z][0];
+ }
+ }
+ if (this.options.grid[z]) this.value.now[z] -= ((this.value.now[z] - (this.limit[z][0]||0)) % this.options.grid[z]);
+ if (this.options.style) this.element.setStyle(this.options.modifiers[z], this.value.now[z] + this.options.unit);
+ else this.element[this.options.modifiers[z]] = this.value.now[z];
+ }
+ this.fireEvent('drag', [this.element, event]);
+ },
+
+ cancel: function(event){
+ this.document.removeEvent('mousemove', this.bound.check);
+ this.document.removeEvent('mouseup', this.bound.cancel);
+ if (event){
+ this.document.removeEvent(this.selection, this.bound.eventStop);
+ this.fireEvent('cancel', this.element);
+ }
+ },
+
+ stop: function(event){
+ this.document.removeEvent(this.selection, this.bound.eventStop);
+ this.document.removeEvent('mousemove', this.bound.drag);
+ this.document.removeEvent('mouseup', this.bound.stop);
+ if (event) this.fireEvent('complete', [this.element, event]);
+ }
+
+});
+
+Element.implement({
+
+ makeResizable: function(options){
+ var drag = new Drag(this, $merge({modifiers: {x: 'width', y: 'height'}}, options));
+ this.store('resizer', drag);
+ return drag.addEvent('drag', function(){
+ this.fireEvent('resize', drag);
+ }.bind(this));
+ }
+
+});
+
+
+/*
+Script: Drag.Move.js
+ A Drag extension that provides support for the constraining of draggables to containers and droppables.
+
+ License:
+ MIT-style license.
+
+ Authors:
+ Valerio Proietti
+ Tom Occhinno
+ Jan Kassens*/
+
+Drag.Move = new Class({
+
+ Extends: Drag,
+
+ options: {/*
+ onEnter: $empty(thisElement, overed),
+ onLeave: $empty(thisElement, overed),
+ onDrop: $empty(thisElement, overed, event),*/
+ droppables: [],
+ container: false,
+ precalculate: false,
+ includeMargins: true,
+ checkDroppables: true
+ },
+
+ initialize: function(element, options){
+ this.parent(element, options);
+ this.droppables = $$(this.options.droppables);
+ this.container = document.id(this.options.container);
+ if (this.container && $type(this.container) != 'element') this.container = document.id(this.container.getDocument().body);
+
+ var position = this.element.getStyle('position');
+ if (position=='static') position = 'absolute';
+ if ([this.element.getStyle('left'), this.element.getStyle('top')].contains('auto')) this.element.position(this.element.getPosition(this.element.offsetParent));
+ this.element.setStyle('position', position);
+
+ this.addEvent('start', this.checkDroppables, true);
+
+ this.overed = null;
+ },
+
+ start: function(event){
+ if (this.container){
+ var ccoo = this.container.getCoordinates(this.element.getOffsetParent()), cbs = {}, ems = {};
+
+ ['top', 'right', 'bottom', 'left'].each(function(pad){
+ cbs[pad] = this.container.getStyle('border-' + pad).toInt();
+ ems[pad] = this.element.getStyle('margin-' + pad).toInt();
+ }, this);
+
+ var width = this.element.offsetWidth + ems.left + ems.right;
+ var height = this.element.offsetHeight + ems.top + ems.bottom;
+
+ if (this.options.includeMargins) {
+ $each(ems, function(value, key) {
+ ems[key] = 0;
+ });
+ }
+ if (this.container == this.element.getOffsetParent()) {
+ this.options.limit = {
+ x: [0 - ems.left, ccoo.right - cbs.left - cbs.right - width + ems.right],
+ y: [0 - ems.top, ccoo.bottom - cbs.top - cbs.bottom - height + ems.bottom]
+ };
+ } else {
+ this.options.limit = {
+ x: [ccoo.left + cbs.left - ems.left, ccoo.right - cbs.right - width + ems.right],
+ y: [ccoo.top + cbs.top - ems.top, ccoo.bottom - cbs.bottom - height + ems.bottom]
+ };
+ }
+
+ }
+ if (this.options.precalculate){
+ this.positions = this.droppables.map(function(el) {
+ return el.getCoordinates();
+ });
+ }
+ this.parent(event);
+ },
+
+ checkAgainst: function(el, i){
+ el = (this.positions) ? this.positions[i] : el.getCoordinates();
+ var now = this.mouse.now;
+ return (now.x > el.left && now.x < el.right && now.y < el.bottom && now.y > el.top);
+ },
+
+ checkDroppables: function(){
+ var overed = this.droppables.filter(this.checkAgainst, this).getLast();
+ if (this.overed != overed){
+ if (this.overed) this.fireEvent('leave', [this.element, this.overed]);
+ if (overed) this.fireEvent('enter', [this.element, overed]);
+ this.overed = overed;
+ }
+ },
+
+ drag: function(event){
+ this.parent(event);
+ if (this.options.checkDroppables && this.droppables.length) this.checkDroppables();
+ },
+
+ stop: function(event){
+ this.checkDroppables();
+ this.fireEvent('drop', [this.element, this.overed, event]);
+ this.overed = null;
+ return this.parent(event);
+ }
+
+});
+
+Element.implement({
+
+ makeDraggable: function(options){
+ var drag = new Drag.Move(this, options);
+ this.store('dragger', drag);
+ return drag;
+ }
+
+});
+
+
+/*
+Script: Color.js
+ Class for creating and manipulating colors in JavaScript. Supports HSB -> RGB Conversions and vice versa.
+
+ License:
+ MIT-style license.
+
+ Authors:
+ Valerio Proietti
+*/
+
+var Color = new Native({
+
+ initialize: function(color, type){
+ if (arguments.length >= 3){
+ type = 'rgb'; color = Array.slice(arguments, 0, 3);
+ } else if (typeof color == 'string'){
+ if (color.match(/rgb/)) color = color.rgbToHex().hexToRgb(true);
+ else if (color.match(/hsb/)) color = color.hsbToRgb();
+ else color = color.hexToRgb(true);
+ }
+ type = type || 'rgb';
+ switch (type){
+ case 'hsb':
+ var old = color;
+ color = color.hsbToRgb();
+ color.hsb = old;
+ break;
+ case 'hex': color = color.hexToRgb(true); break;
+ }
+ color.rgb = color.slice(0, 3);
+ color.hsb = color.hsb || color.rgbToHsb();
+ color.hex = color.rgbToHex();
+ return $extend(color, this);
+ }
+
+});
+
+Color.implement({
+
+ mix: function(){
+ var colors = Array.slice(arguments);
+ var alpha = ($type(colors.getLast()) == 'number') ? colors.pop() : 50;
+ var rgb = this.slice();
+ colors.each(function(color){
+ color = new Color(color);
+ for (var i = 0; i < 3; i++) rgb[i] = Math.round((rgb[i] / 100 * (100 - alpha)) + (color[i] / 100 * alpha));
+ });
+ return new Color(rgb, 'rgb');
+ },
+
+ invert: function(){
+ return new Color(this.map(function(value){
+ return 255 - value;
+ }));
+ },
+
+ setHue: function(value){
+ return new Color([value, this.hsb[1], this.hsb[2]], 'hsb');
+ },
+
+ setSaturation: function(percent){
+ return new Color([this.hsb[0], percent, this.hsb[2]], 'hsb');
+ },
+
+ setBrightness: function(percent){
+ return new Color([this.hsb[0], this.hsb[1], percent], 'hsb');
+ }
+
+});
+
+var $RGB = function(r, g, b){
+ return new Color([r, g, b], 'rgb');
+};
+
+var $HSB = function(h, s, b){
+ return new Color([h, s, b], 'hsb');
+};
+
+var $HEX = function(hex){
+ return new Color(hex, 'hex');
+};
+
+Array.implement({
+
+ rgbToHsb: function(){
+ var red = this[0], green = this[1], blue = this[2];
+ var hue, saturation, brightness;
+ var max = Math.max(red, green, blue), min = Math.min(red, green, blue);
+ var delta = max - min;
+ brightness = max / 255;
+ saturation = (max != 0) ? delta / max : 0;
+ if (saturation == 0){
+ hue = 0;
+ } else {
+ var rr = (max - red) / delta;
+ var gr = (max - green) / delta;
+ var br = (max - blue) / delta;
+ if (red == max) hue = br - gr;
+ else if (green == max) hue = 2 + rr - br;
+ else hue = 4 + gr - rr;
+ hue /= 6;
+ if (hue < 0) hue++;
+ }
+ return [Math.round(hue * 360), Math.round(saturation * 100), Math.round(brightness * 100)];
+ },
+
+ hsbToRgb: function(){
+ var br = Math.round(this[2] / 100 * 255);
+ if (this[1] == 0){
+ return [br, br, br];
+ } else {
+ var hue = this[0] % 360;
+ var f = hue % 60;
+ var p = Math.round((this[2] * (100 - this[1])) / 10000 * 255);
+ var q = Math.round((this[2] * (6000 - this[1] * f)) / 600000 * 255);
+ var t = Math.round((this[2] * (6000 - this[1] * (60 - f))) / 600000 * 255);
+ switch (Math.floor(hue / 60)){
+ case 0: return [br, t, p];
+ case 1: return [q, br, p];
+ case 2: return [p, br, t];
+ case 3: return [p, q, br];
+ case 4: return [t, p, br];
+ case 5: return [br, p, q];
+ }
+ }
+ return false;
+ }
+
+});
+
+String.implement({
+
+ rgbToHsb: function(){
+ var rgb = this.match(/\d{1,3}/g);
+ return (rgb) ? rgb.rgbToHsb() : null;
+ },
+
+ hsbToRgb: function(){
+ var hsb = this.match(/\d{1,3}/g);
+ return (hsb) ? hsb.hsbToRgb() : null;
+ }
+
+});
+
+
+/*
+Script: Hash.Cookie.js
+ Class for creating, reading, and deleting Cookies in JSON format.
+
+ License:
+ MIT-style license.
+
+ Authors:
+ Valerio Proietti
+ Aaron Newton
+*/
+
+Hash.Cookie = new Class({
+
+ Extends: Cookie,
+
+ options: {
+ autoSave: true
+ },
+
+ initialize: function(name, options){
+ this.parent(name, options);
+ this.load();
+ },
+
+ save: function(){
+ var value = JSON.encode(this.hash);
+ if (!value || value.length > 4096) return false; //cookie would be truncated!
+ if (value == '{}') this.dispose();
+ else this.write(value);
+ return true;
+ },
+
+ load: function(){
+ this.hash = new Hash(JSON.decode(this.read(), true));
+ return this;
+ }
+
+});
+
+Hash.each(Hash.prototype, function(method, name){
+ if (typeof method == 'function') Hash.Cookie.implement(name, function(){
+ var value = method.apply(this.hash, arguments);
+ if (this.options.autoSave) this.save();
+ return value;
+ });
+});
+
+/*
+Script: Tips.js
+ Class for creating nice tips that follow the mouse cursor when hovering an element.
+
+ License:
+ MIT-style license.
+
+ Authors:
+ Valerio Proietti
+ Christoph Pojer
+*/
+
+var Tips = new Class({
+
+ Implements: [Events, Options],
+
+ options: {
+ onShow: function(tip){
+ tip.setStyle('visibility', 'visible');
+ },
+ onHide: function(tip){
+ tip.setStyle('visibility', 'hidden');
+ },
+ title: 'title',
+ text: function(el){
+ return el.get('rel') || el.get('href');
+ },
+ showDelay: 100,
+ hideDelay: 100,
+ className: null,
+ offset: {x: 16, y: 16},
+ fixed: false
+ },
+
+ initialize: function(){
+ var params = Array.link(arguments, {options: Object.type, elements: $defined});
+ if (params.options && params.options.offsets) params.options.offset = params.options.offsets;
+ this.setOptions(params.options);
+ this.container = new Element('div', {'class': 'tip'});
+ this.tip = this.getTip();
+
+ if (params.elements) this.attach(params.elements);
+ },
+
+ getTip: function(){
+ return new Element('div', {
+ 'class': this.options.className,
+ styles: {
+ visibility: 'hidden',
+ display: 'none',
+ position: 'absolute',
+ top: 0,
+ left: 0
+ }
+ }).adopt(
+ new Element('div', {'class': 'tip-top'}),
+ this.container,
+ new Element('div', {'class': 'tip-bottom'})
+ ).inject(document.body);
+ },
+
+ attach: function(elements){
+ var read = function(option, element){
+ if (option == null) return '';
+ return $type(option) == 'function' ? option(element) : element.get(option);
+ };
+ $$(elements).each(function(element){
+ var title = read(this.options.title, element);
+ element.erase('title').store('tip:native', title).retrieve('tip:title', title);
+ element.retrieve('tip:text', read(this.options.text, element));
+
+ var events = ['enter', 'leave'];
+ if (!this.options.fixed) events.push('move');
+
+ events.each(function(value){
+ element.addEvent('mouse' + value, element.retrieve('tip:' + value, this['element' + value.capitalize()].bindWithEvent(this, element)));
+ }, this);
+ }, this);
+
+ return this;
+ },
+
+ detach: function(elements){
+ $$(elements).each(function(element){
+ ['enter', 'leave', 'move'].each(function(value){
+ element.removeEvent('mouse' + value, element.retrieve('tip:' + value) || $empty);
+ });
+
+ element.eliminate('tip:enter').eliminate('tip:leave').eliminate('tip:move');
+
+ if ($type(this.options.title) == 'string' && this.options.title == 'title'){
+ var original = element.retrieve('tip:native');
+ if (original) element.set('title', original);
+ }
+ }, this);
+
+ return this;
+ },
+
+ elementEnter: function(event, element){
+ $A(this.container.childNodes).each(Element.dispose);
+
+ ['title', 'text'].each(function(value){
+ var content = element.retrieve('tip:' + value);
+ if (!content) return;
+
+ this[value + 'Element'] = new Element('div', {'class': 'tip-' + value}).inject(this.container);
+ this.fill(this[value + 'Element'], content);
+ }, this);
+
+ this.timer = $clear(this.timer);
+ this.timer = this.show.delay(this.options.showDelay, this, element);
+ this.tip.setStyle('display', 'block');
+ this.position((!this.options.fixed) ? event : {page: element.getPosition()});
+ },
+
+ elementLeave: function(event, element){
+ $clear(this.timer);
+ this.tip.setStyle('display', 'none');
+ this.timer = this.hide.delay(this.options.hideDelay, this, element);
+ },
+
+ elementMove: function(event){
+ this.position(event);
+ },
+
+ position: function(event){
+ var size = window.getSize(), scroll = window.getScroll(),
+ tip = {x: this.tip.offsetWidth, y: this.tip.offsetHeight},
+ props = {x: 'left', y: 'top'},
+ obj = {};
+
+ for (var z in props){
+ obj[props[z]] = event.page[z] + this.options.offset[z];
+ if ((obj[props[z]] + tip[z] - scroll[z]) > size[z]) obj[props[z]] = event.page[z] - this.options.offset[z] - tip[z];
+ }
+
+ this.tip.setStyles(obj);
+ },
+
+ fill: function(element, contents){
+ if(typeof contents == 'string') element.set('html', contents);
+ else element.adopt(contents);
+ },
+
+ show: function(el){
+ this.fireEvent('show', [this.tip, el]);
+ },
+
+ hide: function(el){
+ this.fireEvent('hide', [this.tip, el]);
+ }
+
+});
\ No newline at end of file
Modified: incubator/jspwiki/trunk/src/WebContent/scripts/stripes-support.js
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/src/WebContent/scripts/stripes-support.js?rev=819135&r1=819134&r2=819135&view=diff
==============================================================================
--- incubator/jspwiki/trunk/src/WebContent/scripts/stripes-support.js (original)
+++ incubator/jspwiki/trunk/src/WebContent/scripts/stripes-support.js Sat Sep 26 13:23:58 2009
@@ -1,4 +1,4 @@
-/*!
+/*!
JSPWiki - a JSP-based WikiWiki clone.
Licensed to the Apache Software Foundation (ASF) under one
@@ -16,7 +16,7 @@
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
- under the License.
+ under the License.
*/
/*
@@ -36,31 +36,34 @@
Based on http://mootools.net/ v1.11
* Core, Class, Native, Element(ex. Dimensions), Window,
* Effects(ex. Scroll), Drag(Base), Remote, Plugins(Hash.Cookie, Tips, Accordion)
-
+
*/
/*
Class: Stripes
The main javascript class to support basic jspwiki functions.
+
+ Fixme: update to mootool 1.2.3
*/
var Stripes = {
- executeEvent: function( form, event, divTarget ){
- params = event + "=&" + $(form).toQueryString();
- new Ajax(form.action, {
- postBody: params,
- method: 'post',
+ executeEvent: function( form, event, divTarget ){
+ params = event + "=&" + $(form).toQueryString();
+
+ new Request(form.action, {
+ postBody: params,
+ method: 'post',
onComplete: function(response){
- // Clear the results div
- $(divTarget).empty();
- // Build new results if we got a response
- if(response) var results = eval(response);
- if(results){
- var target = $(divTarget);
- results.each(function(result,i) {
- var p = new Element('p').setHTML(result).injectInside(divTarget);
- });
- }
- }
- }).request();
- }
+ // Clear the results div
+ $(divTarget).empty();
+ // Build new results if we got a response
+ if(response) var results = eval(response);
+ if(results){
+ var target = $(divTarget).addClass("warning");
+ results.each(function(result,i) {
+ var p = new Element('p').setHTML(result).injectInside(divTarget);
+ });
+ }
+ }
+ }).send();
+ }
}