/*
 * THIS IS FREE SCRIPT BUT LEAVE THIS COMMENT IF
 * YOU WANT USE THIS CODE ON YOUR SITE
 *
 * Made by Wilq32, wilq32@gmail.com, Wroclaw, Poland, 01.2009
 *
 */
/*
Description:

This is an final product of a Wilq32.PhotoEffect Snippet. Actually you can
 use this simple and tiny script to get effect of rotated images directly
 from client side (for ex. user generated content), and animate them using
 own functions.


Notices:

Include script after including main jQuery. Whole plugin uses jQuery
namespace and should be compatible with older version (unchecked).
To use it in IE you need those two lines to be added after <body> tag:



<!-- Include the VML behavior -->
<style>v\: * { behavior:url(#default#VML); display:inline-block }</style>
<!-- Declare the VML namespace -->
<xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" />


If someone know working workaround for doing this only in javascript please
let me know. Right now i tried using createStyleSheets but IE doesnt recognise
 "v\: *". Adding namespace with document.namespace.add is also messy. If
 someone know this problem and a solution just please let me know.




Usage:

jQuery(imgElement).rotate(angleValue)
jQuery(imgElement).rotate(parameters)
jQuery(imgElement).rotateAnimation(parameters)
jQuery(imgElement).rotateAnimation(parameters)



Returns:

jQueryRotateElement - !!! NOTICE !!! function return rotateElement
instance to help connect events with actually created 'rotation' element.

Parameters:

    ({angle:angleValue,
     [animateAngle:animateAngleValue],
     [maxAngle:maxAngleValue],
     [minAngle:minAngleValue],
     [callback:callbackFunction],
     [bind:[{event: function},{event:function} ] })
jQuery(imgElement).rotateAnimation

Where:

- angleValue - clockwise rotation given in degrees,
- [animateAngleValue] - optional parameter, animate rotating into this value,
- [maxAngleValue] - optional parameter, maximum angle possible for animation,
- [minAngleValue] - optional parameter, minimum angle possible for animation,
- [callbackFunction] - optional function to run after animation is done
- [bind: [ {event: function}...] -optional parameter, list of events binded
  to newly created rotateable object

Examples:

                $(document).ready(function()
                {
                        $('#image').rotate(-25);
                });

                $(document).ready(function()
                {
                        $('#image2').rotate({angle:5});
                });

                $(document).ready(function()
                {
                        var rot=$('#image3').rotate({maxAngle:25,minAngle:-55,
                        bind:
                                [
                                        {"mouseover":function(){rot[0].rotateAnimation(85);}},
                                        {"mouseout":function(){rot[0].rotateAnimation(-35);}}
                                ]
                        });
                });
*/


jQuery.fn.extend(
    {
        ImageRotate: function(parameters){
            if (this.Wilq32 && this.Wilq32.PhotoEffect){
                return null;
            }
            return (new Wilq32.PhotoEffect(this.get(0), parameters))._temp;
        },

        rotate: function(parameters){
            if (this.length === 0 || typeof parameters == "undefined"){
                return null;
            }
            if (typeof parameters == "number"){
                parameters = {angle: parameters};
            }
            var returned = [];
            for (var i = 0,i0 = this.length;i<i0;i++){
                var element = this.get(i);
                if (typeof element.Wilq32 == "undefined"){
                    returned.push($($(element).ImageRotate(parameters)));
                } else {
                    element.Wilq32.PhotoEffect._rotate(parameters.angle);
                }
            }
            return returned;
        },

        rotateAnimation:function(parameters){
            if (this.length === 0 || typeof parameters == "undefined"){
                return null;
            }
            if (typeof parameters == "number"){
                parameters = {angle: parameters};
            }
            var returned = [];
            for (var i = 0,i0 = this.length;i<i0;i++){
                var element = this.get(i);
                if (typeof element.Wilq32 == "undefined"){
                    returned.push($($(element).ImageRotate(parameters)));
                } else {
                    element.Wilq32.PhotoEffect._parameters.animateAngle = parameters.angle;
                    element.Wilq32.PhotoEffect._parameters.callback = parameters.callback || function(){};
                    element.Wilq32.PhotoEffect._animateStart();
                }
            }
            return returned;
        }

    });

Wilq32 = {};

Wilq32.PhotoEffect = function(img, parameters){
    this._IEfix = img;
    this._parameters = parameters || {};
    this._parameters.className = img.className;
    this._parameters.id = img.getAttribute('id');

    this._angle = 0;
    this._parameters.angle = this._parameters.angle || 0;
    this._parameters.animationTime = this._parameters.animationTime || 500;

    this._temp = document.createElement('span');
    this._temp.Wilq32  = {PhotoEffect: this};

    var image = img.src;
    img.parentNode.insertBefore(this._temp, img);

    this._img =  new Image();
    this._img.src = image;
    if (typeof IMAGE_WIDTH !== "undefined"){
        this._img.width = IMAGE_WIDTH;
    }
    this._css_scale_factor = img.width/this._img.width;
    this._img.width = img.width;
    this._img.height = img.height;
    this._img._ref = this;

    jQuery(this._img).bind("load",
                           function(){
                               if (this._ref._css_scale_factor === Infinity){
                                   this._ref._css_scale_factor = img.width/this.width;
                               }
                               this._ref._Loader.call(this._ref);
                           });

    if (jQuery.browser.msie && this._img.complete){
        this._Loader();
    }
};

if (jQuery.browser.msie){

    Wilq32.PhotoEffect.prototype._Loader = function(){
        var src = this._IEfix.src;
        this._IEfix.parentNode.removeChild(this._IEfix);
        this._temp.setAttribute('id',this._parameters.id);
        this._temp.className = this._parameters.className;
        var width = this._img.width;
        var height = this._img.height;

        this._img._widthMax = this._img._heightMax = Math.sqrt((height)*(height) + (width) * (width));
        this._img._heightMax = Math.sqrt((height)*(height) + (width) * (width));

        this._vimage = document.createElement('v:image');
        this._vimage._ref = this;
        this._vimage.style.height = height;
        this._vimage.style.width = width;
        this._vimage.style.position = "relative";
        this._temp.style.display = "inline-block";
        this._temp.style.width = this._temp.style.height = this._img._heightMax;
        this._vimage.src = src;
        this._vimage.rotate = 0;
        this._temp.appendChild(this._vimage);

        var self = this;
        this._parameters.animateAngle = 0;
        if (this._parameters.bind){
            for (var a in this._parameters.bind){
                if (this._parameters.bind.hasOwnProperty(a)){
                    for (var b in this._parameters.bind[a]){
                        if (this._parameters.bind[a].hasOwnProperty(b)){
                            jQuery(this._temp).bind(b,this._parameters.bind[a][b]);
                        }
                    }
                }
            }
        }
        this._rotate(this._parameters.angle);

    };

    Wilq32.PhotoEffect.prototype._rotate = function(angle){
        this._vimage.style.rotation = angle;
        var radians = angle*Math.PI/180;
        this._vimage.style.top = (this._img._heightMax - this._img.height)/2
                                     - (this._vimage.offsetHeight-this._img.height)/2 +"px";
        this._vimage.style.left = (this._img._widthMax - this._img.width)/2
                                      - (this._vimage.offsetWidth-this._img.width)/2 +"px";
    };


} else {

    Wilq32.PhotoEffect.prototype._Loader = function(){
        this._IEfix.parentNode.removeChild(this._IEfix);
        this._temp.setAttribute('id', this._parameters.id);
        this._temp.className = this._parameters.className;
        var width = this._img.width;
        var height = this._img.height;

        this._img._widthMax = this._img._heightMax = Math.sqrt(height*height + width*width);

        this._canvas = document.createElement('canvas');
        this._canvas._ref = this;

        this._canvas.height = Math.max(height, width);
        this._canvas.width = Math.max(height, width);

//        this._canvas.height = height;
//        this._canvas.width = width;

        this._canvas.setAttribute('width',width);

        this._temp.appendChild(this._canvas);

        var self = this;
        this._parameters.animateAngle = 0;
        if (this._parameters.bind){
            for (var a in this._parameters.bind){
                if (this._parameters.bind.hasOwnProperty(a)){
                    for (var b in this._parameters.bind[a]){
                        if (this._parameters.bind[a].hasOwnProperty(b)){
                            jQuery(this._canvas).bind(b,this._parameters.bind[a][b]);
                        }
                    }
                }
            }
        }
        this._cnv = this._canvas.getContext('2d');
        this._rotate(this._parameters.angle);
    };


    Wilq32.PhotoEffect.prototype._rotate = function(degrees){
        if (!this._img.width || typeof degrees != "number"){
            return;
        }
        var radians = (degrees%360) * Math.PI / 180;

        var width = this._canvas.width;
        var height = this._canvas.height;

        var diagRadius = Math.sqrt(width*width + height*height);
        var diagRadian = Math.acos(width/diagRadius);
        if (-90 < degrees%180 && degrees%180 <= 0 || 90 < degrees%180){
            var newDiagRadian = diagRadian + radians; // in radians
            var newDiagRadian2 = diagRadian - radians; // in radians
        } else {
            var newDiagRadian = diagRadian - radians; // in radians
            var newDiagRadian2 = diagRadian + radians; // in radians
        }

        var newWidth = diagRadius * Math.cos(newDiagRadian);
        var newHeight = diagRadius * Math.sin(newDiagRadian2);

        var scaleFactor = Math.min(Math.abs(width / newWidth),
                                   Math.abs(height / newHeight));

        var widthAdd = (newWidth - width);
        var heightAdd = 0;
        // clear canvas
        this._cnv.clearRect(0,0, width, height);

        // REMEMBER: all drawings are read from backwards..
        // so first function is translate, then rotate, then translate, translate..

        var widthOffset = width/2;
        var heightOffset = height/2;

        this._cnv.save();

        this._cnv.translate(width/2, height/2);       // we move image back to its orginal

        this._cnv.rotate(-radians);                     // rotate image

        this._cnv.scale(scaleFactor, scaleFactor);
        this._cnv.translate(-this._img.width/2,-this._img.height/2);     // move image to its center, so we can rotate around its center

        this._cnv.scale(this._css_scale_factor, this._css_scale_factor);
        this._cnv.drawImage(this._img, 0, 0);        // First - we draw image
        this._cnv.restore();
    };


}


Wilq32.PhotoEffect.prototype._animateStart = function(){
    if (this._timer){
        clearTimeout(this._timer);
    }
    this._startTime = (new Date()).getTime();
    this._parameters.animationTime = 500;
    this._animate();
};

Wilq32.PhotoEffect.prototype._animate = function(){
    var now = (new Date()).getTime();
    var dt = Math.min(now - this._startTime, this._parameters.animationTime);

    if (dt >= this._parameters.animationTime){
        this._angle = this._parameters.animateAngle;
        this._rotate(this._angle);
        return;
    }

    var deltaFactor = dt/this._parameters.animationTime;
    var newAngle = this._angle + (this._parameters.animateAngle - this._angle)*deltaFactor;

    this._rotate(newAngle);

    var self = this;
    this._timer = setTimeout(function(){ self._animate.call(self); }, 10);

};


// STILL DONT WORK ON IE8...
/*
 if (jQuery.browser.msie)
 {
 document.createStyleSheet().addRule('v\\:image', "behavior: url (#default#VML);display:inline-block");
 document.namespaces.add('v', 'urn:schemas-microsoft-com:vml');
 if(document.documentMode && document.documentMode>=8) {
 document.writeln('<?import namespace="v" implementation="#default#VML" ?>');
 }
 }*/