From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001 From: mensonge Date: Thu, 13 Nov 2008 09:49:11 +0000 Subject: New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f --- includes/js/dojox/gfx/fx.js | 281 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 281 insertions(+) create mode 100644 includes/js/dojox/gfx/fx.js (limited to 'includes/js/dojox/gfx/fx.js') diff --git a/includes/js/dojox/gfx/fx.js b/includes/js/dojox/gfx/fx.js new file mode 100644 index 0000000..2b576d6 --- /dev/null +++ b/includes/js/dojox/gfx/fx.js @@ -0,0 +1,281 @@ +if(!dojo._hasResource["dojox.gfx.fx"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojox.gfx.fx"] = true; +dojo.provide("dojox.gfx.fx"); + +dojo.require("dojox.gfx.matrix"); + +(function(){ + var d = dojo, g = dojox.gfx, m = g.matrix; + + // Generic interpolators. Should they be moved to dojox.fx? + + var InterpolNumber = function(start, end){ + this.start = start, this.end = end; + }; + d.extend(InterpolNumber, { + getValue: function(r){ + return (this.end - this.start) * r + this.start; + } + }); + + var InterpolUnit = function(start, end, unit){ + this.start = start, this.end = end; + this.unit = unit; + }; + d.extend(InterpolUnit, { + getValue: function(r){ + return (this.end - this.start) * r + this.start + this.unit; + } + }); + + var InterpolColor = function(start, end){ + this.start = start, this.end = end; + this.temp = new dojo.Color(); + }; + d.extend(InterpolColor, { + getValue: function(r){ + return d.blendColors(this.start, this.end, r, this.temp); + } + }); + + var InterpolValues = function(values){ + this.values = values; + this.length = values.length; + }; + d.extend(InterpolValues, { + getValue: function(r){ + return this.values[Math.min(Math.floor(r * this.length), this.length - 1)]; + } + }); + + var InterpolObject = function(values, def){ + this.values = values; + this.def = def ? def : {}; + }; + d.extend(InterpolObject, { + getValue: function(r){ + var ret = dojo.clone(this.def); + for(var i in this.values){ + ret[i] = this.values[i].getValue(r); + } + return ret; + } + }); + + var InterpolTransform = function(stack, original){ + this.stack = stack; + this.original = original; + }; + d.extend(InterpolTransform, { + getValue: function(r){ + var ret = []; + dojo.forEach(this.stack, function(t){ + if(t instanceof m.Matrix2D){ + ret.push(t); + return; + } + if(t.name == "original" && this.original){ + ret.push(this.original); + return; + } + if(!(t.name in m)){ return; } + var f = m[t.name]; + if(typeof f != "function"){ + // constant + ret.push(f); + return; + } + var val = dojo.map(t.start, function(v, i){ + return (t.end[i] - v) * r + v; + }), + matrix = f.apply(m, val); + if(matrix instanceof m.Matrix2D){ + ret.push(matrix); + } + }, this); + return ret; + } + }); + + var transparent = new d.Color(0, 0, 0, 0); + + var getColorInterpol = function(prop, obj, name, def){ + if(prop.values){ + return new InterpolValues(prop.values); + } + var value, start, end; + if(prop.start){ + start = g.normalizeColor(prop.start); + }else{ + start = value = obj ? (name ? obj[name] : obj) : def; + } + if(prop.end){ + end = g.normalizeColor(prop.end); + }else{ + if(!value){ + value = obj ? (name ? obj[name] : obj) : def; + } + end = value; + } + return new InterpolColor(start, end); + }; + + var getNumberInterpol = function(prop, obj, name, def){ + if(prop.values){ + return new InterpolValues(prop.values); + } + var value, start, end; + if(prop.start){ + start = prop.start; + }else{ + start = value = obj ? obj[name] : def; + } + if(prop.end){ + end = prop.end; + }else{ + if(typeof value != "number"){ + value = obj ? obj[name] : def; + } + end = value; + } + return new InterpolNumber(start, end); + }; + + g.fx.animateStroke = function(/*Object*/ args){ + // summary: + // returns the animation, which will change stroke properties over time + // example: + // | dojox.gfx.fx.animateStroke{{ + // | shape: shape, + // | duration: 500, + // | color: {start: "red", end: "green"}, + // | width: {end: 15}, + // | join: {values: ["miter", "bevel", "round"]} + // | }).play(); + if(!args.easing){ args.easing = d._defaultEasing; } + var anim = new d._Animation(args), shape = args.shape, stroke; + d.connect(anim, "beforeBegin", anim, function(){ + stroke = shape.getStroke(); + var prop = args.color, values = {}, value, start, end; + if(prop){ + values.color = getColorInterpol(prop, stroke, "color", transparent); + } + prop = args.style; + if(prop && prop.values){ + values.style = new InterpolValues(prop.values); + } + prop = args.width; + if(prop){ + values.width = getNumberInterpol(prop, stroke, "width", 1); + } + prop = args.cap; + if(prop && prop.values){ + values.cap = new InterpolValues(prop.values); + } + prop = args.join; + if(prop){ + if(prop.values){ + values.join = new InterpolValues(prop.values); + }else{ + start = prop.start ? prop.start : (stroke && stroke.join || 0); + end = prop.end ? prop.end : (stroke && stroke.join || 0); + if(typeof start == "number" && typeof end == "number"){ + values.join = new InterpolNumber(start, end); + } + } + } + this.curve = new InterpolObject(values, stroke); + }); + d.connect(anim, "onAnimate", shape, "setStroke"); + return anim; + }; + + g.fx.animateFill = function(/*Object*/ args){ + // summary: + // returns the animation, which will change fill color over time, + // only solid fill color is supported at the moment + // example: + // | dojox.gfx.fx.animateFill{{ + // | shape: shape, + // | duration: 500, + // | color: {start: "red", end: "green"} + // | }).play(); + if(!args.easing){ args.easing = d._defaultEasing; } + var anim = new d._Animation(args), shape = args.shape, fill; + d.connect(anim, "beforeBegin", anim, function(){ + fill = shape.getFill(); + var prop = args.color, values = {}; + if(prop){ + this.curve = getColorInterpol(prop, fill, "", transparent); + } + }); + d.connect(anim, "onAnimate", shape, "setFill"); + return anim; + }; + + g.fx.animateFont = function(/*Object*/ args){ + // summary: + // returns the animation, which will change font properties over time + // example: + // | dojox.gfx.fx.animateFont{{ + // | shape: shape, + // | duration: 500, + // | variant: {values: ["normal", "small-caps"]}, + // | size: {end: 10, unit: "pt"} + // | }).play(); + if(!args.easing){ args.easing = d._defaultEasing; } + var anim = new d._Animation(args), shape = args.shape, font; + d.connect(anim, "beforeBegin", anim, function(){ + font = shape.getFont(); + var prop = args.style, values = {}, value, start, end; + if(prop && prop.values){ + values.style = new InterpolValues(prop.values); + } + prop = args.variant; + if(prop && prop.values){ + values.variant = new InterpolValues(prop.values); + } + prop = args.weight; + if(prop && prop.values){ + values.weight = new InterpolValues(prop.values); + } + prop = args.family; + if(prop && prop.values){ + values.family = new InterpolValues(prop.values); + } + prop = args.size; + if(prop && prop.unit){ + start = parseFloat(prop.start ? prop.start : (shape.font && shape.font.size || "0")); + end = parseFloat(prop.end ? prop.end : (shape.font && shape.font.size || "0")); + values.size = new InterpolUnit(start, end, prop.unit); + } + this.curve = new InterpolObject(values, font); + }); + d.connect(anim, "onAnimate", shape, "setFont"); + return anim; + }; + + g.fx.animateTransform = function(/*Object*/ args){ + // summary: + // returns the animation, which will change transformation over time + // example: + // | dojox.gfx.fx.animateTransform{{ + // | shape: shape, + // | duration: 500, + // | transform: [ + // | {name: "translate", start: [0, 0], end: [200, 200]}, + // | {name: "original"} + // | ] + // | }).play(); + if(!args.easing){ args.easing = d._defaultEasing; } + var anim = new d._Animation(args), shape = args.shape, original; + d.connect(anim, "beforeBegin", anim, function(){ + original = shape.getTransform(); + this.curve = new InterpolTransform(args.transform, original); + }); + d.connect(anim, "onAnimate", shape, "setTransform"); + return anim; + }; +})(); + +} -- cgit v1.2.3