You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jackrabbit.apache.org by ed...@apache.org on 2006/11/11 17:44:48 UTC
svn commit: r473755 [21/43] - in /jackrabbit/trunk/contrib/jcr-browser: ./
src/ src/main/ src/main/java/ src/main/java/org/ src/main/java/org/apache/
src/main/java/org/apache/jackrabbit/
src/main/java/org/apache/jackrabbit/browser/ src/main/resources/ ...
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/common.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/common.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/common.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/common.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,220 @@
+dojo.provide("dojo.lang.common");
+
+dojo.lang.inherits = function(/*Function*/ subclass, /*Function*/ superclass){
+ // summary: Set up inheritance between two classes.
+ if(typeof superclass != 'function'){
+ dojo.raise("dojo.inherits: superclass argument ["+superclass+"] must be a function (subclass: ["+subclass+"']");
+ }
+ subclass.prototype = new superclass();
+ subclass.prototype.constructor = subclass;
+ subclass.superclass = superclass.prototype;
+ // DEPRECATED: super is a reserved word, use 'superclass'
+ subclass['super'] = superclass.prototype;
+}
+
+dojo.lang._mixin = function(/*Object*/ obj, /*Object*/ props){
+ // summary: Adds all properties and methods of props to obj.
+ var tobj = {};
+ for(var x in props){
+ // the "tobj" condition avoid copying properties in "props"
+ // inherited from Object.prototype. For example, if obj has a custom
+ // toString() method, don't overwrite it with the toString() method
+ // that props inherited from Object.protoype
+ if((typeof tobj[x] == "undefined") || (tobj[x] != props[x])){
+ obj[x] = props[x];
+ }
+ }
+ // IE doesn't recognize custom toStrings in for..in
+ if(dojo.render.html.ie
+ && (typeof(props["toString"]) == "function")
+ && (props["toString"] != obj["toString"])
+ && (props["toString"] != tobj["toString"]))
+ {
+ obj.toString = props.toString;
+ }
+ return obj; // Object
+}
+
+dojo.lang.mixin = function(/*Object*/ obj, /*Object...*/props){
+ // summary: Adds all properties and methods of props to obj.
+ for(var i=1, l=arguments.length; i<l; i++){
+ dojo.lang._mixin(obj, arguments[i]);
+ }
+ return obj; // Object
+}
+
+dojo.lang.extend = function(/*Object*/ constructor, /*Object...*/ props){
+ // summary: Adds all properties and methods of props to constructor's prototype,
+ // making them available to all instances created with constructor.
+ for(var i=1, l=arguments.length; i<l; i++){
+ dojo.lang._mixin(constructor.prototype, arguments[i]);
+ }
+ return constructor; // Object
+}
+
+// Promote to dojo module
+dojo.inherits = dojo.lang.inherits;
+//dojo.lang._mixin = dojo.lang._mixin;
+dojo.mixin = dojo.lang.mixin;
+dojo.extend = dojo.lang.extend;
+
+dojo.lang.find = function( /*Array*/ array,
+ /*Object*/ value,
+ /*Boolean?*/ identity,
+ /*Boolean?*/ findLast){
+ // summary: Return the index of value in array, returning -1 if not found.
+ // identity: If true, matches with identity comparison (===).
+ // If false, uses normal comparison (==).
+ // findLast: If true, returns index of last instance of value.
+
+ // examples:
+ // find(array, value[, identity [findLast]]) // recommended
+ // find(value, array[, identity [findLast]]) // deprecated
+
+ // support both (array, value) and (value, array)
+ if(!dojo.lang.isArrayLike(array) && dojo.lang.isArrayLike(value)) {
+ dojo.deprecated('dojo.lang.find(value, array)', 'use dojo.lang.find(array, value) instead', "0.5");
+ var temp = array;
+ array = value;
+ value = temp;
+ }
+ var isString = dojo.lang.isString(array);
+ if(isString) { array = array.split(""); }
+
+ if(findLast) {
+ var step = -1;
+ var i = array.length - 1;
+ var end = -1;
+ } else {
+ var step = 1;
+ var i = 0;
+ var end = array.length;
+ }
+ if(identity){
+ while(i != end) {
+ if(array[i] === value){ return i; }
+ i += step;
+ }
+ }else{
+ while(i != end) {
+ if(array[i] == value){ return i; }
+ i += step;
+ }
+ }
+ return -1; // number
+}
+
+dojo.lang.indexOf = dojo.lang.find;
+
+dojo.lang.findLast = function(/*Array*/ array, /*Object*/ value, /*boolean?*/ identity){
+ // summary: Return index of last occurance of value in array, returning -1 if not found.
+ // identity: If true, matches with identity comparison (===). If false, uses normal comparison (==).
+ return dojo.lang.find(array, value, identity, true); // number
+}
+
+dojo.lang.lastIndexOf = dojo.lang.findLast;
+
+dojo.lang.inArray = function(array /*Array*/, value /*Object*/){
+ // summary: Return true if value is present in array.
+ return dojo.lang.find(array, value) > -1; // boolean
+}
+
+/**
+ * Partial implmentation of is* functions from
+ * http://www.crockford.com/javascript/recommend.html
+ * NOTE: some of these may not be the best thing to use in all situations
+ * as they aren't part of core JS and therefore can't work in every case.
+ * See WARNING messages inline for tips.
+ *
+ * The following is* functions are fairly "safe"
+ */
+
+dojo.lang.isObject = function(/*anything*/ it){
+ // summary: Return true if it is an Object, Array or Function.
+ if(typeof it == "undefined"){ return false; }
+ return (typeof it == "object" || it === null || dojo.lang.isArray(it) || dojo.lang.isFunction(it)); // Boolean
+}
+
+dojo.lang.isArray = function(/*anything*/ it){
+ // summary: Return true if it is an Array.
+ return (it && it instanceof Array || typeof it == "array"); // Boolean
+}
+
+dojo.lang.isArrayLike = function(/*anything*/ it){
+ // summary: Return true if it can be used as an array (i.e. is an object with an integer length property).
+ if((!it)||(dojo.lang.isUndefined(it))){ return false; }
+ if(dojo.lang.isString(it)){ return false; }
+ if(dojo.lang.isFunction(it)){ return false; } // keeps out built-in constructors (Number, String, ...) which have length properties
+ if(dojo.lang.isArray(it)){ return true; }
+ // form node itself is ArrayLike, but not always iterable. Use form.elements instead.
+ if((it.tagName)&&(it.tagName.toLowerCase()=='form')){ return false; }
+ if(dojo.lang.isNumber(it.length) && isFinite(it.length)){ return true; }
+ return false; // Boolean
+}
+
+dojo.lang.isFunction = function(/*anything*/ it){
+ // summary: Return true if it is a Function.
+ if(!it){ return false; }
+ // webkit treats NodeList as a function, which is bad
+ if((typeof(it) == "function") && (it == "[object NodeList]")) { return false; }
+ return (it instanceof Function || typeof it == "function"); // Boolean
+}
+
+dojo.lang.isString = function(/*anything*/ it){
+ // summary: Return true if it is a String.
+ return (typeof it == "string" || it instanceof String);
+}
+
+dojo.lang.isAlien = function(/*anything*/ it){
+ // summary: Return true if it is not a built-in function.
+ if(!it){ return false; }
+ return !dojo.lang.isFunction() && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
+}
+
+dojo.lang.isBoolean = function(/*anything*/ it){
+ // summary: Return true if it is a Boolean.
+ return (it instanceof Boolean || typeof it == "boolean"); // Boolean
+}
+
+/**
+ * The following is***() functions are somewhat "unsafe". Fortunately,
+ * there are workarounds the the language provides and are mentioned
+ * in the WARNING messages.
+ *
+ */
+dojo.lang.isNumber = function(/*anything*/ it){
+ // summary: Return true if it is a number.
+ // description:
+ // WARNING - In most cases, isNaN(it) is sufficient to determine whether or not
+ // something is a number or can be used as such. For example, a number or string
+ // can be used interchangably when accessing array items (array["1"] is the same as
+ // array[1]) and isNaN will return false for both values ("1" and 1). However,
+ // isNumber("1") will return false, which is generally not too useful.
+ // Also, isNumber(NaN) returns true, again, this isn't generally useful, but there
+ // are corner cases (like when you want to make sure that two things are really
+ // the same type of thing). That is really where isNumber "shines".
+ //
+ // Recommendation - Use isNaN(it) when possible
+
+ return (it instanceof Number || typeof it == "number"); // Boolean
+}
+
+/*
+ * FIXME: Should isUndefined go away since it is error prone?
+ */
+dojo.lang.isUndefined = function(/*anything*/ it){
+ // summary: Return true if it is not defined.
+ // description:
+ // WARNING - In some cases, isUndefined will not behave as you
+ // might expect. If you do isUndefined(foo) and there is no earlier
+ // reference to foo, an error will be thrown before isUndefined is
+ // called. It behaves correctly if you scope yor object first, i.e.
+ // isUndefined(foo.bar) where foo is an object and bar isn't a
+ // property of the object.
+ //
+ // Recommendation - Use typeof foo == "undefined" when possible
+
+ return ((typeof(it) == "undefined")&&(it == undefined)); // Boolean
+}
+
+// end Crockford functions
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/common.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/declare.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/declare.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/declare.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/declare.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,151 @@
+dojo.provide("dojo.lang.declare");
+
+dojo.require("dojo.lang.common");
+dojo.require("dojo.lang.extras");
+
+dojo.lang.declare = function(/*String*/ className, /*Function|Array*/ superclass, /*Function?*/ init, /*Object|Array*/ props){
+/*
+ * summary: Create a feature-rich constructor with a compact notation
+ *
+ * className: the name of the constructor (loosely, a "class")
+ *
+ * superclass: may be a Function, or an Array of Functions.
+ * If "superclass" is an array, the first element is used
+ * as the prototypical ancestor and any following Functions
+ * become mixin ancestors.
+ *
+ * init: an initializer function
+ *
+ * props: an object (or array of objects) whose properties are copied to the created prototype
+ *
+ * description: Create a constructor using a compact notation for inheritance and prototype extension.
+ *
+ * "superclass" argument may be a Function, or an array of
+ * Functions.
+ *
+ * If "superclass" is an array, the first element is used
+ * as the prototypical ancestor and any following Functions
+ * become mixin ancestors.
+ *
+ * All "superclass(es)" must be Functions (not mere Objects).
+ *
+ * Using mixin ancestors provides a type of multiple
+ * inheritance. Mixin ancestors prototypical
+ * properties are copied to the subclass, and any
+ * inializater/constructor is invoked.
+ *
+ * Properties of object "props" are copied to the constructor
+ * prototype. If "props" is an array, properties of each
+ * object in the array are copied to the constructor prototype.
+ *
+ * name of the class ("className" argument) is stored in
+ * "declaredClass" property
+ *
+ * Initializer functions are called when an object
+ * is instantiated from this constructor.
+ *
+ * Aliased as "dojo.declare"
+ *
+ * Usage:
+ *
+ * dojo.declare("my.classes.bar", my.classes.foo,
+ * function() {
+ * // initialization function
+ * this.myComplicatedObject = new ReallyComplicatedObject();
+ * },{
+ * someValue: 2,
+ * someMethod: function() {
+ * doStuff();
+ * }
+ * });
+ *
+ */
+ if((dojo.lang.isFunction(props))||((!props)&&(!dojo.lang.isFunction(init)))){
+ // parameter juggling to support omitting init param (also allows reordering init and props arguments)
+ var temp = props;
+ props = init;
+ init = temp;
+ }
+ var mixins = [ ];
+ if(dojo.lang.isArray(superclass)){
+ mixins = superclass;
+ superclass = mixins.shift();
+ }
+ if(!init){
+ init = dojo.evalObjPath(className, false);
+ if((init)&&(!dojo.lang.isFunction(init))){ init = null };
+ }
+ var ctor = dojo.lang.declare._makeConstructor();
+ var scp = (superclass ? superclass.prototype : null);
+ if(scp){
+ scp.prototyping = true;
+ ctor.prototype = new superclass();
+ scp.prototyping = false;
+ }
+ ctor.superclass = scp;
+ ctor.mixins = mixins;
+ for(var i=0,l=mixins.length; i<l; i++){
+ dojo.lang.extend(ctor, mixins[i].prototype);
+ }
+ ctor.prototype.initializer = null;
+ ctor.prototype.declaredClass = className;
+ if(dojo.lang.isArray(props)){
+ dojo.lang.extend.apply(dojo.lang, [ctor].concat(props));
+ }else{
+ dojo.lang.extend(ctor, (props)||{});
+ }
+ dojo.lang.extend(ctor, dojo.lang.declare._common);
+ ctor.prototype.constructor = ctor;
+ ctor.prototype.initializer = (ctor.prototype.initializer)||(init)||(function(){});
+ dojo.lang.setObjPathValue(className, ctor, null, true);
+ return ctor; // Function
+}
+
+dojo.lang.declare._makeConstructor = function() {
+ return function(){
+ // get the generational context (which object [or prototype] should be constructed)
+ var self = this._getPropContext();
+ var s = self.constructor.superclass;
+ if((s)&&(s.constructor)){
+ if(s.constructor==arguments.callee){
+ // if this constructor is invoked directly (my.ancestor.call(this))
+ this._inherited("constructor", arguments);
+ }else{
+ this._contextMethod(s, "constructor", arguments);
+ }
+ }
+ var ms = (self.constructor.mixins)||([]);
+ for(var i=0, m; (m=ms[i]); i++) {
+ (((m.prototype)&&(m.prototype.initializer))||(m)).apply(this, arguments);
+ }
+ if((!this.prototyping)&&(self.initializer)){
+ self.initializer.apply(this, arguments);
+ }
+ }
+}
+
+dojo.lang.declare._common = {
+ _getPropContext: function() { return (this.___proto||this); },
+ // caches ptype context and calls method on it
+ _contextMethod: function(ptype, method, args){
+ var result, stack = this.___proto;
+ this.___proto = ptype;
+ try { result = ptype[method].apply(this,(args||[])); }
+ catch(e) { throw e; }
+ finally { this.___proto = stack; }
+ return result;
+ },
+ _inherited: function(prop, args){
+ // summary
+ // Searches backward thru prototype chain to find nearest ancestral instance of prop.
+ // Internal use only.
+ var p = this._getPropContext();
+ do{
+ if((!p.constructor)||(!p.constructor.superclass)){return;}
+ p = p.constructor.superclass;
+ }while(!(prop in p));
+ return (dojo.lang.isFunction(p[prop]) ? this._contextMethod(p, prop, args) : p[prop]);
+ }
+}
+
+dojo.declare = dojo.lang.declare;
\ No newline at end of file
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/declare.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/extras.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/extras.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/extras.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/extras.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,120 @@
+dojo.provide("dojo.lang.extras");
+
+dojo.require("dojo.lang.common");
+
+dojo.lang.setTimeout = function(/*Function*/func, /*int*/delay /*, ...*/){
+ // summary:
+ // Sets a timeout in milliseconds to execute a function in a given context
+ // with optional arguments.
+ //
+ // usage:
+ // setTimeout (Object context, function func, number delay[, arg1[, ...]]);
+ // setTimeout (function func, number delay[, arg1[, ...]]);
+
+ var context = window, argsStart = 2;
+ if(!dojo.lang.isFunction(func)){
+ context = func;
+ func = delay;
+ delay = arguments[2];
+ argsStart++;
+ }
+
+ if(dojo.lang.isString(func)){
+ func = context[func];
+ }
+
+ var args = [];
+ for (var i = argsStart; i < arguments.length; i++){
+ args.push(arguments[i]);
+ }
+ return dojo.global().setTimeout(function () { func.apply(context, args); }, delay); // int
+}
+
+dojo.lang.clearTimeout = function(/*int*/timer){
+ // summary: clears timer by number from the execution queue
+ dojo.global().clearTimeout(timer);
+}
+
+dojo.lang.getNameInObj = function(/*Object*/ns, /*unknown*/item){
+ // summary: looks for a value in the object ns with a value matching item and returns the property name
+ // ns: if null, dj_global is used
+ // item: value to match
+ if(!ns){ ns = dj_global; }
+
+ for(var x in ns){
+ if(ns[x] === item){
+ return new String(x); // String
+ }
+ }
+ return null; // null
+}
+
+dojo.lang.shallowCopy = function(/*Object*/obj, /*Boolean?*/deep){
+ // summary: copies object obj one level deep, or full depth if deep is true
+ var i, ret;
+
+ if(obj === null){ /*obj: null*/ return null; } // null
+
+ if(dojo.lang.isObject(obj)){
+ // obj: Object
+ ret = new obj.constructor();
+ for(i in obj){
+ if(dojo.lang.isUndefined(ret[i])){
+ ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i];
+ }
+ }
+ } else if(dojo.lang.isArray(obj)){
+ // obj: Array
+ ret = [];
+ for(i=0; i<obj.length; i++){
+ ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i];
+ }
+ } else {
+ // obj: unknown
+ ret = obj;
+ }
+
+ return ret; // unknown
+}
+
+dojo.lang.firstValued = function(/* ... */){
+ // summary: Return the first argument that isn't undefined
+
+ for(var i = 0; i < arguments.length; i++){
+ if(typeof arguments[i] != "undefined"){
+ return arguments[i]; // unknown
+ }
+ }
+ return undefined; // undefined
+}
+
+dojo.lang.getObjPathValue = function(/*String*/objpath, /*Object?*/context, /*Boolean?*/create){
+ // summary:
+ // Gets a value from a reference specified as a string descriptor,
+ // (e.g. "A.B") in the given context.
+ //
+ // context: if not specified, dj_global is used
+ // create: if true, undefined objects in the path are created.
+
+ with(dojo.parseObjPath(objpath, context, create)){
+ return dojo.evalProp(prop, obj, create); // unknown
+ }
+}
+
+dojo.lang.setObjPathValue = function(/*String*/objpath, /*unknown*/value, /*Object?*/context, /*Boolean?*/create){
+ // summary:
+ // Sets a value on a reference specified as a string descriptor.
+ // (e.g. "A.B") in the given context.
+ //
+ // context: if not specified, dj_global is used
+ // create: if true, undefined objects in the path are created.
+
+ if(arguments.length < 4){
+ create = true;
+ }
+ with(dojo.parseObjPath(objpath, context, create)){
+ if(obj && (create || (prop in obj))){
+ obj[prop] = value;
+ }
+ }
+}
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/extras.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/func.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/func.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/func.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/func.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,138 @@
+dojo.provide("dojo.lang.func");
+
+dojo.require("dojo.lang.common");
+
+/**
+ * Runs a function in a given scope (thisObject), can
+ * also be used to preserve scope.
+ *
+ * hitch(foo, "bar"); // runs foo.bar() in the scope of foo
+ * hitch(foo, myFunction); // runs myFunction in the scope of foo
+ */
+dojo.lang.hitch = function(thisObject, method){
+ var fcn = (dojo.lang.isString(method) ? thisObject[method] : method) || function(){};
+
+ return function() {
+ return fcn.apply(thisObject, arguments);
+ };
+}
+
+dojo.lang.anonCtr = 0;
+dojo.lang.anon = {};
+dojo.lang.nameAnonFunc = function(anonFuncPtr, namespaceObj, searchForNames){
+ var nso = (namespaceObj || dojo.lang.anon);
+ if( (searchForNames) ||
+ ((dj_global["djConfig"])&&(djConfig["slowAnonFuncLookups"] == true)) ){
+ for(var x in nso){
+ try{
+ if(nso[x] === anonFuncPtr){
+ return x;
+ }
+ }catch(e){} // window.external fails in IE embedded in Eclipse (Eclipse bug #151165)
+ }
+ }
+ var ret = "__"+dojo.lang.anonCtr++;
+ while(typeof nso[ret] != "undefined"){
+ ret = "__"+dojo.lang.anonCtr++;
+ }
+ nso[ret] = anonFuncPtr;
+ return ret;
+}
+
+dojo.lang.forward = function(funcName){
+ // Returns a function that forwards a method call to this.func(...)
+ return function(){
+ return this[funcName].apply(this, arguments);
+ };
+}
+
+dojo.lang.curry = function(ns, func /* args ... */){
+ var outerArgs = [];
+ ns = ns||dj_global;
+ if(dojo.lang.isString(func)){
+ func = ns[func];
+ }
+ for(var x=2; x<arguments.length; x++){
+ outerArgs.push(arguments[x]);
+ }
+ // since the event system replaces the original function with a new
+ // join-point runner with an arity of 0, we check to see if it's left us
+ // any clues about the original arity in lieu of the function's actual
+ // length property
+ var ecount = (func["__preJoinArity"]||func.length) - outerArgs.length;
+ // borrowed from svend tofte
+ function gather(nextArgs, innerArgs, expected){
+ var texpected = expected;
+ var totalArgs = innerArgs.slice(0); // copy
+ for(var x=0; x<nextArgs.length; x++){
+ totalArgs.push(nextArgs[x]);
+ }
+ // check the list of provided nextArgs to see if it, plus the
+ // number of innerArgs already supplied, meets the total
+ // expected.
+ expected = expected-nextArgs.length;
+ if(expected<=0){
+ var res = func.apply(ns, totalArgs);
+ expected = texpected;
+ return res;
+ }else{
+ return function(){
+ return gather(arguments,// check to see if we've been run
+ // with enough args
+ totalArgs, // a copy
+ expected); // how many more do we need to run?;
+ };
+ }
+ }
+ return gather([], outerArgs, ecount);
+}
+
+dojo.lang.curryArguments = function(ns, func, args, offset){
+ var targs = [];
+ var x = offset||0;
+ for(x=offset; x<args.length; x++){
+ targs.push(args[x]); // ensure that it's an arr
+ }
+ return dojo.lang.curry.apply(dojo.lang, [ns, func].concat(targs));
+}
+
+dojo.lang.tryThese = function(){
+ for(var x=0; x<arguments.length; x++){
+ try{
+ if(typeof arguments[x] == "function"){
+ var ret = (arguments[x]());
+ if(ret){
+ return ret;
+ }
+ }
+ }catch(e){
+ dojo.debug(e);
+ }
+ }
+}
+
+dojo.lang.delayThese = function(farr, cb, delay, onend){
+ /**
+ * alternate: (array funcArray, function callback, function onend)
+ * alternate: (array funcArray, function callback)
+ * alternate: (array funcArray)
+ */
+ if(!farr.length){
+ if(typeof onend == "function"){
+ onend();
+ }
+ return;
+ }
+ if((typeof delay == "undefined")&&(typeof cb == "number")){
+ delay = cb;
+ cb = function(){};
+ }else if(!cb){
+ cb = function(){};
+ if(!delay){ delay = 0; }
+ }
+ setTimeout(function(){
+ (farr.shift())();
+ cb();
+ dojo.lang.delayThese(farr, cb, delay, onend);
+ }, delay);
+}
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/func.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/repr.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/repr.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/repr.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/repr.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,75 @@
+dojo.provide("dojo.lang.repr");
+
+dojo.require("dojo.lang.common");
+dojo.require("dojo.AdapterRegistry");
+dojo.require("dojo.string.extras");
+
+dojo.lang.reprRegistry = new dojo.AdapterRegistry();
+dojo.lang.registerRepr = function(/*String*/name, /*Function*/check, /*Function*/wrap, /*Boolean?*/override){
+ // summary:
+ // Register a repr function. repr functions should take
+ // one argument and return a string representation of it
+ // suitable for developers, primarily used when debugging.
+ //
+ // If override is given, it is used as the highest priority
+ // repr, otherwise it will be used as the lowest.
+
+ dojo.lang.reprRegistry.register(name, check, wrap, override);
+};
+
+dojo.lang.repr = function(/*Object*/obj){
+ // summary: Return a "programmer representation" for an object
+ // description: returns a string representation of an object suitable for developers, primarily used when debugging
+
+ if(typeof(obj) == "undefined"){
+ // obj: undefined
+ return "undefined"; // String
+ }else if(obj === null){
+ // obj: null
+ return "null"; // String
+ }
+
+ try{
+ if(typeof(obj["__repr__"]) == 'function'){
+ return obj["__repr__"]();
+ }else if((typeof(obj["repr"]) == 'function')&&(obj.repr != arguments.callee)){
+ return obj["repr"]();
+ }
+ return dojo.lang.reprRegistry.match(obj);
+ }catch(e){
+ if(typeof(obj.NAME) == 'string' && (
+ obj.toString == Function.prototype.toString ||
+ obj.toString == Object.prototype.toString
+ )){
+ return obj.NAME; // String
+ }
+ }
+
+ if(typeof(obj) == "function"){
+ // obj: Function
+ obj = (obj + "").replace(/^\s+/, "");
+ var idx = obj.indexOf("{");
+ if(idx != -1){
+ obj = obj.substr(0, idx) + "{...}";
+ }
+ }
+ return obj + ""; // String
+}
+
+dojo.lang.reprArrayLike = function(/*Array*/arr){
+ // summary: Maps each element of arr to dojo.lang.repr and provides output in an array-like format
+ // description: returns an array-like string representation of the provided array suitable for developers, primarily used when debugging
+ try{
+ var na = dojo.lang.map(arr, dojo.lang.repr);
+ return "[" + na.join(", ") + "]"; // String
+ }catch(e){ }
+};
+
+(function(){
+ var m = dojo.lang;
+ m.registerRepr("arrayLike", m.isArrayLike, m.reprArrayLike);
+ m.registerRepr("string", m.isString, m.reprString);
+ m.registerRepr("numbers", m.isNumber, m.reprNumber);
+ m.registerRepr("boolean", m.isBoolean, m.reprNumber);
+ // m.registerRepr("numbers", m.typeMatcher("number", "boolean"), m.reprNumber);
+})();
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/repr.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Streamer.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Streamer.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Streamer.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Streamer.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,89 @@
+dojo.provide("dojo.lang.timing.Streamer");
+dojo.require("dojo.lang.timing.Timer");
+
+dojo.lang.timing.Streamer = function(
+ /* function */input,
+ /* function */output,
+ /* int */interval,
+ /* int */minimum,
+ /* array */initialData
+){
+ // summary
+ // Streamer will take an input function that pushes N datapoints into a
+ // queue, and will pass the next point in that queue out to an
+ // output function at the passed interval; this way you can emulate
+ // a constant buffered stream of data.
+ // input: the function executed when the internal queue reaches minimumSize
+ // output: the function executed on internal tick
+ // interval: the interval in ms at which the output function is fired.
+ // minimum: the minimum number of elements in the internal queue.
+
+ var self = this;
+ var queue = [];
+
+ // public properties
+ this.interval = interval || 1000;
+ this.minimumSize = minimum || 10; // latency usually == interval * minimumSize
+ this.inputFunction = input || function(q){ };
+ this.outputFunction = output || function(point){ };
+
+ // more setup
+ var timer = new dojo.lang.timing.Timer(this.interval);
+ var tick = function(){
+ self.onTick(self);
+
+ if(queue.length < self.minimumSize){
+ self.inputFunction(queue);
+ }
+
+ var obj = queue.shift();
+ while(typeof(obj) == "undefined" && queue.length > 0){
+ obj = queue.shift();
+ }
+
+ // check to see if the input function needs to be fired
+ // stop before firing the output function
+ // TODO: relegate this to the output function?
+ if(typeof(obj) == "undefined"){
+ self.stop();
+ return;
+ }
+
+ // call the output function.
+ self.outputFunction(obj);
+ };
+
+ this.setInterval = function(/* int */ms){
+ // summary
+ // sets the interval in milliseconds of the internal timer
+ this.interval = ms;
+ timer.setInterval(ms);
+ };
+
+ this.onTick = function(/* dojo.lang.timing.Streamer */obj){ };
+ // wrap the timer functions so that we can connect to them if needed.
+ this.start = function(){
+ // summary
+ // starts the Streamer
+ if(typeof(this.inputFunction) == "function" && typeof(this.outputFunction) == "function"){
+ timer.start();
+ return;
+ }
+ dojo.raise("You cannot start a Streamer without an input and an output function.");
+ };
+ this.onStart = function(){ };
+ this.stop = function(){
+ // summary
+ // stops the Streamer
+ timer.stop();
+ };
+ this.onStop = function(){ };
+
+ // finish initialization
+ timer.onTick = this.tick;
+ timer.onStart = this.onStart;
+ timer.onStop = this.onStop;
+ if(initialData){
+ queue.concat(initialData);
+ }
+};
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Streamer.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Timer.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Timer.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Timer.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Timer.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,54 @@
+dojo.provide("dojo.lang.timing.Timer");
+dojo.require("dojo.lang.func");
+
+dojo.lang.timing.Timer = function(/*int*/ interval){
+ // summary: Timer object executes an "onTick()" method repeatedly at a specified interval.
+ // repeatedly at a given interval.
+ // interval: Interval between function calls, in milliseconds.
+ this.timer = null;
+ this.isRunning = false;
+ this.interval = interval;
+
+ this.onStart = null;
+ this.onStop = null;
+};
+
+dojo.extend(dojo.lang.timing.Timer, {
+ onTick : function(){
+ // summary: Method called every time the interval passes. Override to do something useful.
+ },
+
+ setInterval : function(interval){
+ // summary: Reset the interval of a timer, whether running or not.
+ // interval: New interval, in milliseconds.
+ if (this.isRunning){
+ dj_global.clearInterval(this.timer);
+ }
+ this.interval = interval;
+ if (this.isRunning){
+ this.timer = dj_global.setInterval(dojo.lang.hitch(this, "onTick"), this.interval);
+ }
+ },
+
+ start : function(){
+ // summary: Start the timer ticking.
+ // description: Calls the "onStart()" handler, if defined.
+ // Note that the onTick() function is not called right away,
+ // only after first interval passes.
+ if (typeof this.onStart == "function"){
+ this.onStart();
+ }
+ this.isRunning = true;
+ this.timer = dj_global.setInterval(dojo.lang.hitch(this, "onTick"), this.interval);
+ },
+
+ stop : function(){
+ // summary: Stop the timer.
+ // description: Calls the "onStop()" handler, if defined.
+ if (typeof this.onStop == "function"){
+ this.onStop();
+ }
+ this.isRunning = false;
+ dj_global.clearInterval(this.timer);
+ }
+});
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/Timer.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/__package__.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/__package__.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/__package__.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/__package__.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1 @@
+dojo.provide("dojo.lang.timing.*");
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/timing/__package__.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/type.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/type.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/type.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/type.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,241 @@
+dojo.provide("dojo.lang.type");
+dojo.require("dojo.lang.common");
+
+dojo.lang.whatAmI = function(value) {
+ dojo.deprecated("dojo.lang.whatAmI", "use dojo.lang.getType instead", "0.5");
+ return dojo.lang.getType(value);
+}
+dojo.lang.whatAmI.custom = {};
+
+dojo.lang.getType = function(/* anything */ value){
+ /* summary:
+ * Attempts to determine what type value is.
+ * value: Any literal value or object instance.
+ */
+ try {
+ if(dojo.lang.isArray(value)) {
+ return "array"; // string
+ }
+ if(dojo.lang.isFunction(value)) {
+ return "function"; // string
+ }
+ if(dojo.lang.isString(value)) {
+ return "string"; // string
+ }
+ if(dojo.lang.isNumber(value)) {
+ return "number"; // string
+ }
+ if(dojo.lang.isBoolean(value)) {
+ return "boolean"; // string
+ }
+ if(dojo.lang.isAlien(value)) {
+ return "alien"; // string
+ }
+ if(dojo.lang.isUndefined(value)) {
+ return "undefined"; // string
+ }
+ // FIXME: should this go first?
+ for(var name in dojo.lang.whatAmI.custom) {
+ if(dojo.lang.whatAmI.custom[name](value)) {
+ return name; // string
+ }
+ }
+ if(dojo.lang.isObject(value)) {
+ return "object"; // string
+ }
+ } catch(e) {}
+ return "unknown"; // string
+}
+
+dojo.lang.isNumeric = function(/* anything */ value){
+ /* summary:
+ * Returns true if value can be interpreted as a number
+ * value: Any literal value or object instance.
+ */
+
+ /* examples:
+ * dojo.lang.isNumeric(3); // returns true
+ * dojo.lang.isNumeric("3"); // returns true
+ * dojo.lang.isNumeric(new Number(3)); // returns true
+ * dojo.lang.isNumeric(new String("3")); // returns true
+ *
+ * dojo.lang.isNumeric(3/0); // returns false
+ * dojo.lang.isNumeric("foo"); // returns false
+ * dojo.lang.isNumeric(new Number("foo")); // returns false
+ * dojo.lang.isNumeric(false); // returns false
+ * dojo.lang.isNumeric(true); // returns false
+ */
+ return (!isNaN(value)
+ && isFinite(value)
+ && (value != null)
+ && !dojo.lang.isBoolean(value)
+ && !dojo.lang.isArray(value)
+ && !/^\s*$/.test(value)
+ ); // boolean
+}
+
+dojo.lang.isBuiltIn = function(/* anything */ value){
+ /* summary:
+ * Returns true if value is of a type provided by core JavaScript
+ * description:
+ * Returns true for any literal, and for any object that is an
+ * instance of a built-in type like String, Number, Boolean,
+ * Array, Function, or Error.
+ * value: Any literal value or object instance.
+ */
+ return (dojo.lang.isArray(value)
+ || dojo.lang.isFunction(value)
+ || dojo.lang.isString(value)
+ || dojo.lang.isNumber(value)
+ || dojo.lang.isBoolean(value)
+ || (value == null)
+ || (value instanceof Error)
+ || (typeof value == "error")
+ ); // boolean
+}
+
+dojo.lang.isPureObject = function(/* anything */ value){
+ /* summary:
+ * Returns true for any value where the value of value.constructor == Object
+ * description:
+ * Returns true for any literal, and for any object that is an
+ * instance of a built-in type like String, Number, Boolean,
+ * Array, Function, or Error.
+ * value: Any literal value or object instance.
+ */
+
+ /* examples:
+ * dojo.lang.isPureObject(new Object()); // returns true
+ * dojo.lang.isPureObject({a: 1, b: 2}); // returns true
+ *
+ * dojo.lang.isPureObject(new Date()); // returns false
+ * dojo.lang.isPureObject([11, 2, 3]); // returns false
+ */
+ return ((value != null)
+ && dojo.lang.isObject(value)
+ && value.constructor == Object
+ ); // boolean
+}
+
+dojo.lang.isOfType = function(/* anything */ value, /* function */ type, /* object? */ keywordParameters) {
+ /* summary:
+ * Returns true if 'value' is of type 'type'
+ * description:
+ * Given a value and a datatype, this method returns true if the
+ * type of the value matches the datatype. The datatype parameter
+ * can be an array of datatypes, in which case the method returns
+ * true if the type of the value matches any of the datatypes.
+ * value: Any literal value or object instance.
+ * type: A class of object, or a literal type, or the string name of a type, or an array with a list of types.
+ * keywordParameters: {optional: boolean}
+ */
+
+ /* examples:
+ * dojo.lang.isOfType("foo", String); // returns true
+ * dojo.lang.isOfType(12345, Number); // returns true
+ * dojo.lang.isOfType(false, Boolean); // returns true
+ * dojo.lang.isOfType([6, 8], Array); // returns true
+ * dojo.lang.isOfType(dojo.lang.isOfType, Function); // returns true
+ * dojo.lang.isOfType({foo: "bar"}, Object); // returns true
+ * dojo.lang.isOfType(new Date(), Date); // returns true
+ *
+ * dojo.lang.isOfType("foo", "string"); // returns true
+ * dojo.lang.isOfType(12345, "number"); // returns true
+ * dojo.lang.isOfType(false, "boolean"); // returns true
+ * dojo.lang.isOfType([6, 8], "array"); // returns true
+ * dojo.lang.isOfType(dojo.lang.isOfType, "function"); // returns true
+ * dojo.lang.isOfType({foo: "bar"}, "object"); // returns true
+ * dojo.lang.isOfType(xxxxx, "undefined"); // returns true
+ * dojo.lang.isOfType(null, "null"); // returns true
+ *
+ * dojo.lang.isOfType("foo", [Number, String, Boolean]); // returns true
+ * dojo.lang.isOfType(12345, [Number, String, Boolean]); // returns true
+ * dojo.lang.isOfType(false, [Number, String, Boolean]); // returns true
+ *
+ * dojo.lang.isOfType(null, Date, {optional: true} ); // returns true // description:
+ */
+ var optional = false;
+ if (keywordParameters) {
+ optional = keywordParameters["optional"];
+ }
+ if (optional && ((value === null) || dojo.lang.isUndefined(value))) {
+ return true; // boolean
+ }
+ if(dojo.lang.isArray(type)){
+ var arrayOfTypes = type;
+ for(var i in arrayOfTypes){
+ var aType = arrayOfTypes[i];
+ if(dojo.lang.isOfType(value, aType)) {
+ return true; // boolean
+ }
+ }
+ return false; // boolean
+ }else{
+ if(dojo.lang.isString(type)){
+ type = type.toLowerCase();
+ }
+ switch (type) {
+ case Array:
+ case "array":
+ return dojo.lang.isArray(value); // boolean
+ case Function:
+ case "function":
+ return dojo.lang.isFunction(value); // boolean
+ case String:
+ case "string":
+ return dojo.lang.isString(value); // boolean
+ case Number:
+ case "number":
+ return dojo.lang.isNumber(value); // boolean
+ case "numeric":
+ return dojo.lang.isNumeric(value); // boolean
+ case Boolean:
+ case "boolean":
+ return dojo.lang.isBoolean(value); // boolean
+ case Object:
+ case "object":
+ return dojo.lang.isObject(value); // boolean
+ case "pureobject":
+ return dojo.lang.isPureObject(value); // boolean
+ case "builtin":
+ return dojo.lang.isBuiltIn(value); // boolean
+ case "alien":
+ return dojo.lang.isAlien(value); // boolean
+ case "undefined":
+ return dojo.lang.isUndefined(value); // boolean
+ case null:
+ case "null":
+ return (value === null); // boolean
+ case "optional":
+ dojo.deprecated('dojo.lang.isOfType(value, [type, "optional"])', 'use dojo.lang.isOfType(value, type, {optional: true} ) instead', "0.5");
+ return ((value === null) || dojo.lang.isUndefined(value)); // boolean
+ default:
+ if (dojo.lang.isFunction(type)) {
+ return (value instanceof type); // boolean
+ } else {
+ dojo.raise("dojo.lang.isOfType() was passed an invalid type");
+ }
+ }
+ }
+ dojo.raise("If we get here, it means a bug was introduced above.");
+}
+
+dojo.lang.getObject=function(/* String */ str){
+ // summary:
+ // Will return an object, if it exists, based on the name in the passed string.
+ var parts=str.split("."), i=0, obj=dj_global;
+ do{
+ obj=obj[parts[i++]];
+ }while(i<parts.length&&obj);
+ return (obj!=dj_global)?obj:null; // Object
+}
+
+dojo.lang.doesObjectExist=function(/* String */ str){
+ // summary:
+ // Check to see if object [str] exists, based on the passed string.
+ var parts=str.split("."), i=0, obj=dj_global;
+ do{
+ obj=obj[parts[i++]];
+ }while(i<parts.length&&obj);
+ return (obj&&obj!=dj_global); // boolean
+}
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lang/type.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/Animation.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/Animation.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/Animation.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/Animation.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,565 @@
+dojo.provide("dojo.lfx.Animation");
+
+dojo.require("dojo.lang.func");
+
+/*
+ Animation package based on Dan Pupius' work: http://pupius.co.uk/js/Toolkit.Drawing.js
+*/
+dojo.lfx.Line = function(/*int*/ start, /*int*/ end){
+ // summary: dojo.lfx.Line is the object used to generate values
+ // from a start value to an end value
+ this.start = start;
+ this.end = end;
+ if(dojo.lang.isArray(start)){
+ /* start: Array
+ end: Array
+ pId: a */
+ var diff = [];
+ dojo.lang.forEach(this.start, function(s,i){
+ diff[i] = this.end[i] - s;
+ }, this);
+
+ this.getValue = function(/*float*/ n){
+ var res = [];
+ dojo.lang.forEach(this.start, function(s, i){
+ res[i] = (diff[i] * n) + s;
+ }, this);
+ return res; // Array
+ }
+ }else{
+ var diff = end - start;
+
+ this.getValue = function(/*float*/ n){
+ // summary: returns the point on the line
+ // n: a floating point number greater than 0 and less than 1
+ return (diff * n) + this.start; // Decimal
+ }
+ }
+}
+
+dojo.lfx.easeDefault = function(/*Decimal?*/ n){
+ // summary: Returns the point for point n on a sin wave.
+ if(dojo.render.html.khtml){
+ // the cool kids are obviously not using konqueror...
+ // found a very wierd bug in floats constants, 1.5 evals as 1
+ // seems somebody mixed up ints and floats in 3.5.4 ??
+ // FIXME: investigate more and post a KDE bug (Fredrik)
+ return (parseFloat("0.5")+((Math.sin( (n+parseFloat("1.5")) * Math.PI))/2));
+ }else{
+ return (0.5+((Math.sin( (n+1.5) * Math.PI))/2));
+ }
+}
+
+dojo.lfx.easeIn = function(/*Decimal?*/ n){
+ // summary: returns the point on an easing curve
+ // n: a floating point number greater than 0 and less than 1
+ return Math.pow(n, 3);
+}
+
+dojo.lfx.easeOut = function(/*Decimal?*/ n){
+ // summary: returns the point on the line
+ // n: a floating point number greater than 0 and less than 1
+ return ( 1 - Math.pow(1 - n, 3) );
+}
+
+dojo.lfx.easeInOut = function(/*Decimal?*/ n){
+ // summary: returns the point on the line
+ // n: a floating point number greater than 0 and less than 1
+ return ( (3 * Math.pow(n, 2)) - (2 * Math.pow(n, 3)) );
+}
+
+dojo.lfx.IAnimation = function(){
+ // summary: dojo.lfx.IAnimation is an interface that implements
+ // commonly used functions of animation objects
+}
+dojo.lang.extend(dojo.lfx.IAnimation, {
+ // public properties
+ curve: null,
+ duration: 1000,
+ easing: null,
+ repeatCount: 0,
+ rate: 25,
+
+ // events
+ handler: null,
+ beforeBegin: null,
+ onBegin: null,
+ onAnimate: null,
+ onEnd: null,
+ onPlay: null,
+ onPause: null,
+ onStop: null,
+
+ // public methods
+ play: null,
+ pause: null,
+ stop: null,
+
+ connect: function(/*Event*/ evt, /*Object*/ scope, /*Function*/ newFunc){
+ // summary: Convenience function. Quickly connect to an event
+ // of this object and save the old functions connected to it.
+ // evt: The name of the event to connect to.
+ // scope: the scope in which to run newFunc.
+ // newFunc: the function to run when evt is fired.
+ if(!newFunc){
+ /* scope: Function
+ newFunc: null
+ pId: f */
+ newFunc = scope;
+ scope = this;
+ }
+ newFunc = dojo.lang.hitch(scope, newFunc);
+ var oldFunc = this[evt]||function(){};
+ this[evt] = function(){
+ var ret = oldFunc.apply(this, arguments);
+ newFunc.apply(this, arguments);
+ return ret;
+ }
+ return this; // dojo.lfx.IAnimation
+ },
+
+ fire: function(/*Event*/ evt, /*Array*/ args){
+ // summary: Convenience function. Fire event "evt" and pass it
+ // the arguments specified in "args".
+ // evt: The event to fire.
+ // args: The arguments to pass to the event.
+ if(this[evt]){
+ this[evt].apply(this, (args||[]));
+ }
+ return this; // dojo.lfx.IAnimation
+ },
+
+ repeat: function(/*int*/ count){
+ // summary: Set the repeat count of this object.
+ // count: How many times to repeat the animation.
+ this.repeatCount = count;
+ return this; // dojo.lfx.IAnimation
+ },
+
+ // private properties
+ _active: false,
+ _paused: false
+});
+
+dojo.lfx.Animation = function( /*Object*/ handlers,
+ /*int*/ duration,
+ /*dojo.lfx.Line*/ curve,
+ /*function*/ easing,
+ /*int*/ repeatCount,
+ /*int*/ rate){
+ // summary
+ // a generic animation object that fires callbacks into it's handlers
+ // object at various states
+ // handlers: { handler: Function?, onstart: Function?, onstop: Function?, onanimate: Function? }
+ dojo.lfx.IAnimation.call(this);
+ if(dojo.lang.isNumber(handlers)||(!handlers && duration.getValue)){
+ // no handlers argument:
+ rate = repeatCount;
+ repeatCount = easing;
+ easing = curve;
+ curve = duration;
+ duration = handlers;
+ handlers = null;
+ }else if(handlers.getValue||dojo.lang.isArray(handlers)){
+ // no handlers or duration:
+ rate = easing;
+ repeatCount = curve;
+ easing = duration;
+ curve = handlers;
+ duration = null;
+ handlers = null;
+ }
+ if(dojo.lang.isArray(curve)){
+ /* curve: Array
+ pId: a */
+ this.curve = new dojo.lfx.Line(curve[0], curve[1]);
+ }else{
+ this.curve = curve;
+ }
+ if(duration != null && duration > 0){ this.duration = duration; }
+ if(repeatCount){ this.repeatCount = repeatCount; }
+ if(rate){ this.rate = rate; }
+ if(handlers){
+ dojo.lang.forEach([
+ "handler", "beforeBegin", "onBegin",
+ "onEnd", "onPlay", "onStop", "onAnimate"
+ ], function(item){
+ if(handlers[item]){
+ this.connect(item, handlers[item]);
+ }
+ }, this);
+ }
+ if(easing && dojo.lang.isFunction(easing)){
+ this.easing=easing;
+ }
+}
+dojo.inherits(dojo.lfx.Animation, dojo.lfx.IAnimation);
+dojo.lang.extend(dojo.lfx.Animation, {
+ // "private" properties
+ _startTime: null,
+ _endTime: null,
+ _timer: null,
+ _percent: 0,
+ _startRepeatCount: 0,
+
+ // public methods
+ play: function(/*int?*/ delay, /*bool?*/ gotoStart){
+ // summary: Start the animation.
+ // delay: How many milliseconds to delay before starting.
+ // gotoStart: If true, starts the animation from the beginning; otherwise,
+ // starts it from its current position.
+ if(gotoStart){
+ clearTimeout(this._timer);
+ this._active = false;
+ this._paused = false;
+ this._percent = 0;
+ }else if(this._active && !this._paused){
+ return this; // dojo.lfx.Animation
+ }
+
+ this.fire("handler", ["beforeBegin"]);
+ this.fire("beforeBegin");
+
+ if(delay > 0){
+ setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay);
+ return this; // dojo.lfx.Animation
+ }
+
+ this._startTime = new Date().valueOf();
+ if(this._paused){
+ this._startTime -= (this.duration * this._percent / 100);
+ }
+ this._endTime = this._startTime + this.duration;
+
+ this._active = true;
+ this._paused = false;
+
+ var step = this._percent / 100;
+ var value = this.curve.getValue(step);
+ if(this._percent == 0 ){
+ if(!this._startRepeatCount){
+ this._startRepeatCount = this.repeatCount;
+ }
+ this.fire("handler", ["begin", value]);
+ this.fire("onBegin", [value]);
+ }
+
+ this.fire("handler", ["play", value]);
+ this.fire("onPlay", [value]);
+
+ this._cycle();
+ return this; // dojo.lfx.Animation
+ },
+
+ pause: function(){
+ // summary: Pauses a running animation.
+ clearTimeout(this._timer);
+ if(!this._active){ return this; /*dojo.lfx.Animation*/}
+ this._paused = true;
+ var value = this.curve.getValue(this._percent / 100);
+ this.fire("handler", ["pause", value]);
+ this.fire("onPause", [value]);
+ return this; // dojo.lfx.Animation
+ },
+
+ gotoPercent: function(/*Decimal*/ pct, /*bool?*/ andPlay){
+ // summary: Sets the progress of the animation.
+ // pct: A percentage in decimal notation (between and including 0.0 and 1.0).
+ // andPlay: If true, play the animation after setting the progress.
+ clearTimeout(this._timer);
+ this._active = true;
+ this._paused = true;
+ this._percent = pct;
+ if(andPlay){ this.play(); }
+ return this; // dojo.lfx.Animation
+ },
+
+ stop: function(/*bool?*/ gotoEnd){
+ // summary: Stops a running animation.
+ // gotoEnd: If true, the animation will end.
+ clearTimeout(this._timer);
+ var step = this._percent / 100;
+ if(gotoEnd){
+ step = 1;
+ }
+ var value = this.curve.getValue(step);
+ this.fire("handler", ["stop", value]);
+ this.fire("onStop", [value]);
+ this._active = false;
+ this._paused = false;
+ return this; // dojo.lfx.Animation
+ },
+
+ status: function(){
+ // summary: Returns a string representation of the status of
+ // the animation.
+ if(this._active){
+ return this._paused ? "paused" : "playing"; // String
+ }else{
+ return "stopped"; // String
+ }
+ return this;
+ },
+
+ // "private" methods
+ _cycle: function(){
+ clearTimeout(this._timer);
+ if(this._active){
+ var curr = new Date().valueOf();
+ var step = (curr - this._startTime) / (this._endTime - this._startTime);
+
+ if(step >= 1){
+ step = 1;
+ this._percent = 100;
+ }else{
+ this._percent = step * 100;
+ }
+
+ // Perform easing
+ if((this.easing)&&(dojo.lang.isFunction(this.easing))){
+ step = this.easing(step);
+ }
+
+ var value = this.curve.getValue(step);
+ this.fire("handler", ["animate", value]);
+ this.fire("onAnimate", [value]);
+
+ if( step < 1 ){
+ this._timer = setTimeout(dojo.lang.hitch(this, "_cycle"), this.rate);
+ }else{
+ this._active = false;
+ this.fire("handler", ["end"]);
+ this.fire("onEnd");
+
+ if(this.repeatCount > 0){
+ this.repeatCount--;
+ this.play(null, true);
+ }else if(this.repeatCount == -1){
+ this.play(null, true);
+ }else{
+ if(this._startRepeatCount){
+ this.repeatCount = this._startRepeatCount;
+ this._startRepeatCount = 0;
+ }
+ }
+ }
+ }
+ return this; // dojo.lfx.Animation
+ }
+});
+
+dojo.lfx.Combine = function(/*dojo.lfx.IAnimation...*/ animations){
+ // summary: An animation object to play animations passed to it at the same time.
+ dojo.lfx.IAnimation.call(this);
+ this._anims = [];
+ this._animsEnded = 0;
+
+ var anims = arguments;
+ if(anims.length == 1 && (dojo.lang.isArray(anims[0]) || dojo.lang.isArrayLike(anims[0]))){
+ /* animations: dojo.lfx.IAnimation[]
+ pId: a */
+ anims = anims[0];
+ }
+
+ dojo.lang.forEach(anims, function(anim){
+ this._anims.push(anim);
+ anim.connect("onEnd", dojo.lang.hitch(this, "_onAnimsEnded"));
+ }, this);
+}
+dojo.inherits(dojo.lfx.Combine, dojo.lfx.IAnimation);
+dojo.lang.extend(dojo.lfx.Combine, {
+ // private members
+ _animsEnded: 0,
+
+ // public methods
+ play: function(/*int?*/ delay, /*bool?*/ gotoStart){
+ // summary: Start the animations.
+ // delay: How many milliseconds to delay before starting.
+ // gotoStart: If true, starts the animations from the beginning; otherwise,
+ // starts them from their current position.
+ if( !this._anims.length ){ return this; /*dojo.lfx.Combine*/}
+
+ this.fire("beforeBegin");
+
+ if(delay > 0){
+ setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay);
+ return this; // dojo.lfx.Combine
+ }
+
+ if(gotoStart || this._anims[0].percent == 0){
+ this.fire("onBegin");
+ }
+ this.fire("onPlay");
+ this._animsCall("play", null, gotoStart);
+ return this; // dojo.lfx.Combine
+ },
+
+ pause: function(){
+ // summary: Pauses the running animations.
+ this.fire("onPause");
+ this._animsCall("pause");
+ return this; // dojo.lfx.Combine
+ },
+
+ stop: function(/*bool?*/ gotoEnd){
+ // summary: Stops the running animations.
+ // gotoEnd: If true, the animations will end.
+ this.fire("onStop");
+ this._animsCall("stop", gotoEnd);
+ return this; // dojo.lfx.Combine
+ },
+
+ // private methods
+ _onAnimsEnded: function(){
+ this._animsEnded++;
+ if(this._animsEnded >= this._anims.length){
+ this.fire("onEnd");
+ }
+ return this; // dojo.lfx.Combine
+ },
+
+ _animsCall: function(/*String*/ funcName){
+ var args = [];
+ if(arguments.length > 1){
+ for(var i = 1 ; i < arguments.length ; i++){
+ args.push(arguments[i]);
+ }
+ }
+ var _this = this;
+ dojo.lang.forEach(this._anims, function(anim){
+ anim[funcName](args);
+ }, _this);
+ return this; // dojo.lfx.Combine
+ }
+});
+
+dojo.lfx.Chain = function(/*dojo.lfx.IAnimation...*/ animations) {
+ // summary: An animation object to play animations passed to it
+ // one after another.
+ dojo.lfx.IAnimation.call(this);
+ this._anims = [];
+ this._currAnim = -1;
+
+ var anims = arguments;
+ if(anims.length == 1 && (dojo.lang.isArray(anims[0]) || dojo.lang.isArrayLike(anims[0]))){
+ /* animations: dojo.lfx.IAnimation[]
+ pId: a */
+ anims = anims[0];
+ }
+
+ var _this = this;
+ dojo.lang.forEach(anims, function(anim, i, anims_arr){
+ this._anims.push(anim);
+ if(i < anims_arr.length - 1){
+ anim.connect("onEnd", dojo.lang.hitch(this, "_playNext") );
+ }else{
+ anim.connect("onEnd", dojo.lang.hitch(this, function(){ this.fire("onEnd"); }) );
+ }
+ }, this);
+}
+dojo.inherits(dojo.lfx.Chain, dojo.lfx.IAnimation);
+dojo.lang.extend(dojo.lfx.Chain, {
+ // private members
+ _currAnim: -1,
+
+ // public methods
+ play: function(/*int?*/ delay, /*bool?*/ gotoStart){
+ // summary: Start the animation sequence.
+ // delay: How many milliseconds to delay before starting.
+ // gotoStart: If true, starts the sequence from the beginning; otherwise,
+ // starts it from its current position.
+ if( !this._anims.length ) { return this; /*dojo.lfx.Chain*/}
+ if( gotoStart || !this._anims[this._currAnim] ) {
+ this._currAnim = 0;
+ }
+
+ var currentAnimation = this._anims[this._currAnim];
+
+ this.fire("beforeBegin");
+ if(delay > 0){
+ setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay);
+ return this; // dojo.lfx.Chain
+ }
+
+ if(currentAnimation){
+ if(this._currAnim == 0){
+ this.fire("handler", ["begin", this._currAnim]);
+ this.fire("onBegin", [this._currAnim]);
+ }
+ this.fire("onPlay", [this._currAnim]);
+ currentAnimation.play(null, gotoStart);
+ }
+ return this; // dojo.lfx.Chain
+ },
+
+ pause: function(){
+ // summary: Pauses the running animation sequence.
+ if( this._anims[this._currAnim] ) {
+ this._anims[this._currAnim].pause();
+ this.fire("onPause", [this._currAnim]);
+ }
+ return this; // dojo.lfx.Chain
+ },
+
+ playPause: function(){
+ // summary: If the animation sequence is playing, pause it; otherwise,
+ // play it.
+ if(this._anims.length == 0){ return this; }
+ if(this._currAnim == -1){ this._currAnim = 0; }
+ var currAnim = this._anims[this._currAnim];
+ if( currAnim ) {
+ if( !currAnim._active || currAnim._paused ) {
+ this.play();
+ } else {
+ this.pause();
+ }
+ }
+ return this; // dojo.lfx.Chain
+ },
+
+ stop: function(){
+ // summary: Stops the running animations.
+ var currAnim = this._anims[this._currAnim];
+ if(currAnim){
+ currAnim.stop();
+ this.fire("onStop", [this._currAnim]);
+ }
+ return currAnim; // dojo.lfx.IAnimation
+ },
+
+ // private methods
+ _playNext: function(){
+ if( this._currAnim == -1 || this._anims.length == 0 ) { return this; }
+ this._currAnim++;
+ if( this._anims[this._currAnim] ){
+ this._anims[this._currAnim].play(null, true);
+ }
+ return this; // dojo.lfx.Chain
+ }
+});
+
+dojo.lfx.combine = function(/*dojo.lfx.IAnimation...*/ animations){
+ // summary: Convenience function. Returns a dojo.lfx.Combine created
+ // using the animations passed in.
+ var anims = arguments;
+ if(dojo.lang.isArray(arguments[0])){
+ /* animations: dojo.lfx.IAnimation[]
+ pId: a */
+ anims = arguments[0];
+ }
+ if(anims.length == 1){ return anims[0]; }
+ return new dojo.lfx.Combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.chain = function(/*dojo.lfx.IAnimation...*/ animations){
+ // summary: Convenience function. Returns a dojo.lfx.Chain created
+ // using the animations passed in.
+ var anims = arguments;
+ if(dojo.lang.isArray(arguments[0])){
+ /* animations: dojo.lfx.IAnimation[]
+ pId: a */
+ anims = arguments[0];
+ }
+ if(anims.length == 1){ return anims[0]; }
+ return new dojo.lfx.Chain(anims); // dojo.lfx.Combine
+}
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/Animation.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/__package__.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/__package__.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/__package__.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/__package__.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,5 @@
+dojo.kwCompoundRequire({
+ browser: ["dojo.lfx.html"],
+ dashboard: ["dojo.lfx.html"]
+});
+dojo.provide("dojo.lfx.*");
\ No newline at end of file
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/__package__.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/extras.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/extras.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/extras.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/extras.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,138 @@
+dojo.provide("dojo.lfx.extras");
+
+dojo.require("dojo.lfx.html");
+dojo.require("dojo.lfx.Animation");
+
+dojo.lfx.html.fadeWipeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from its current
+ // opacity to fully opaque while wiping it in.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anim = dojo.lfx.combine(
+ dojo.lfx.fadeIn(nodes, duration, easing),
+ dojo.lfx.wipeIn(nodes, duration, easing)
+ );
+
+ if(callback){
+ anim.connect("onEnd", function(){
+ callback(nodes, anim);
+ });
+ }
+
+ return anim; // dojo.lfx.Combine
+}
+
+dojo.lfx.html.fadeWipeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from its current
+ // opacity to fully transparent while wiping it out.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anim = dojo.lfx.combine(
+ dojo.lfx.fadeOut(nodes, duration, easing),
+ dojo.lfx.wipeOut(nodes, duration, easing)
+ );
+
+ if(callback){
+ /* callback: Function
+ pId: f */
+ anim.connect("onEnd", function(){
+ callback(nodes, anim);
+ });
+ }
+
+ return anim; // dojo.lfx.Combine
+}
+
+dojo.lfx.html.scale = function(/*DOMNode[]*/nodes,
+ /*int*/ percentage,
+ /*bool?*/ scaleContent,
+ /*bool?*/ fromCenter,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will scale "nodes" by "percentage".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // percentage: A whole number representing the percentage to scale "nodes".
+ // scaleContent: If true, will scale the contents of "nodes".
+ // fromCenter: If true, will scale "nodes" from its center rather than the
+ // lower right corner.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var outer = dojo.html.getMarginBox(node);
+
+ var actualPct = percentage/100.0;
+ var props = [
+ { property: "width",
+ start: outer.width,
+ end: outer.width * actualPct
+ },
+ { property: "height",
+ start: outer.height,
+ end: outer.height * actualPct
+ }];
+
+ if(scaleContent){
+ var fontSize = dojo.html.getStyle(node, 'font-size');
+ var fontSizeType = null;
+ if(!fontSize){
+ fontSize = parseFloat('100%');
+ fontSizeType = '%';
+ }else{
+ dojo.lang.some(['em','px','%'], function(item, index, arr){
+ if(fontSize.indexOf(item)>0){
+ fontSize = parseFloat(fontSize);
+ fontSizeType = item;
+ return true;
+ }
+ });
+ }
+ props.push({
+ property: "font-size",
+ start: fontSize,
+ end: fontSize * actualPct,
+ units: fontSizeType });
+ }
+
+ if(fromCenter){
+ var positioning = dojo.html.getStyle(node, "position");
+ var originalTop = node.offsetTop;
+ var originalLeft = node.offsetLeft;
+ var endTop = ((outer.height * actualPct) - outer.height)/2;
+ var endLeft = ((outer.width * actualPct) - outer.width)/2;
+ props.push({
+ property: "top",
+ start: originalTop,
+ end: (positioning == "absolute" ? originalTop - endTop : (-1*endTop))
+ });
+ props.push({
+ property: "left",
+ start: originalLeft,
+ end: (positioning == "absolute" ? originalLeft - endLeft : (-1*endLeft))
+ });
+ }
+
+ var anim = dojo.lfx.propertyAnimation(node, props, duration, easing);
+ if(callback){
+ anim.connect("onEnd", function(){
+ callback(node, anim);
+ });
+ }
+
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lang.mixin(dojo.lfx, dojo.lfx.html);
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/extras.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/html.js
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/html.js?view=auto&rev=473755
==============================================================================
--- jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/html.js (added)
+++ jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/html.js Sat Nov 11 08:44:22 2006
@@ -0,0 +1,724 @@
+dojo.provide("dojo.lfx.html");
+
+dojo.require("dojo.gfx.color");
+dojo.require("dojo.lfx.Animation");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.html.display");
+dojo.require("dojo.html.color");
+dojo.require("dojo.html.layout");
+
+dojo.lfx.html._byId = function(nodes){
+ if(!nodes){ return []; }
+ if(dojo.lang.isArrayLike(nodes)){
+ if(!nodes.alreadyChecked){
+ var n = [];
+ dojo.lang.forEach(nodes, function(node){
+ n.push(dojo.byId(node));
+ });
+ n.alreadyChecked = true;
+ return n;
+ }else{
+ return nodes;
+ }
+ }else{
+ var n = [];
+ n.push(dojo.byId(nodes));
+ n.alreadyChecked = true;
+ return n;
+ }
+}
+
+dojo.lfx.html.propertyAnimation = function( /*DOMNode[]*/ nodes,
+ /*Object[]*/ propertyMap,
+ /*int*/ duration,
+ /*function*/ easing,
+ /*Object*/ handlers){
+ // summary: Returns an animation that will transition the properties of "nodes"
+ // depending how they are defined in "propertyMap".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // propertyMap: { property: String, start: Decimal?, end: Decimal?, units: String? }
+ // An array of objects defining properties to change.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // handlers: { handler: Function?, onstart: Function?, onstop: Function?, onanimate: Function? }
+ nodes = dojo.lfx.html._byId(nodes);
+
+ var targs = {
+ "propertyMap": propertyMap,
+ "nodes": nodes,
+ "duration": duration,
+ "easing": easing||dojo.lfx.easeDefault
+ };
+
+ var setEmUp = function(args){
+ if(args.nodes.length==1){
+ // FIXME: we're only supporting start-value filling when one node is
+ // passed
+
+ var pm = args.propertyMap;
+ if(!dojo.lang.isArray(args.propertyMap)){
+ // it's stupid to have to pack an array with a set of objects
+ // when you can just pass in an object list
+ var parr = [];
+ for(var pname in pm){
+ pm[pname].property = pname;
+ parr.push(pm[pname]);
+ }
+ pm = args.propertyMap = parr;
+ }
+ dojo.lang.forEach(pm, function(prop){
+ if(dj_undef("start", prop)){
+ if(prop.property != "opacity"){
+ prop.start = parseInt(dojo.html.getComputedStyle(args.nodes[0], prop.property));
+ }else{
+ prop.start = dojo.html.getOpacity(args.nodes[0]);
+ }
+ }
+ });
+ }
+ }
+
+ var coordsAsInts = function(coords){
+ var cints = [];
+ dojo.lang.forEach(coords, function(c){
+ cints.push(Math.round(c));
+ });
+ return cints;
+ }
+
+ var setStyle = function(n, style){
+ n = dojo.byId(n);
+ if(!n || !n.style){ return; }
+ for(var s in style){
+ if(s == "opacity"){
+ dojo.html.setOpacity(n, style[s]);
+ }else{
+ n.style[s] = style[s];
+ }
+ }
+ }
+
+ var propLine = function(properties){
+ this._properties = properties;
+ this.diffs = new Array(properties.length);
+ dojo.lang.forEach(properties, function(prop, i){
+ // calculate the end - start to optimize a bit
+ if(dojo.lang.isFunction(prop.start)){
+ prop.start = prop.start(prop, i);
+ }
+ if(dojo.lang.isFunction(prop.end)){
+ prop.end = prop.end(prop, i);
+ }
+ if(dojo.lang.isArray(prop.start)){
+ // don't loop through the arrays
+ this.diffs[i] = null;
+ }else if(prop.start instanceof dojo.gfx.color.Color){
+ // save these so we don't have to call toRgb() every getValue() call
+ prop.startRgb = prop.start.toRgb();
+ prop.endRgb = prop.end.toRgb();
+ }else{
+ this.diffs[i] = prop.end - prop.start;
+ }
+ }, this);
+
+ this.getValue = function(n){
+ var ret = {};
+ dojo.lang.forEach(this._properties, function(prop, i){
+ var value = null;
+ if(dojo.lang.isArray(prop.start)){
+ // FIXME: what to do here?
+ }else if(prop.start instanceof dojo.gfx.color.Color){
+ value = (prop.units||"rgb") + "(";
+ for(var j = 0 ; j < prop.startRgb.length ; j++){
+ value += Math.round(((prop.endRgb[j] - prop.startRgb[j]) * n) + prop.startRgb[j]) + (j < prop.startRgb.length - 1 ? "," : "");
+ }
+ value += ")";
+ }else{
+ value = ((this.diffs[i]) * n) + prop.start + (prop.property != "opacity" ? prop.units||"px" : "");
+ }
+ ret[dojo.html.toCamelCase(prop.property)] = value;
+ }, this);
+ return ret;
+ }
+ }
+
+ var anim = new dojo.lfx.Animation({
+ beforeBegin: function(){
+ setEmUp(targs);
+ anim.curve = new propLine(targs.propertyMap);
+ },
+ onAnimate: function(propValues){
+ dojo.lang.forEach(targs.nodes, function(node){
+ setStyle(node, propValues);
+ });
+ }
+ },
+ targs.duration,
+ null,
+ targs.easing
+ );
+ if(handlers){
+ for(var x in handlers){
+ if(dojo.lang.isFunction(handlers[x])){
+ anim.connect(x, anim, handlers[x]);
+ }
+ }
+ }
+
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html._makeFadeable = function(nodes){
+ var makeFade = function(node){
+ if(dojo.render.html.ie){
+ // only set the zoom if the "tickle" value would be the same as the
+ // default
+ if( (node.style.zoom.length == 0) &&
+ (dojo.html.getStyle(node, "zoom") == "normal") ){
+ // make sure the node "hasLayout"
+ // NOTE: this has been tested with larger and smaller user-set text
+ // sizes and works fine
+ node.style.zoom = "1";
+ // node.style.zoom = "normal";
+ }
+ // don't set the width to auto if it didn't already cascade that way.
+ // We don't want to f anyones designs
+ if( (node.style.width.length == 0) &&
+ (dojo.html.getStyle(node, "width") == "auto") ){
+ node.style.width = "auto";
+ }
+ }
+ }
+ if(dojo.lang.isArrayLike(nodes)){
+ dojo.lang.forEach(nodes, makeFade);
+ }else{
+ makeFade(nodes);
+ }
+}
+
+dojo.lfx.html.fade = function(/*DOMNode[]*/ nodes,
+ /*Object*/values,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary:Returns an animation that will fade the "nodes" from the start to end values passed.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // values: { start: Decimal?, end: Decimal? }
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var props = { property: "opacity" };
+ if(!dj_undef("start", values)){
+ props.start = values.start;
+ }else{
+ props.start = function(){ return dojo.html.getOpacity(nodes[0]); };
+ }
+
+ if(!dj_undef("end", values)){
+ props.end = values.end;
+ }else{
+ dojo.raise("dojo.lfx.html.fade needs an end value");
+ }
+
+ var anim = dojo.lfx.propertyAnimation(nodes, [ props ], duration, easing);
+ anim.connect("beforeBegin", function(){
+ dojo.lfx.html._makeFadeable(nodes);
+ });
+ if(callback){
+ anim.connect("onEnd", function(){ callback(nodes, anim); });
+ }
+
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.fadeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from its current opacity to fully opaque.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ return dojo.lfx.html.fade(nodes, { end: 1 }, duration, easing, callback); // dojo.lfx.Animation
+}
+
+dojo.lfx.html.fadeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from its current opacity to fully transparent.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ return dojo.lfx.html.fade(nodes, { end: 0 }, duration, easing, callback); // dojo.lfx.Animation
+}
+
+dojo.lfx.html.fadeShow = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from transparent to opaque and shows
+ // "nodes" at the end if it is hidden.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes=dojo.lfx.html._byId(nodes);
+ dojo.lang.forEach(nodes, function(node){
+ dojo.html.setOpacity(node, 0.0);
+ });
+
+ var anim = dojo.lfx.html.fadeIn(nodes, duration, easing, callback);
+ anim.connect("beforeBegin", function(){
+ if(dojo.lang.isArrayLike(nodes)){
+ dojo.lang.forEach(nodes, dojo.html.show);
+ }else{
+ dojo.html.show(nodes);
+ }
+ });
+
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.fadeHide = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from its current opacity to opaque and hides
+ // "nodes" at the end.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ var anim = dojo.lfx.html.fadeOut(nodes, duration, easing, function(){
+ if(dojo.lang.isArrayLike(nodes)){
+ dojo.lang.forEach(nodes, dojo.html.hide);
+ }else{
+ dojo.html.hide(nodes);
+ }
+ if(callback){ callback(nodes, anim); }
+ });
+
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.wipeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will show and wipe in "nodes".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var oprop = { }; // old properties of node (before we mucked w/them)
+
+ // get node height, either it's natural height or it's height specified via style or class attributes
+ // (for FF, the node has to be (temporarily) rendered to measure height)
+ dojo.html.show(node);
+ var height = dojo.html.getBorderBox(node).height;
+ dojo.html.hide(node);
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "height": {
+ start: 1, // 0 causes IE to display the whole panel
+ end: function(){ return height; }
+ }
+ },
+ duration,
+ easing);
+
+ anim.connect("beforeBegin", function(){
+ oprop.overflow = node.style.overflow;
+ oprop.height = node.style.height;
+ with(node.style){
+ overflow = "hidden";
+ height = "1px"; // 0 causes IE to display the whole panel
+ }
+ dojo.html.show(node);
+ });
+
+ anim.connect("onEnd", function(){
+ with(node.style){
+ overflow = oprop.overflow;
+ height = oprop.height;
+ }
+ if(callback){ callback(node, anim); }
+ });
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.wipeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will wipe out and hide "nodes".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var oprop = { }; // old properties of node (before we mucked w/them)
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "height": {
+ start: function(){ return dojo.html.getContentBox(node).height; },
+ end: 1 // 0 causes IE to display the whole panel
+ }
+ },
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ oprop.overflow = node.style.overflow;
+ oprop.height = node.style.height;
+ with(node.style){
+ overflow = "hidden";
+ }
+ dojo.html.show(node);
+ },
+
+ "onEnd": function(){
+ dojo.html.hide(node);
+ with(node.style){
+ overflow = oprop.overflow;
+ height = oprop.height;
+ }
+ if(callback){ callback(node, anim); }
+ }
+ }
+ );
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.slideTo = function(/*DOMNode*/ nodes,
+ /*Object*/ coords,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will slide "nodes" from its current position to
+ // the position defined in "coords".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // coords: { top: Decimal?, left: Decimal? }
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+ var compute = dojo.html.getComputedStyle;
+
+ if(dojo.lang.isArray(coords)){
+ /* coords: Array
+ pId: a */
+ dojo.deprecated('dojo.lfx.html.slideTo(node, array)', 'use dojo.lfx.html.slideTo(node, {top: value, left: value});', '0.5');
+ coords = { top: coords[0], left: coords[1] };
+ }
+ dojo.lang.forEach(nodes, function(node){
+ var top = null;
+ var left = null;
+
+ var init = (function(){
+ var innerNode = node;
+ return function(){
+ var pos = compute(innerNode, 'position');
+ top = (pos == 'absolute' ? node.offsetTop : parseInt(compute(node, 'top')) || 0);
+ left = (pos == 'absolute' ? node.offsetLeft : parseInt(compute(node, 'left')) || 0);
+
+ if (!dojo.lang.inArray(['absolute', 'relative'], pos)) {
+ var ret = dojo.html.abs(innerNode, true);
+ dojo.html.setStyleAttributes(innerNode, "position:absolute;top:"+ret.y+"px;left:"+ret.x+"px;");
+ top = ret.y;
+ left = ret.x;
+ }
+ }
+ })();
+ init();
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "top": { start: top, end: (coords.top||0) },
+ "left": { start: left, end: (coords.left||0) }
+ },
+ duration,
+ easing,
+ { "beforeBegin": init }
+ );
+
+ if(callback){
+ anim.connect("onEnd", function(){ callback(nodes, anim); });
+ }
+
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.slideBy = function(/*DOMNode*/ nodes, /*Object*/ coords, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will slide "nodes" from its current position
+ // to its current position plus the numbers defined in "coords".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // coords: { top: Decimal?, left: Decimal? }
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+ var compute = dojo.html.getComputedStyle;
+
+ if(dojo.lang.isArray(coords)){
+ /* coords: Array
+ pId: a */
+ dojo.deprecated('dojo.lfx.html.slideBy(node, array)', 'use dojo.lfx.html.slideBy(node, {top: value, left: value});', '0.5');
+ coords = { top: coords[0], left: coords[1] };
+ }
+
+ dojo.lang.forEach(nodes, function(node){
+ var top = null;
+ var left = null;
+
+ var init = (function(){
+ var innerNode = node;
+ return function(){
+ var pos = compute(innerNode, 'position');
+ top = (pos == 'absolute' ? node.offsetTop : parseInt(compute(node, 'top')) || 0);
+ left = (pos == 'absolute' ? node.offsetLeft : parseInt(compute(node, 'left')) || 0);
+
+ if (!dojo.lang.inArray(['absolute', 'relative'], pos)) {
+ var ret = dojo.html.abs(innerNode, true);
+ dojo.html.setStyleAttributes(innerNode, "position:absolute;top:"+ret.y+"px;left:"+ret.x+"px;");
+ top = ret.y;
+ left = ret.x;
+ }
+ }
+ })();
+ init();
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ {
+ "top": { start: top, end: top+(coords.top||0) },
+ "left": { start: left, end: left+(coords.left||0) }
+ },
+ duration,
+ easing).connect("beforeBegin", init);
+
+ if(callback){
+ anim.connect("onEnd", function(){ callback(nodes, anim); });
+ }
+
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.explode = function(/*DOMNode*/ start,
+ /*DOMNode*/ endNode,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will
+ // start:
+ // endNode:
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ var h = dojo.html;
+ start = dojo.byId(start);
+ endNode = dojo.byId(endNode);
+ var startCoords = h.toCoordinateObject(start, true);
+ var outline = document.createElement("div");
+ h.copyStyle(outline, endNode);
+ if (endNode.explodeClassName) { outline.className = endNode.explodeClassName; }
+ with(outline.style){
+ position = "absolute";
+ display = "none";
+ // border = "1px solid black";
+ }
+ dojo.body().appendChild(outline);
+
+ with(endNode.style){
+ visibility = "hidden";
+ display = "block";
+ }
+ var endCoords = h.toCoordinateObject(endNode, true);
+ with(endNode.style){
+ display = "none";
+ visibility = "visible";
+ }
+
+ var props = { opacity: { start: 0.5, end: 1.0 } };
+ dojo.lang.forEach(["height", "width", "top", "left"], function(type){
+ props[type] = { start: startCoords[type], end: endCoords[type] }
+ });
+
+ var anim = new dojo.lfx.propertyAnimation(outline,
+ props,
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ h.setDisplay(outline, "block");
+ },
+ "onEnd": function(){
+ h.setDisplay(endNode, "block");
+ outline.parentNode.removeChild(outline);
+ }
+ }
+ );
+
+ if(callback){
+ anim.connect("onEnd", function(){ callback(endNode, anim); });
+ }
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.implode = function(/*DOMNode*/ startNode,
+ /*DOMNode*/ end,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will
+ // startNode:
+ // end:
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ var h = dojo.html;
+ startNode = dojo.byId(startNode);
+ end = dojo.byId(end);
+ var startCoords = dojo.html.toCoordinateObject(startNode, true);
+ var endCoords = dojo.html.toCoordinateObject(end, true);
+
+ var outline = document.createElement("div");
+ dojo.html.copyStyle(outline, startNode);
+ if (startNode.explodeClassName) { outline.className = startNode.explodeClassName; }
+ dojo.html.setOpacity(outline, 0.3);
+ with(outline.style){
+ position = "absolute";
+ display = "none";
+ backgroundColor = h.getStyle(startNode, "background-color").toLowerCase();
+ }
+ dojo.body().appendChild(outline);
+
+ var props = { opacity: { start: 1.0, end: 0.5 } };
+ dojo.lang.forEach(["height", "width", "top", "left"], function(type){
+ props[type] = { start: startCoords[type], end: endCoords[type] }
+ });
+
+ var anim = new dojo.lfx.propertyAnimation(outline,
+ props,
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ dojo.html.hide(startNode);
+ dojo.html.show(outline);
+ },
+ "onEnd": function(){
+ outline.parentNode.removeChild(outline);
+ }
+ }
+ );
+
+ if(callback){
+ anim.connect("onEnd", function(){ callback(startNode, anim); });
+ }
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.highlight = function(/*DOMNode[]*/ nodes,
+ /*dojo.gfx.color.Color*/ startColor,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will set the background color
+ // of "nodes" to startColor and transition it to "nodes"
+ // original color.
+ // startColor: Color to transition from.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var color = dojo.html.getBackgroundColor(node);
+ var bg = dojo.html.getStyle(node, "background-color").toLowerCase();
+ var bgImage = dojo.html.getStyle(node, "background-image");
+ var wasTransparent = (bg == "transparent" || bg == "rgba(0, 0, 0, 0)");
+ while(color.length > 3) { color.pop(); }
+
+ var rgb = new dojo.gfx.color.Color(startColor);
+ var endRgb = new dojo.gfx.color.Color(color);
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "background-color": { start: rgb, end: endRgb } },
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ if(bgImage){
+ node.style.backgroundImage = "none";
+ }
+ node.style.backgroundColor = "rgb(" + rgb.toRgb().join(",") + ")";
+ },
+ "onEnd": function(){
+ if(bgImage){
+ node.style.backgroundImage = bgImage;
+ }
+ if(wasTransparent){
+ node.style.backgroundColor = "transparent";
+ }
+ if(callback){
+ callback(node, anim);
+ }
+ }
+ }
+ );
+
+ anims.push(anim);
+ });
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.unhighlight = function(/*DOMNode[]*/ nodes,
+ /*dojo.gfx.color.Color*/ endColor,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will transition "nodes" background color
+ // from its current color to "endColor".
+ // endColor: Color to transition to.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var color = new dojo.gfx.color.Color(dojo.html.getBackgroundColor(node));
+ var rgb = new dojo.gfx.color.Color(endColor);
+
+ var bgImage = dojo.html.getStyle(node, "background-image");
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "background-color": { start: color, end: rgb } },
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ if(bgImage){
+ node.style.backgroundImage = "none";
+ }
+ node.style.backgroundColor = "rgb(" + color.toRgb().join(",") + ")";
+ },
+ "onEnd": function(){
+ if(callback){
+ callback(node, anim);
+ }
+ }
+ }
+ );
+ anims.push(anim);
+ });
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lang.mixin(dojo.lfx, dojo.lfx.html);
Propchange: jackrabbit/trunk/contrib/jcr-browser/src/main/webapp/dojo/src/lfx/html.js
------------------------------------------------------------------------------
svn:eol-style = native