Changeset 654 for mochikit/branches/scriptaculous/MochiKit

mochikit/branches/scriptaculous/MochiKit/DragAndDrop.js

r649	r654
172	172
173	173	__init__: function (element, /* optional */options) {
174		this.element = MochiKit.DOM.getElement(element);
175		this.options = MochiKit.Base.update({
	174	var d = MochiKit.DOM;
	175	var b = MochiKit.Base;
	176	this.element = d.getElement(element);
	177	this.options = b.update({
176	178	greedy: true,
177	179	hoverclass: null,
…	…
185	187	if ((typeof(containment) == 'object') &&
186	188	(containment.constructor == Array)) {
187		~~MochiKit.Base~~.map(MochiKit.Base.bind(function (c) {
188		this.options._containers.push(~~MochiKit.DOM~~.getElement(c));
	189	b.map(MochiKit.Base.bind(function (c) {
	190	this.options._containers.push(d.getElement(c));
189	191	}, this), containment);
190	192	} else {
191	193	this.options._containers.push(
192		~~MochiKit.DOM~~.getElement(containment));
193		}
194		}
195
196		~~MochiKit.DOM~~.makePositioned(this.element); // fix IE
	194	d.getElement(containment));
	195	}
	196	}
	197
	198	d.makePositioned(this.element); // fix IE
197	199
198	200	MochiKit.DragAndDrop.Droppables.register(this);
…	…
278	280	register: function (draggable) {
279	281	if (this.drags.length === 0) {
280		this.eventMouseUp = MochiKit.Base.bind(this.endDrag, this);
281		this.eventMouseMove = MochiKit.Base.bind(this.updateDrag, this);
282		this.eventKeypress = MochiKit.Base.bind(this.keyPress, this);
283		MochiKit.Signal.connect(document, 'onmouseup', this.eventMouseUp);
284		MochiKit.Signal.connect(document, 'onmousemove', this.eventMouseMove);
285		MochiKit.Signal.connect(document, 'onkeypress', this.eventKeypress);
	282	var bind = MochiKit.Base.bind;
	283	var conn = MochiKit.Signal.connect;
	284	this.eventMouseUp = bind(this.endDrag, this);
	285	this.eventMouseMove = bind(this.updateDrag, this);
	286	this.eventKeypress = bind(this.keyPress, this);
	287	conn(document, 'onmouseup', this.eventMouseUp);
	288	conn(document, 'onmousemove', this.eventMouseMove);
	289	conn(document, 'onkeypress', this.eventKeypress);
286	290	}
287	291	this.drags.push(draggable);
…	…
293	297	}, this.drags);
294	298	if (this.drags.length === 0) {
295		MochiKit.Signal.disconnect(document, 'onmouseup',
296		this.eventMouseUp);
297		MochiKit.Signal.disconnect(document, 'onmousemove',
298		this.eventMouseMove);
299		MochiKit.Signal.disconnect(document, 'onkeypress',
300		this.eventKeypress);
	299	var disc = MochiKit.Signal.disconnect
	300	disc(document, 'onmouseup', this.eventMouseUp);
	301	disc(document, 'onmousemove', this.eventMouseMove);
	302	disc(document, 'onkeypress', this.eventKeypress);
301	303	}
302	304	},
…	…
368	370
369	371	_cacheObserverCallbacks: function () {
370		MochiKit.Base.map(function (eventName) {
371		MochiKit.DragAndDrop.Draggables[eventName + 'Count'] =
372		MochiKit.Base.filter(function (o) {
	372	var b = MochiKit.Base;
	373	var self = MochiKit.DragAndDrop.Draggables;
	374	b.map(function (eventName) {
	375	self[eventName + 'Count'] =
	376	b.filter(function (o) {
373	377	return o[eventName];
374		}, ~~MochiKit.DragAndDrop.Draggables~~.observers).length;
	378	}, self.observers).length;
375	379	}, ['onStart', 'onEnd', 'onDrag']);
376	380	}
…	…
392	396
393	397	__init__: function (element, /* optional */options) {
	398	var v = MochiKit.Visual;
394	399	options = MochiKit.Base.update({
395	400	handle: false,
396	401	starteffect: function (element) {
397		new MochiKit.Visual.Opacity(element,
398		{duration:0.2, from:1.0, to:0.7});
	402	new v.Opacity(element, {duration:0.2, from:1.0, to:0.7});
399	403	},
400	404	reverteffect: function (element, top_offset, left_offset) {
401	405	var dur = Math.sqrt(Math.abs(top_offset^2) +
402	406	Math.abs(left_offset^2))*0.02;
403		element._revert = new ~~MochiKit.Visual~~.Move(element,
	407	element._revert = new v.Move(element,
404	408	{x: -left_offset, y: -top_offset, duration: dur});
405	409	},
406	410	endeffect: function (element) {
407		new ~~MochiKit.Visual~~.Opacity(element, {duration:0.2, from:0.7, to:1.0});
	411	new v.Opacity(element, {duration:0.2, from:0.7, to:1.0});
408	412	},
409	413	zindex: 1000,
…	…
416	420	}, options \|\| {});
417	421
418		this.element = MochiKit.DOM.getElement(element);
	422	var d = MochiKit.DOM;
	423	this.element = d.getElement(element);
419	424
420	425	if (options.handle && (typeof(options.handle) == 'string')) {
421		this.handle = ~~MochiKit.DOM~~.getFirstElementByTagAndClassName(null,
	426	this.handle = d.getFirstElementByTagAndClassName(null,
422	427	options.handle, this.element);
423	428	}
424	429	if (!this.handle) {
425		this.handle = ~~MochiKit.DOM~~.getElement(options.handle);
	430	this.handle = d.getElement(options.handle);
426	431	}
427	432	if (!this.handle) {
…	…
430	435
431	436	if (options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
432		options.scroll = ~~MochiKit.DOM~~.getElement(options.scroll);
433		}
434
435		~~MochiKit.DOM~~.makePositioned(this.element); // fix IE
	437	options.scroll = d.getElement(options.scroll);
	438	}
	439
	440	d.makePositioned(this.element); // fix IE
436	441
437	442	this.delta = this.currentDelta();
…	…
446	451	destroy: function () {
447	452	MochiKit.Signal.disconnect(this.handle, 'onmousedown',
448		this.eventMouseDown);
	453	this.eventMouseDown);
449	454	MochiKit.DragAndDrop.Draggables.unregister(this);
450	455	},
451	456
452	457	currentDelta: function () {
	458	var s = MochiKit.DOM.getStyle;
453	459	return [
454		parseInt(~~MochiKit.DOM.getStyle~~(this.element, 'left') \|\| '0'),
455		parseInt(~~MochiKit.DOM.getStyle~~(this.element, 'top') \|\| '0')];
	460	parseInt(s(this.element, 'left') \|\| '0'),
	461	parseInt(s(this.element, 'top') \|\| '0')];
456	462	},
457	463
…	…
572	578
573	579	finishDrag: function (event, success) {
	580	var dr = MochiKit.DragAndDrop;
574	581	this.dragging = false;
575	582	if (this.options.selectclass) {
…	…
590	597
591	598	if (success) {
592		~~MochiKit.DragAndDrop~~.Droppables.fire(event, this.element);
593		}
594		~~MochiKit.DragAndDrop~~.Draggables.notify('onEnd', this, event);
	599	dr.Droppables.fire(event, this.element);
	600	}
	601	dr.Draggables.notify('onEnd', this, event);
595	602
596	603	var revert = this.options.revert;
…	…
615	622	}
616	623
617		~~MochiKit.DragAndDrop~~.Draggables.deactivate();
618		~~MochiKit.DragAndDrop~~.Droppables.reset(this.element);
	624	dr.Draggables.deactivate();
	625	dr.Droppables.reset(this.element);
619	626	},
620	627
…	…
712	719	}
713	720
	721	var d = MochiKit.DragAndDrop;
	722
714	723	MochiKit.Position.prepare();
715		MochiKit.DragAndDrop.Droppables.show(MochiKit.DragAndDrop.Draggables._lastPointer, this.element);
716		//MochiKit.DragAndDrop.Draggables.notify('onDrag', this);
717		this.draw(MochiKit.DragAndDrop.Draggables._lastPointer);
	724	d.Droppables.show(d.Draggables._lastPointer, this.element);
	725	this.draw(d.Draggables._lastPointer);
718	726	if (this.options.change) {
719	727	this.options.change(this);

mochikit/branches/scriptaculous/MochiKit/Sortable.js

r648	r654
90	90
91	91	options: function (element){
	92	var i = MochiKit.Iter;
92	93	element = MochiKit.DOM.getElement(element);
93	94	var result;
94		~~MochiKit.Iter~~.forEach(this.sortables, function (s) {
	95	i.forEach(this.sortables, function (s) {
95	96	if (s.element == element) {
96	97	result = s;
97		throw ~~MochiKit.Iter~~.StopIteration;
	98	throw i.StopIteration;
98	99	}
99	100	});
…	…
102	103
103	104	destroy: function (element){
104		element = MochiKit.DOM.getElement(element);
105		var toDestroy = MochiKit.Base.filter(function (s) {
	105	var b = MochiKit.Base;
	106	var d = MochiKit.DragAndDrop;
	107	element = MochiKit.DOM.getElement(element);
	108	var toDestroy = b.filter(function (s) {
106	109	return s.element == element;
107	110	}, this.sortables);
108		~~MochiKit.Base~~.map(function (s) {
109		~~MochiKit.DragAndDrop~~.Draggables.removeObserver(s.element);
110		~~MochiKit.Base.map(function (d~~) {
111		~~MochiKit.DragAndDrop.Droppables.remove(d~~);
	111	b.map(function (s) {
	112	d.Draggables.removeObserver(s.element);
	113	b.map(function (dr) {
	114	d.Droppables.remove(dr);
112	115	}, s.droppables);
113		~~MochiKit.Base.map(function (d~~) {
114		d.destroy();
	116	b.map(function (dr) {
	117	dr.destroy();
115	118	}, s.draggables);
116	119	}, toDestroy);
117		this.sortables = ~~MochiKit.Base~~.filter(function (s) {
	120	this.sortables = b.filter(function (s) {
118	121	return s.element != element;
119	122	}, this.sortables);
…	…
279	282
280	283	onEmptyHover: function (element, dropon) {
	284	var o = MochiKit.Sortable.Sortable.options;
281	285	if (element.parentNode != dropon) {
282	286	var oldParentNode = element.parentNode;
283	287	dropon.appendChild(element);
284		~~MochiKit.Sortable.Sortable.options~~(oldParentNode).onChange(element);
285		~~MochiKit.Sortable.Sortable.options~~(dropon).onChange(element);
	288	o(oldParentNode).onChange(element);
	289	o(dropon).onChange(element);
286	290	}
287	291	},
288	292
289	293	unmark: function () {
290		if (MochiKit.Sortable.Sortable._marker) {
291		MochiKit.DOM.hideElement(MochiKit.Sortable.Sortable._marker);
	294	var m = MochiKit.Sortable.Sortable._marker;
	295	if (m) {
	296	MochiKit.DOM.hideElement(m);
292	297	}
293	298	},
…	…
295	300	mark: function (dropon, position) {
296	301	// mark on ghosting only
297		var sortable = MochiKit.Sortable.Sortable.options(dropon.parentNode);
	302	var s = MochiKit.Sortable.Sortable;
	303	var d = MochiKit.DOM;
	304	var sortable = s.options(dropon.parentNode);
298	305	if (sortable && !sortable.ghosting) {
299	306	return;
300	307	}
301	308
302		if (!MochiKit.Sortable.Sortable._marker) {
303		MochiKit.Sortable.Sortable._marker = MochiKit.DOM.getElement('dropmarker') \|\|
304		document.createElement('DIV');
305		MochiKit.DOM.hideElement(MochiKit.Sortable.Sortable._marker);
306		MochiKit.DOM.addElementClass(MochiKit.Sortable.Sortable._marker, 'dropmarker');
307		MochiKit.Sortable.Sortable._marker.style.position = 'absolute';
308		document.getElementsByTagName('body').item(0).appendChild(
309		MochiKit.Sortable.Sortable._marker);
	309	if (!s._marker) {
	310	s._marker = d.getElement('dropmarker') \|\|
	311	document.createElement('DIV');
	312	d.hideElement(s._marker);
	313	d.addElementClass(s._marker, 'dropmarker');
	314	s._marker.style.position = 'absolute';
	315	document.getElementsByTagName('body').item(0).appendChild(s._marker);
310	316	}
311	317	var offsets = MochiKit.Position.cumulativeOffset(dropon);
312		~~MochiKit.Sortable.Sortable~~._marker.style.left = offsets[0] + 'px';
313		~~MochiKit.Sortable.Sortable~~._marker.style.top = offsets[1] + 'px';
	318	s._marker.style.left = offsets[0] + 'px';
	319	s._marker.style.top = offsets[1] + 'px';
314	320
315	321	if (position == 'after') {
316	322	if (sortable.overlap == 'horizontal') {
317		MochiKit.Sortable.Sortable._marker.style.left = (offsets[0] +
318		dropon.clientWidth) + 'px';
	323	s._marker.style.left = (offsets[0] + dropon.clientWidth) + 'px';
319	324	} else {
320		MochiKit.Sortable.Sortable._marker.style.top = (offsets[1] +
321		dropon.clientHeight) + 'px';
322		}
323		}
324		MochiKit.DOM.showElement(MochiKit.Sortable.Sortable._marker);
	325	s._marker.style.top = (offsets[1] + dropon.clientHeight) + 'px';
	326	}
	327	}
	328	d.showElement(s._marker);
325	329	},
326	330
327	331	setSequence: function (element, newSequence) {
328		element = MochiKit.DOM.getElement(element);
329		var options = MochiKit.Base.update(arguments[2] \|\| {}, this.options(element));
	332	var b = MochiKit.Base;
	333	element = MochiKit.DOM.getElement(element);
	334	var options = b.update(arguments[2] \|\| {}, this.options(element));
330	335
331	336	var nodeMap = {};
332		~~MochiKit.Base~~.map(function (n) {
	337	b.map(function (n) {
333	338	var m = n.id.match(options.format);
334	339	if (m) {
…	…
338	343	}, this.findElements(element, options));
339	344
340		~~MochiKit.Base~~.map(function (ident) {
	345	b.map(function (ident) {
341	346	var n = nodeMap[ident];
342	347	if (n) {

mochikit/branches/scriptaculous/MochiKit/Visual.js

r648	r654
389	389	}
390	390	element = MochiKit.DOM.getElement(element);
391		MochiKit.Iter.forEach(element.childNodes, function (child) {
	391	var fe = MochiKit.Iter.forEach;
	392	fe(element.childNodes, function (child) {
392	393	if (child.nodeType == 3) {
393		~~MochiKit.Iter.forEach~~(child.nodeValue.split(''), function (character) {
	394	fe(child.nodeValue.split(''), function (character) {
394	395	element.insertBefore(
395	396	MochiKit.DOM.SPAN({style: tagifyStyle},
…	…
450	451	queue: {position: 'end', scope: (element.id \|\| 'global'), limit: 1}
451	452	}, options \|\| {});
452		MochiKit.Visual[MochiKit.DOM.isVisible(element) ?
453		MochiKit.Visual.PAIRS[effect][1] : MochiKit.Visual.PAIRS[effect][0]](element, options);
	453	var v = MochiKit.Visual;
	454	v[MochiKit.DOM.isVisible(element) ?
	455	v.PAIRS[effect][1] : v.PAIRS[effect][0]](element, options);
454	456	};
455	457
…	…
517	519	effect.options.queue : effect.options.queue.position;
518	520
	521	var fe = MochiKit.Iter.forEach;
519	522	switch(position) {
520	523	case 'front':
521	524	// move unstarted effects after this effect
522		~~MochiKit.Iter.forEach~~(this.effects, function (e) {
	525	fe(this.effects, function (e) {
523	526	if (e.state == 'idle') {
524	527	e.startOn += effect.finishOn;
…	…
530	533	var finish;
531	534	// start effect after last queued effect has finished
532		~~MochiKit.Iter.forEach~~(this.effects, function (e) {
	535	fe(this.effects, function (e) {
533	536	var i = e.finishOn;
534	537	if (i >= (finish \|\| i)) {
…	…
613	616
614	617	start: function (options) {
	618	var v = MochiKit.Visual;
615	619	this.options = MochiKit.Base.setdefault(options \|\| {},
616		~~MochiKit.Visual~~.DefaultOptions);
	620	v.DefaultOptions);
617	621	this.currentFrame = 0;
618	622	this.state = 'idle';
…	…
621	625	this.event('beforeStart');
622	626	if (!this.options.sync) {
623		~~MochiKit.Visual~~.Queues.get(typeof(this.options.queue) == 'string' ?
	627	v.Queues.get(typeof(this.options.queue) == 'string' ?
624	628	'global' : this.options.queue.scope).add(this);
625	629	}
…	…
749	753	***/
750	754	__init__: function (element, /* optional */options) {
751		this.element = MochiKit.DOM.getElement(element);
	755	var b = MochiKit.Base;
	756	var d = MochiKit.DOM;
	757	this.element = d.getElement(element);
752	758	// make this work on IE on elements without 'layout'
753		if (~~MochiKit.Base~~.isIE() && (!this.element.hasLayout)) {
754		~~MochiKit.DOM~~.setStyle(this.element, {zoom: 1});
755		}
756		options = ~~MochiKit.Base~~.update({
757		from: ~~MochiKit.DOM~~.getOpacity(this.element) \|\| 0.0,
	759	if (b.isIE() && (!this.element.hasLayout)) {
	760	d.setStyle(this.element, {zoom: 1});
	761	}
	762	options = b.update({
	763	from: d.getOpacity(this.element) \|\| 0.0,
758	764	to: 1.0
759	765	}, options \|\| {});
…	…
791	797
792	798	setup: function () {
	799	var d = MochiKit.DOM;
793	800	// Bug in Opera: Opera returns the 'real' position of a static element
794	801	// or relative element that does not have top/left explicitly set.
795	802	// ==> Always set top and left for position relative elements in your
796	803	// stylesheets (to 0 if you do not need them)
797		~~MochiKit.DOM~~.makePositioned(this.element);
	804	d.makePositioned(this.element);
798	805
799	806	var s = this.element.style;
…	…
805	812	}
806	813
807		this.originalLeft = parseFloat(MochiKit.DOM.getStyle(this.element,
808		'left') \|\| '0');
809		this.originalTop = parseFloat(MochiKit.DOM.getStyle(this.element,
810		'top') \|\| '0');
	814	this.originalLeft = parseFloat(d.getStyle(this.element, 'left') \|\| '0');
	815	this.originalTop = parseFloat(d.getStyle(this.element, 'top') \|\| '0');
811	816
812	817	if (this.options.mode == 'absolute') {
…	…
864	869	'position');
865	870
	871	var fe = MochiKit.Iter.forEach;
	872	var b = MochiKit.Base.bind;
866	873	this.originalStyle = {};
867		~~MochiKit.Iter.forEach~~(['top', 'left', 'width', 'height', 'fontSize'],
868		~~MochiKit.Base.bind~~(function (k) {
	874	fe(['top', 'left', 'width', 'height', 'fontSize'],
	875	b(function (k) {
869	876	this.originalStyle[k] = this.element.style[k];
870	877	}, this));
…	…
875	882	var fontSize = MochiKit.DOM.getStyle(this.element,
876	883	'font-size') \|\| '100%';
877		~~MochiKit.Iter.forEach~~(['em', 'px', '%'],
878		~~MochiKit.Base.bind~~(function (fontSizeType) {
	884	fe(['em', 'px', '%'],
	885	b(function (fontSizeType) {
879	886	if (fontSize.indexOf(fontSizeType) > 0) {
880	887	this.fontSize = parseFloat(fontSize);
…	…
971	978
972	979	setup: function () {
	980	var d = MochiKit.DOM;
	981	var b = MochiKit.Base;
973	982	// Prevent executing on elements not in the layout flow
974		if (~~MochiKit.DOM~~.getStyle(this.element, 'display') == 'none') {
	983	if (d.getStyle(this.element, 'display') == 'none') {
975	984	this.cancel();
976	985	return;
…	…
978	987	// Disable background image during the effect
979	988	this.oldStyle = {
980		backgroundImage: MochiKit.DOM.getStyle(this.element,
981		'background-image')
	989	backgroundImage: d.getStyle(this.element, 'background-image')
982	990	};
983		~~MochiKit.DOM~~.setStyle(this.element, {
	991	d.setStyle(this.element, {
984	992	backgroundImage: 'none'
985	993	});
…	…
990	998	}
991	999	if(!this.options.restorecolor) {
992		this.options.restorecolor = MochiKit.DOM.getStyle(this.element,
993		'background-color');
	1000	this.options.restorecolor = d.getStyle(this.element, 'background-color');
994	1001	}
995	1002	// init color calculations
996		this._base = ~~MochiKit.Base.map(MochiKit.Base~~.bind(function (i) {
	1003	this._base = b.map(b.bind(function (i) {
997	1004	return parseInt(
998	1005	this.options.startcolor.slice(i2 + 1, i2 + 3), 16);
999	1006	}, this), [0, 1, 2]);
1000		this._delta = ~~MochiKit.Base.map(MochiKit.Base~~.bind(function (i) {
	1007	this._delta = b.map(b.bind(function (i) {
1001	1008	return parseInt(this.options.endcolor.slice(i2 + 1, i2 + 3), 16)
1002	1009	- this._base[i];
…	…
1041	1048
1042	1049	setup: function () {
1043		MochiKit.Position.prepare();
1044		var offsets = MochiKit.Position.cumulativeOffset(this.element);
	1050	var p = MochiKit.Position;
	1051	p.prepare();
	1052	var offsets = p.cumulativeOffset(this.element);
1045	1053	if (this.options.offset) {
1046	1054	offsets[1] += this.options.offset;
…	…
1056	1064	max = document.body.clientHeight - document.body.scrollHeight;
1057	1065	}
1058		this.scrollStart = ~~MochiKit.Position~~.deltaY;
	1066	this.scrollStart = p.deltaY;
1059	1067	this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
1060	1068	},
1061	1069
1062	1070	update: function (position) {
1063		~~MochiKit.Position.prepare()~~;
1064		~~window.scrollTo(MochiKit.Position.deltaX,~~
1065		this.scrollStart + (position*this.delta));
	1071	var p = MochiKit.Position;
	1072	p.prepare();
	1073	window.scrollTo(p.deltaX, this.scrollStart + (position * this.delta));
1066	1074	}
1067	1075	});
…	…
1081	1089
1082	1090	***/
1083		var oldOpacity = MochiKit.DOM.getInlineOpacity(element);
	1091	var d = MochiKit.DOM;
	1092	var oldOpacity = d.getInlineOpacity(element);
1084	1093	options = MochiKit.Base.update({
1085		from: ~~MochiKit.DOM~~.getOpacity(element) \|\| 1.0,
	1094	from: d.getOpacity(element) \|\| 1.0,
1086	1095	to: 0.0,
1087	1096	afterFinishInternal: function (effect) {
…	…
1089	1098	return;
1090	1099	}
1091		~~MochiKit.DOM~~.hideElement(effect.element);
1092		~~MochiKit.DOM~~.setStyle(effect.element, {opacity: oldOpacity});
	1100	d.hideElement(effect.element);
	1101	d.setStyle(effect.element, {opacity: oldOpacity});
1093	1102	}
1094	1103	}, options \|\| {});
…	…
1104	1113
1105	1114	***/
	1115	var d = MochiKit.DOM;
	1116	var v = MochiKit.Visual;
1106	1117	options = MochiKit.Base.update({
1107		from: (~~MochiKit.DOM~~.getStyle(element, 'display') == 'none' ? 0.0 :
1108		~~MochiKit.DOM~~.getOpacity(element) \|\| 0.0),
	1118	from: (d.getStyle(element, 'display') == 'none' ? 0.0 :
	1119	d.getOpacity(element) \|\| 0.0),
1109	1120	to: 1.0,
1110	1121	// force Safari to render floated elements properly
1111	1122	afterFinishInternal: function(effect) {
1112		~~MochiKit.Visual~~.forceRerendering(effect.element);
	1123	v.forceRerendering(effect.element);
1113	1124	},
1114	1125	beforeSetup: function (effect) {
1115		~~MochiKit.DOM~~.setOpacity(effect.element, effect.options.from);
1116		~~MochiKit.DOM~~.showElement(effect.element);
	1126	d.setOpacity(effect.element, effect.options.from);
	1127	d.showElement(effect.element);
1117	1128	}
1118	1129	}, options \|\| {});
1119		return new ~~MochiKit.Visual~~.Opacity(element, options);
	1130	return new v.Opacity(element, options);
1120	1131	};
1121	1132
…	…
1126	1137
1127	1138	***/
1128		element = MochiKit.DOM.getElement(element);
	1139	var d = MochiKit.DOM;
	1140	var v = MochiKit.Visual;
	1141	element = d.getElement(element);
1129	1142	var oldStyle = {
1130		opacity: ~~MochiKit.DOM~~.getInlineOpacity(element),
1131		position: ~~MochiKit.DOM~~.getStyle(element, 'position')
	1143	opacity: d.getInlineOpacity(element),
	1144	position: d.getStyle(element, 'position')
1132	1145	};
1133	1146	options = MochiKit.Base.update({
1134	1147	beforeSetupInternal: function (effect) {
1135		~~MochiKit.DOM~~.setStyle(effect.effects[0].element,
	1148	d.setStyle(effect.effects[0].element,
1136	1149	{position: 'absolute'});
1137	1150	},
1138	1151	afterFinishInternal: function (effect) {
1139		~~MochiKit.DOM~~.hideElement(effect.effects[0].element);
1140		~~MochiKit.DOM~~.setStyle(effect.effects[0].element, oldStyle);
	1152	d.hideElement(effect.effects[0].element);
	1153	d.setStyle(effect.effects[0].element, oldStyle);
1141	1154	}
1142	1155	}, options \|\| {});
1143		return new ~~MochiKit.Visual~~.Parallel(
1144		[new ~~MochiKit.Visual~~.Scale(element, 200,
	1156	return new v.Parallel(
	1157	[new v.Scale(element, 200,
1145	1158	{sync: true, scaleFromCenter: true,
1146	1159	scaleContent: true, restoreAfterFinish: true}),
1147		new MochiKit.Visual.Opacity(element, {sync: true, to: 0.0 })],
1148		options
1149		);
	1160	new v.Opacity(element, {sync: true, to: 0.0 })],
	1161	options);
1150	1162	};
1151	1163
…	…
1156	1168
1157	1169	***/
1158		element = MochiKit.DOM.getElement(element);
1159		MochiKit.DOM.makeClipping(element);
	1170	var d = MochiKit.DOM;
	1171	element = d.getElement(element);
	1172	d.makeClipping(element);
1160	1173	options = MochiKit.Base.update({
1161	1174	scaleContent: false,
…	…
1163	1176	restoreAfterFinish: true,
1164	1177	afterFinishInternal: function (effect) {
1165		~~MochiKit.DOM~~.hideElement(effect.element);
1166		~~MochiKit.DOM~~.undoClipping(effect.element);
	1178	d.hideElement(effect.element);
	1179	d.undoClipping(effect.element);
1167	1180	}
1168	1181	}, options \|\| {});
…	…
1177	1190
1178	1191	***/
1179		element = MochiKit.DOM.getElement(element);
1180		var elementDimensions = MochiKit.DOM.elementDimensions(element);
	1192	var d = MochiKit.DOM;
	1193	element = d.getElement(element);
	1194	var elementDimensions = d.elementDimensions(element);
1181	1195	options = MochiKit.Base.update({
1182	1196	scaleContent: false,
…	…
1187	1201	restoreAfterFinish: true,
1188	1202	afterSetup: function (effect) {
1189		~~MochiKit.DOM~~.makeClipping(effect.element);
1190		~~MochiKit.DOM~~.setStyle(effect.element, {height: '0px'});
1191		~~MochiKit.DOM~~.showElement(effect.element);
	1203	d.makeClipping(effect.element);
	1204	d.setStyle(effect.element, {height: '0px'});
	1205	d.showElement(effect.element);
1192	1206	},
1193	1207	afterFinishInternal: function (effect) {
1194		~~MochiKit.DOM~~.undoClipping(effect.element);
	1208	d.undoClipping(effect.element);
1195	1209	}
1196	1210	}, options \|\| {});
…	…
1204	1218
1205	1219	***/
1206		element = MochiKit.DOM.getElement(element);
1207		var oldOpacity = MochiKit.DOM.getInlineOpacity(element);
	1220	var d = MochiKit.DOM;
	1221	element = d.getElement(element);
	1222	var oldOpacity = d.getInlineOpacity(element);
1208	1223	var optionsScale = {
1209	1224	duration: 0.3,
…	…
1213	1228	restoreAfterFinish: true,
1214	1229	beforeSetup: function (effect) {
1215		~~MochiKit.DOM~~.makePositioned(effect.element);
1216		~~MochiKit.DOM~~.makeClipping(effect.element);
	1230	d.makePositioned(effect.element);
	1231	d.makeClipping(effect.element);
1217	1232	},
1218	1233	afterFinishInternal: function (effect) {
1219		~~MochiKit.DOM~~.hideElement(effect.element);
1220		~~MochiKit.DOM~~.undoClipping(effect.element);
1221		~~MochiKit.DOM~~.undoPositioned(effect.element);
1222		~~MochiKit.DOM~~.setStyle(effect.element, {opacity: oldOpacity});
	1234	d.hideElement(effect.element);
	1235	d.undoClipping(effect.element);
	1236	d.undoPositioned(effect.element);
	1237	d.setStyle(effect.element, {opacity: oldOpacity});
1223	1238	}
1224	1239	};
1225		return new MochiKit.Visual.appear(element, {
	1240	var v = MochiKit.Visual;
	1241	return new v.appear(element, {
1226	1242	duration: 0.4,
1227	1243	from: 0,
1228		transition: ~~MochiKit.Visual~~.Transitions.flicker,
	1244	transition: v.Transitions.flicker,
1229	1245	afterFinishInternal: function (effect) {
1230		new ~~MochiKit.Visual~~.Scale(effect.element, 1, optionsScale)
	1246	new v.Scale(effect.element, 1, optionsScale)
1231	1247	}
1232	1248	});
…	…
1239	1255
1240	1256	***/
1241		element = MochiKit.DOM.getElement(element);
	1257	var d = MochiKit.DOM;
	1258	element = d.getElement(element);
1242	1259	var oldStyle = {
1243		top: ~~MochiKit.DOM~~.getStyle(element, 'top'),
1244		left: ~~MochiKit.DOM~~.getStyle(element, 'left'),
1245		opacity: ~~MochiKit.DOM~~.getInlineOpacity(element)
	1260	top: d.getStyle(element, 'top'),
	1261	left: d.getStyle(element, 'left'),
	1262	opacity: d.getInlineOpacity(element)
1246	1263	};
1247	1264
…	…
1249	1266	duration: 0.5,
1250	1267	beforeSetup: function (effect) {
1251		~~MochiKit.DOM~~.makePositioned(effect.effects[0].element);
	1268	d.makePositioned(effect.effects[0].element);
1252	1269	},
1253	1270	afterFinishInternal: function (effect) {
1254		~~MochiKit.DOM~~.hideElement(effect.effects[0].element);
1255		~~MochiKit.DOM~~.undoPositioned(effect.effects[0].element);
1256		~~MochiKit.DOM~~.setStyle(effect.effects[0].element, oldStyle);
	1271	d.hideElement(effect.effects[0].element);
	1272	d.undoPositioned(effect.effects[0].element);
	1273	d.setStyle(effect.effects[0].element, oldStyle);
1257	1274	}
1258	1275	}, options \|\| {});
1259		return new MochiKit.Visual.Parallel(
1260		[new MochiKit.Visual.Move(element, {x: 0, y: 100, sync: true}),
1261		new MochiKit.Visual.Opacity(element, {sync: true, to: 0.0})],
	1276	var v = MochiKit.Visual;
	1277	return new v.Parallel(
	1278	[new v.Move(element, {x: 0, y: 100, sync: true}),
	1279	new v.Opacity(element, {sync: true, to: 0.0})],
1262	1280	options);
1263	1281	};
…	…
1269	1287
1270	1288	***/
1271		element = MochiKit.DOM.getElement(element);
	1289	var d = MochiKit.DOM;
	1290	var v = MochiKit.Visual;
	1291	element = d.getElement(element);
1272	1292	var oldStyle = {
1273		top: ~~MochiKit.DOM~~.getStyle(element, 'top'),
1274		left: ~~MochiKit.DOM~~.getStyle(element, 'left') };
1275		return new ~~MochiKit.Visual~~.Move(element,
	1293	top: d.getStyle(element, 'top'),
	1294	left: d.getStyle(element, 'left') };
	1295	return new v.Move(element,
1276	1296	{x: 20, y: 0, duration: 0.05, afterFinishInternal: function (effect) {
1277		new ~~MochiKit.Visual~~.Move(effect.element,
	1297	new v.Move(effect.element,
1278	1298	{x: -40, y: 0, duration: 0.1, afterFinishInternal: function (effect) {
1279		new ~~MochiKit.Visual~~.Move(effect.element,
	1299	new v.Move(effect.element,
1280	1300	{x: 40, y: 0, duration: 0.1, afterFinishInternal: function (effect) {
1281		new ~~MochiKit.Visual~~.Move(effect.element,
	1301	new v.Move(effect.element,
1282	1302	{x: -40, y: 0, duration: 0.1, afterFinishInternal: function (effect) {
1283		new ~~MochiKit.Visual~~.Move(effect.element,
	1303	new v.Move(effect.element,
1284	1304	{x: 40, y: 0, duration: 0.1, afterFinishInternal: function (effect) {
1285		new ~~MochiKit.Visual~~.Move(effect.element,
	1305	new v.Move(effect.element,
1286	1306	{x: -20, y: 0, duration: 0.05, afterFinishInternal: function (effect) {
1287		~~MochiKit.DOM~~.undoPositioned(effect.element);
1288		~~MochiKit.DOM~~.setStyle(effect.element, oldStyle);
	1307	d.undoPositioned(effect.element);
	1308	d.setStyle(effect.element, oldStyle);
1289	1309	}}) }}) }}) }}) }}) }});
1290	1310	};
…	…
1298	1318
1299	1319	***/
1300		element = MochiKit.DOM.getElement(element);
1301		MochiKit.DOM.cleanWhitespace(element);
1302		var oldInnerBottom = MochiKit.DOM.getStyle(element.firstChild, 'bottom') \|\| 0;
1303		var elementDimensions = MochiKit.DOM.elementDimensions(element);
1304		options = MochiKit.Base.update({
	1320	var d = MochiKit.DOM;
	1321	var b = MochiKit.Base;
	1322	element = d.getElement(element);
	1323	d.cleanWhitespace(element);
	1324	var oldInnerBottom = d.getStyle(element.firstChild, 'bottom') \|\| 0;
	1325	var elementDimensions = d.elementDimensions(element);
	1326	options = b.update({
1305	1327	scaleContent: false,
1306	1328	scaleX: false,
…	…
1310	1332	restoreAfterFinish: true,
1311	1333	afterSetup: function (effect) {
1312		~~MochiKit.DOM~~.makePositioned(effect.element);
1313		~~MochiKit.DOM~~.makePositioned(effect.element.firstChild);
1314		if (~~MochiKit.Base~~.isOpera()) {
1315		~~MochiKit.DOM~~.setStyle(effect.element, {top: ''});
	1334	d.makePositioned(effect.element);
	1335	d.makePositioned(effect.element.firstChild);
	1336	if (b.isOpera()) {
	1337	d.setStyle(effect.element, {top: ''});
1316	1338	}
1317		~~MochiKit.DOM~~.makeClipping(effect.element);
1318		~~MochiKit.DOM~~.setStyle(effect.element, {height: '0px'});
1319		~~MochiKit.DOM~~.showElement(element);
	1339	d.makeClipping(effect.element);
	1340	d.setStyle(effect.element, {height: '0px'});
	1341	d.showElement(element);
1320	1342	},
1321	1343	afterUpdateInternal: function (effect) {
1322		~~MochiKit.DOM~~.setStyle(effect.element.firstChild,
	1344	d.setStyle(effect.element.firstChild,
1323	1345	{bottom: (effect.dims[0] - effect.element.clientHeight) + 'px'})
1324	1346	},
1325	1347	afterFinishInternal: function (effect) {
1326		~~MochiKit.DOM~~.undoClipping(effect.element);
	1348	d.undoClipping(effect.element);
1327	1349	// IE will crash if child is undoPositioned first
1328		if (~~MochiKit.Base~~.isIE()){
1329		~~MochiKit.DOM~~.undoPositioned(effect.element);
1330		~~MochiKit.DOM~~.undoPositioned(effect.element.firstChild);
	1350	if (b.isIE()){
	1351	d.undoPositioned(effect.element);
	1352	d.undoPositioned(effect.element.firstChild);
1331	1353	} else {
1332		~~MochiKit.DOM~~.undoPositioned(effect.element.firstChild);
1333		~~MochiKit.DOM~~.undoPositioned(effect.element);
	1354	d.undoPositioned(effect.element.firstChild);
	1355	d.undoPositioned(effect.element);
1334	1356	}
1335		~~MochiKit.DOM~~.setStyle(effect.element.firstChild,
	1357	d.setStyle(effect.element.firstChild,
1336	1358	{bottom: oldInnerBottom});
1337	1359	}
…	…
1349	1371
1350	1372	***/
1351		element = MochiKit.DOM.getElement(element);
1352		MochiKit.DOM.cleanWhitespace(element);
1353		var oldInnerBottom = MochiKit.DOM.getStyle(element.firstChild, 'bottom');
1354		options = MochiKit.Base.update({
	1373	var d = MochiKit.DOM;
	1374	var b = MochiKit.Base;
	1375	element = d.getElement(element);
	1376	d.cleanWhitespace(element);
	1377	var oldInnerBottom = d.getStyle(element.firstChild, 'bottom');
	1378	options = b.update({
1355	1379	scaleContent: false,
1356	1380	scaleX: false,
…	…
1359	1383	restoreAfterFinish: true,
1360	1384	beforeStartInternal: function (effect) {
1361		~~MochiKit.DOM~~.makePositioned(effect.element);
1362		~~MochiKit.DOM~~.makePositioned(effect.element.firstChild);
1363		if (~~MochiKit.Base~~.isOpera()) {
1364		~~MochiKit.DOM~~.setStyle(effect.element, {top: ''});
	1385	d.makePositioned(effect.element);
	1386	d.makePositioned(effect.element.firstChild);
	1387	if (b.isOpera()) {
	1388	d.setStyle(effect.element, {top: ''});
1365	1389	}
1366		~~MochiKit.DOM~~.makeClipping(effect.element);
1367		~~MochiKit.DOM~~.showElement(element);
	1390	d.makeClipping(effect.element);
	1391	d.showElement(element);
1368	1392	},
1369	1393	afterUpdateInternal: function (effect) {
1370		~~MochiKit.DOM~~.setStyle(effect.element.firstChild,
	1394	d.setStyle(effect.element.firstChild,
1371	1395	{bottom: (effect.dims[0] - effect.element.clientHeight) + 'px'});
1372	1396	},
1373	1397	&

Navigation

Legend:

mochikit/branches/scriptaculous/MochiKit/DragAndDrop.js

mochikit/branches/scriptaculous/MochiKit/Sortable.js

mochikit/branches/scriptaculous/MochiKit/Visual.js