/// <reference path="XamlObjectFactory.js" />

var token = '';
var stopDuration = 0.7;
if (!window.SilverlightRecipes) window.SilverlightRecipes = {};

SilverlightRecipes.Animator = function() {
}

SilverlightRecipes.Animator.fadeIn = function(id, target, duration) {
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {
            storyboard.stop();
            storyboard.duration = duration;
            storyboard.begin();
            return;
        }
    }
    var storyboard = SilverlightRecipes.Animator.createUiElementOpacityAnimation(id, target, duration, "0", "1");
    target.visibility = 'Visible';
    storyboard.begin();
}

SilverlightRecipes.Animator.fadeOut = function(id, target, duration) {
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {
            storyboard.stop();
            storyboard.duration = duration;
            storyboard.begin();
            return;
        }
    }
    var storyboard = SilverlightRecipes.Animator.createUiElementOpacityAnimation(id, target, duration, "1", "0");
    storyboard.begin();
}

SilverlightRecipes.Animator.createUiElementOpacityAnimation = function(id, target, duration, from, to) {
    var xaml = SilverlightRecipes.Animator.createOpacityAnimation(id, target.Name, duration, from, to);
    var storyboard = target.getHost().content.createFromXaml(xaml);
    target.resources.add(storyboard);
    return storyboard;
}

SilverlightRecipes.Animator.createOpacityAnimation = function(id, targetName, duration, from, to) {
    var xaml = '<Storyboard #Name#>';
    xaml += '<DoubleAnimation #Storyboard.TargetName# Storyboard.TargetProperty="(UIElement.Opacity)" #From# #To# />';
    xaml += '</Storyboard>';
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Name', id);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Storyboard.TargetName', targetName);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'From', from);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'To', to);
    return xaml;
}

SilverlightRecipes.Animator.Rectangle = function(left, top, width, height) {
    this.left = left;
    this.top = top;
    this.width = width;
    this.height = height;
}

SilverlightRecipes.Animator.wipeDown = function(id, target, duration, completeFunctionName) {
    var fromRect = new SilverlightRecipes.Animator.Rectangle(0, 0, target.width, 0);
    var toRect = new SilverlightRecipes.Animator.Rectangle(0, 0, target.width, target.height);
    var storyboard = SilverlightRecipes.Animator.createUiElementWipeAnimation(id, target, duration, fromRect, toRect);

    target.visibility = 'Visible';

    if (completeFunctionName != '') {
        storyboard.AddEventListener("Completed", completeFunctionName);
    }

    storyboard.stop();
    storyboard.begin();
}

SilverlightRecipes.Animator.wipeUp = function(id, target, duration, completeFunctionName) {
    var fromRect = new SilverlightRecipes.Animator.Rectangle(target.width, target.height, -target.width, 0);
    var toRect = new SilverlightRecipes.Animator.Rectangle(target.width, target.height, -target.width, -target.height);
    var storyboard = SilverlightRecipes.Animator.createUiElementWipeAnimation(id, target, duration, fromRect, toRect);
    target.visibility = 'Visible';

    if (completeFunctionName != '') {
        storyboard.AddEventListener("Completed", completeFunctionName);
    }

    storyboard.stop();
    storyboard.begin();
}

SilverlightRecipes.Animator.wipeRight = function(id, target, duration, completeFunctionName) {
    var fromRect = new SilverlightRecipes.Animator.Rectangle(0, 0, 0, target.height);
    var toRect = new SilverlightRecipes.Animator.Rectangle(0, 0, target.width, target.height);
    var storyboard = SilverlightRecipes.Animator.createUiElementWipeAnimation(id, target, duration, fromRect, toRect);
    target.visibility = 'Visible';

    if (completeFunctionName != '') {
        storyboard.AddEventListener("Completed", completeFunctionName);
    }

    storyboard.stop();
    storyboard.begin();
}

SilverlightRecipes.Animator.wipeLeft = function(id, target, duration, completeFunctionName) {
    var fromRect = new SilverlightRecipes.Animator.Rectangle(target.width, target.height, 0, -target.height);
    var toRect = new SilverlightRecipes.Animator.Rectangle(target.width, target.height, -target.width, -target.height);
    var storyboard = SilverlightRecipes.Animator.createUiElementWipeAnimation(id, target, duration, fromRect, toRect);
    target.visibility = 'Visible';

    if (completeFunctionName != '') {
        storyboard.AddEventListener("Completed", completeFunctionName);
    }

    storyboard.stop();
    storyboard.begin();
}

SilverlightRecipes.Animator.createUiElementWipeAnimation = function(id, target, duration, fromRect, toRect) {
    SilverlightRecipes.Animator.__initWipeGeometry__(target, fromRect);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {
            //storyboard.duration = duration;
            return storyboard;
        }
    }
    var storyboard = target.getHost().content.createfromXaml(SilverlightRecipes.Animator.createWipeAnimationXaml(id, target.Name, duration, fromRect, toRect));
    target.resources.add(storyboard);
    return storyboard;
}

SilverlightRecipes.Animator.createWipeAnimationXaml = function(id, targetName, duration, fromRect, toRect, figureIndex) {
    if (figureIndex == null)
        figureIndex = 0;
    var secs;

    secs = duration.split(':');

    var sec = parseFloat(secs[2]) + stopDuration;
    var exDuration = SilverlightRecipes.Animator.formatDuration(sec);

    var xaml = '<Storyboard Duration="' + exDuration + '" Name="' + id + '" >';
    xaml += '<PointAnimation Duration="' + duration + '" Storyboard.TargetName="' + targetName + '" Storyboard.TargetProperty="(UIElement.Clip).(PathGeometry.Figures)[' + String(figureIndex) + '].(PathFigure.Segments)[0].(LineSegment.Point)" To="' + (toRect.left + toRect.width) + ',' + (toRect.top) + '" />';
    xaml += '<PointAnimation Duration="' + duration + '" Storyboard.TargetName="' + targetName + '" Storyboard.TargetProperty="(UIElement.Clip).(PathGeometry.Figures)[' + String(figureIndex) + '].(PathFigure.Segments)[1].(LineSegment.Point)" To="' + (toRect.left + toRect.width) + ',' + (toRect.top + toRect.height) + '" />';
    xaml += '<PointAnimation Duration="' + duration + '" Storyboard.TargetName="' + targetName + '" Storyboard.TargetProperty="(UIElement.Clip).(PathGeometry.Figures)[' + String(figureIndex) + '].(PathFigure.Segments)[2].(LineSegment.Point)" To="' + (toRect.left) + ',' + (toRect.top + toRect.height) + '" />';
    xaml += '</Storyboard>';
    return xaml;
}

SilverlightRecipes.Animator.__initWipeGeometry__ = function(target, fromRect) {
    var xaml = "<PathGeometry>";
    xaml += "<PathGeometry.Figures>";
    xaml += '<PathFigure IsClosed="True" StartPoint="' + fromRect.left + ',' + fromRect.top + '" >';
    xaml += "<PathFigure.Segments>"
    xaml += '<LineSegment Point="' + (fromRect.left + fromRect.width) + ',' + fromRect.top + '" />';
    xaml += '<LineSegment Point="' + (fromRect.left + fromRect.width) + ',' + (fromRect.top + fromRect.height) + '" />';
    xaml += '<LineSegment Point="' + (fromRect.left) + ',' + (fromRect.top + fromRect.height) + '" />';
    xaml += "</PathFigure.Segments>"
    xaml += "</PathFigure>";
    xaml += "</PathGeometry.Figures>";
    xaml += "</PathGeometry>";
    target.clip = target.getHost().content.createFromXaml(xaml);
}

SilverlightRecipes.Animator.checkerAcross = function(id, target, duration, horizontalCheckers, verticalCheckers, completeFunctionName) {
    target.visibility = 'Visible';

    SilverlightRecipes.Animator.__initCheckerGeometry__(target, horizontalCheckers, verticalCheckers, true);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }
    var storyboard = target.getHost().content.createfromXaml(SilverlightRecipes.Animator.createCheckerAnimation(id, target, duration, horizontalCheckers, verticalCheckers));
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.checkerDown = function(id, target, duration, horizontalCheckers, verticalCheckers, completeFunctionName) {
    target.visibility = 'Visible';

    SilverlightRecipes.Animator.__initCheckerGeometry__(target, horizontalCheckers, verticalCheckers, false);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {

            // storyboard.AddEventListener("Completed", completeFunctionName);
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }
    var storyboard = target.getHost().content.createfromXaml(SilverlightRecipes.Animator.createCheckerAnimation(id, target, duration, horizontalCheckers, verticalCheckers));
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.__initCheckerGeometry__ = function(target, horizontalCheckers, verticalCheckers, isAcross) {
    var checkerWidth = SilverlightRecipes.Animator.getUiElementWidth(target) / horizontalCheckers;
    var checkerHeight = SilverlightRecipes.Animator.getUiElementHeight(target) / verticalCheckers;
    var widthFactor = (isAcross) ? 0 : 1;
    var heightFactor = (!isAcross) ? 0 : 1;
    var xaml = "<PathGeometry>";
    xaml += "<PathGeometry.Figures>";
    for (i = 0; i < horizontalCheckers; i++) {
        for (j = 0; j < verticalCheckers; j++) {
            xaml += SilverlightRecipes.XamlObjectFactory.createClipAnimationRectangle('', i * checkerWidth, j * checkerHeight, checkerWidth * widthFactor, checkerHeight * heightFactor);
        }
    }
    xaml += "</PathGeometry.Figures>";
    xaml += "</PathGeometry>";
    target.clip = target.getHost().content.createFromXaml(xaml);
}

SilverlightRecipes.Animator.createCheckerAnimation = function(id, target, duration, horizontalCheckers, verticalCheckers) {
    var checkerWidth = SilverlightRecipes.Animator.getUiElementWidth(target) / horizontalCheckers;
    var checkerHeight = SilverlightRecipes.Animator.getUiElementHeight(target) / verticalCheckers;
    var evenDuration = SilverlightRecipes.Animator.formatDuration(duration / 2);
    var oddDuration = SilverlightRecipes.Animator.formatDuration(duration);

    var sec = eval(duration) + stopDuration;

    var xaml = '<Storyboard Duration="' + SilverlightRecipes.Animator.formatDuration(sec) + '" Name="' + id + '" >';
    var figureIndex = 0;
    for (i = 0; i < horizontalCheckers; i++) {
        var isOdd = false;
        for (j = 0; j < verticalCheckers; j++) {
            if (i % 2 == 1) {
                if (j % 2 == 1)
                    isOdd = false;
                else
                    isOdd = true;
            }
            else {
                if (j % 2 == 1)
                    isOdd = true;
                else
                    isOdd = false;
            }
            var toRect = new SilverlightRecipes.Animator.Rectangle(i * checkerWidth, j * checkerHeight, checkerWidth, checkerHeight);
            if (isOdd)
                xaml += SilverlightRecipes.Animator.createWipePointAnimationXaml(id, target.name, evenDuration, '00:00:00', toRect, figureIndex);
            else
                xaml += SilverlightRecipes.Animator.createWipePointAnimationXaml(id, target.name, evenDuration, evenDuration, toRect, figureIndex);
            figureIndex++;
        }
    }
    xaml += "</Storyboard>";
    return xaml;
}

SilverlightRecipes.Animator.createWipePointAnimationXaml = function(id, targetName, duration, beginTime, toRect, figureIndex) {
    var xaml = '<PointAnimation Duration="' + duration + '" BeginTime="' + beginTime + '" Storyboard.TargetName="' + targetName + '" Storyboard.TargetProperty="(UIElement.Clip).(PathGeometry.Figures)[' + String(figureIndex) + '].(PathFigure.Segments)[0].(LineSegment.Point)" To="' + (toRect.left + toRect.width) + ',' + (toRect.top) + '" />';
    xaml += '<PointAnimation Duration="' + duration + '" BeginTime="' + beginTime + '" Storyboard.TargetName="' + targetName + '" Storyboard.TargetProperty="(UIElement.Clip).(PathGeometry.Figures)[' + String(figureIndex) + '].(PathFigure.Segments)[1].(LineSegment.Point)" To="' + (toRect.left + toRect.width) + ',' + (toRect.top + toRect.height) + '" />';
    xaml += '<PointAnimation Duration="' + duration + '" BeginTime="' + beginTime + '" Storyboard.TargetName="' + targetName + '" Storyboard.TargetProperty="(UIElement.Clip).(PathGeometry.Figures)[' + String(figureIndex) + '].(PathFigure.Segments)[2].(LineSegment.Point)" To="' + (toRect.left) + ',' + (toRect.top + toRect.height) + '" />';
    return xaml;
}

SilverlightRecipes.Animator.blindsV = function(id, target, duration, blinds, completeFunctionName) {
    target.visibility = 'Visible';

    SilverlightRecipes.Animator.__initBlindsGeometry__(target, blinds, true);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {

            //storyboard.AddEventListener("Completed", completeFunctionName);
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }
    var storyboard = target.getHost().content.createfromXaml(SilverlightRecipes.Animator.createBlindsAnimation(id, target, duration, blinds, true));
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.blindsH = function(id, target, duration, blinds, completeFunctionName) {
    target.visibility = 'Visible';

    SilverlightRecipes.Animator.__initBlindsGeometry__(target, blinds, false);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }
    var storyboard = target.getHost().content.createfromXaml(SilverlightRecipes.Animator.createBlindsAnimation(id, target, duration, blinds, false));
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.__initBlindsGeometry__ = function(target, blinds, isVertical) {
    var blindWidth = (isVertical) ? SilverlightRecipes.Animator.getUiElementWidth(target) / blinds : SilverlightRecipes.Animator.getUiElementWidth(target);
    var blindHeight = (isVertical) ? SilverlightRecipes.Animator.getUiElementHeight(target) : SilverlightRecipes.Animator.getUiElementHeight(target) / blinds;
    var widthFactor = (isVertical) ? 0 : 1;
    var heightFactor = (!isVertical) ? 0 : 1;
    var xaml = "<PathGeometry>";
    xaml += "<PathGeometry.Figures>";
    for (i = 0; i < blinds; i++) {
        xaml += SilverlightRecipes.XamlObjectFactory.createClipAnimationRectangle('', i * blindWidth * heightFactor, i * blindHeight * widthFactor, blindWidth * widthFactor, blindHeight * heightFactor);
    }
    xaml += "</PathGeometry.Figures>";
    xaml += "</PathGeometry>";
    target.clip = target.getHost().content.createFromXaml(xaml);
}

SilverlightRecipes.Animator.createBlindsAnimation = function(id, target, duration, blinds, isVertical) {
    var blindWidth = (isVertical) ? SilverlightRecipes.Animator.getUiElementWidth(target) / blinds : SilverlightRecipes.Animator.getUiElementWidth(target);
    var blindHeight = (isVertical) ? SilverlightRecipes.Animator.getUiElementHeight(target) : SilverlightRecipes.Animator.getUiElementHeight(target) / blinds;
    var widthFactor = (isVertical) ? 0 : 1;
    var heightFactor = (!isVertical) ? 0 : 1;

    var sec = eval(duration) + stopDuration;

    var xaml = '<Storyboard Duration="' + SilverlightRecipes.Animator.formatDuration(sec) + '" Name="' + id + '" >';
    var figureIndex = 0;
    for (i = 0; i < blinds; i++) {
        var toRect = new SilverlightRecipes.Animator.Rectangle(i * blindWidth * heightFactor, i * blindHeight * widthFactor, blindWidth, blindHeight);
        xaml += SilverlightRecipes.Animator.createWipePointAnimationXaml(id, target.name, SilverlightRecipes.Animator.formatDuration(duration), '00:00:00', toRect, figureIndex);
        figureIndex++;
    }
    xaml += "</Storyboard>";
    return xaml;
}

SilverlightRecipes.Animator.combV = function(id, target, duration, combs, completeFunctionName) {
    target.visibility = 'Visible';

    SilverlightRecipes.Animator.__initCombGeometry__(target, combs, true);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {

            //storyboard.AddEventListener("Completed", completeFunctionName);
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }
    var storyboard = target.getHost().content.createfromXaml(SilverlightRecipes.Animator.createCombAnimation(id, target, duration, combs, true));
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.combH = function(id, target, duration, combs, completeFunctionName) {
    target.visibility = 'Visible';

    SilverlightRecipes.Animator.__initCombGeometry__(target, combs, false);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {

            //storyboard.AddEventListener("Completed", completeFunctionName);
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }
    var storyboard = target.getHost().content.createfromXaml(SilverlightRecipes.Animator.createCombAnimation(id, target, duration, combs, false));
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.__initCombGeometry__ = function(target, combs, isVertical) {
    var combWidth = (!isVertical) ? SilverlightRecipes.Animator.getUiElementWidth(target) / combs : SilverlightRecipes.Animator.getUiElementWidth(target);
    var combHeight = (!isVertical) ? SilverlightRecipes.Animator.getUiElementHeight(target) : SilverlightRecipes.Animator.getUiElementHeight(target) / combs;
    var widthFactor = (isVertical) ? 0 : 1;
    var heightFactor = (!isVertical) ? 0 : 1;
    var verticalComb = SilverlightRecipes.Animator.getUiElementWidth(target);
    var horizontalComb = SilverlightRecipes.Animator.getUiElementHeight(target);
    var xaml = "<PathGeometry>";
    xaml += "<PathGeometry.Figures>";
    for (i = 0; i < combs; i++) {
        if (i % 2 == 0)
            xaml += SilverlightRecipes.XamlObjectFactory.createClipAnimationRectangle('', i * combWidth * widthFactor, i * combHeight * heightFactor, combWidth * widthFactor, combHeight * heightFactor);
        else {
            if (isVertical)
                xaml += SilverlightRecipes.XamlObjectFactory.createClipAnimationRectangle('', verticalComb, (i * combHeight) + combHeight, 0, combHeight * -1);
            else
                xaml += SilverlightRecipes.XamlObjectFactory.createClipAnimationRectangle('', (i * combWidth) + combWidth, horizontalComb, combWidth * -1, 0);
        }
    }
    xaml += "</PathGeometry.Figures>";
    xaml += "</PathGeometry>";
    target.clip = target.getHost().content.createFromXaml(xaml);
}

SilverlightRecipes.Animator.createCombAnimation = function(id, target, duration, combs, isVertical) {
    var combWidth = (!isVertical) ? SilverlightRecipes.Animator.getUiElementWidth(target) / combs : SilverlightRecipes.Animator.getUiElementWidth(target);
    var combHeight = (!isVertical) ? SilverlightRecipes.Animator.getUiElementHeight(target) : SilverlightRecipes.Animator.getUiElementHeight(target) / combs;
    var widthFactor = (!isVertical) ? 0 : 1;
    var heightFactor = (isVertical) ? 0 : 1;
    var verticalComb = SilverlightRecipes.Animator.getUiElementWidth(target);
    var horizontalComb = SilverlightRecipes.Animator.getUiElementHeight(target);

    var sec = eval(duration) + stopDuration;

    var xaml = '<Storyboard Duration="' + SilverlightRecipes.Animator.formatDuration(sec) + '" Name="' + id + '" >';
    var figureIndex = 0;
    for (i = 0; i < combs; i++) {
        var toRect;
        if (i % 2 == 0)
            toRect = new SilverlightRecipes.Animator.Rectangle(i * combWidth * heightFactor, i * combHeight * widthFactor, combWidth, combHeight);
        else {
            if (isVertical)
                toRect = new SilverlightRecipes.Animator.Rectangle(combWidth, (i * combHeight) + combHeight, combWidth * -1, combHeight * -1);
            else
                toRect = new SilverlightRecipes.Animator.Rectangle((i * combWidth) + combWidth, horizontalComb, combWidth * -1, combHeight * -1);
        }
        xaml += SilverlightRecipes.Animator.createWipePointAnimationXaml(id, target.name, SilverlightRecipes.Animator.formatDuration(duration), '00:00:00', toRect, figureIndex);
        figureIndex++;
    }
    xaml += "</Storyboard>";
    return xaml;
}

SilverlightRecipes.Animator.getUiElementWidth = function(target) {
    var type = target.toString();
    if (type == "TextBlock")
        return target.actualWidth;
    else
        return target.width;
}

SilverlightRecipes.Animator.getUiElementHeight = function(target) {
    var type = target.toString();
    if (type == "TextBlock")
        return target.actualHeight;
    else
        return target.height;
}

SilverlightRecipes.Animator.wheel = function(id, target, duration, completeFunctionName) {
    target.visibility = 'Visible';

    var x, y;
    x = SilverlightRecipes.Animator.getUiElementWidth(target) / 2;
    y = SilverlightRecipes.Animator.getUiElementHeight(target) / 2;
    var x2 = x;
    var y2 = y;
    var clipXaml = '<PathGeometry>';
    clipXaml += '<PathGeometry.Figures>';
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2, 0);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, 0);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, 0);
    clipXaml += '</PathGeometry.Figures>';
    clipXaml += '</PathGeometry>';
    target.clip = target.getHost().content.createFromXaml(clipXaml);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {

            //storyboard.AddEventListener("Completed", completeFunctionName);
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }

    var sec = eval(duration) + stopDuration;

    var animationXaml = '<Storyboard Name="' + id + '" Duration="' + SilverlightRecipes.Animator.formatDuration(sec) + '">';
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, 0, 0, (duration / 8), 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, y2 * 2, 1, (duration / 4), (duration / 8));
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, y2 * 2, 2, (duration / 4), (duration / 8 + duration / 4));
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, 0, 3, (duration / 4), (duration / 8 + duration / 2));
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2, 0, 4, (duration / 8), (duration / 8 + (3 * duration / 4)));
    animationXaml += '</Storyboard>';
    var storyboard = target.getHost().content.createFromXaml(animationXaml);
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.wheel2 = function(id, target, duration, completeFunctionName) {
    target.visibility = 'Visible';

    var x, y;
    x = SilverlightRecipes.Animator.getUiElementWidth(target) / 2;
    y = SilverlightRecipes.Animator.getUiElementHeight(target) / 2;
    var x2 = x;
    var y2 = y;
    var clipXaml = '<PathGeometry>';
    clipXaml += '<PathGeometry.Figures>';
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2, 0);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, 0);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, 0);
    clipXaml += '</PathGeometry.Figures>';
    clipXaml += '</PathGeometry>';
    target.clip = target.getHost().content.createFromXaml(clipXaml);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {

            //storyboard.AddEventListener("Completed", completeFunctionName);
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }

    var sec = eval(duration) + stopDuration;

    var animationXaml = '<Storyboard Name="' + id + '" Duration="' + SilverlightRecipes.Animator.formatDuration(sec) + '">';
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, 0, 0, (duration / 4), 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, y2 * 2, 3, (duration / 4), 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, y2 * 2, 1, (duration / 2), (duration / 4));
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, 0, 4, (duration / 2), (duration / 4));
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2, y2 * 2, 2, (duration / 4), (duration / 4 + duration / 2));
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2, 0, 5, (duration / 4), (duration / 4 + duration / 2));
    animationXaml += '</Storyboard>';
    var storyboard = target.getHost().content.createFromXaml(animationXaml);
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.wheel4 = function(id, target, duration, completeFunctionName) {
    target.visibility = 'Visible';

    var x, y;
    x = SilverlightRecipes.Animator.getUiElementWidth(target) / 2;
    y = SilverlightRecipes.Animator.getUiElementHeight(target) / 2;
    var x2 = x;
    var y2 = y;
    var clipXaml = '<PathGeometry>';
    clipXaml += '<PathGeometry.Figures>';
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2, 0);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, 0);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, y2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, y2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, 0);
    clipXaml += '</PathGeometry.Figures>';
    clipXaml += '</PathGeometry>';
    target.clip = target.getHost().content.createFromXaml(clipXaml);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {

            //storyboard.AddEventListener("Completed", completeFunctionName);
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }

    var sec = eval(duration) + stopDuration;

    var animationXaml = '<Storyboard Name="' + id + '" Duration="' + SilverlightRecipes.Animator.formatDuration(sec) + '">';
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, 0, 0, duration / 2, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, y2 * 2, 2, duration / 2, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, y2 * 2, 4, duration / 2, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, 0, 6, duration / 2, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, y2, 1, duration / 2, duration / 2);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2, y2 * 2, 3, duration / 2, duration / 2);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, y2, 5, duration / 2, duration / 2);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2, 0, 7, duration / 2, duration / 2);
    animationXaml += '</Storyboard>';
    var storyboard = target.getHost().content.createFromXaml(animationXaml);
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.wheel8 = function(id, target, duration, completeFunctionName) {
    target.visibility = 'Visible';

    var x, y;
    x = SilverlightRecipes.Animator.getUiElementWidth(target) / 2;
    y = SilverlightRecipes.Animator.getUiElementHeight(target) / 2;
    var x2 = x;
    var y2 = y;
    var clipXaml = '<PathGeometry>';
    clipXaml += '<PathGeometry.Figures>';
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2, 0);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, 0);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, y2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2 * 2, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, x2, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, y2 * 2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, y2);
    clipXaml += SilverlightRecipes.Animator.__createWheelFigure__(x, y, 0, 0);
    clipXaml += '</PathGeometry.Figures>';
    clipXaml += '</PathGeometry>';
    target.clip = target.getHost().content.createFromXaml(clipXaml);
    for (i = 0; i < target.resources.count; i++) {
        var storyboard = target.resources.getItem(i);
        if (storyboard.name == id) {

            //storyboard.AddEventListener("Completed", completeFunctionName);
            storyboard.stop();
            storyboard.begin();
            return;
        }
    }

    var sec = eval(duration) + stopDuration;

    var animationXaml = '<Storyboard Name="' + id + '" Duration="' + SilverlightRecipes.Animator.formatDuration(sec) + '">';
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, 0, 0, duration, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, y2 * 2, 2, duration, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, y2 * 2, 4, duration, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, 0, 6, duration, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2 * 2, y2, 1, duration, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2, y2 * 2, 3, duration, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, 0, y2, 5, duration, 0);
    animationXaml += SilverlightRecipes.Animator.__createWheelPointAnimation__(target.Name, x2, 0, 7, duration, 0);
    animationXaml += '</Storyboard>';
    var storyboard = target.getHost().content.createFromXaml(animationXaml);
    target.resources.add(storyboard);

    storyboard.AddEventListener("Completed", completeFunctionName);
    storyboard.begin();
}

SilverlightRecipes.Animator.__createWheelFigure__ = function(x, y, x2, y2) {
    var xaml = '<PathFigure IsClosed="True" StartPoint="#x#, #y#">';
    xaml += '<PathFigure.Segments>';
    xaml += '<LineSegment Point="#x2#, #y2#"/>';
    xaml += '<LineSegment Point="#x2#, #y2#"/>';
    xaml += '</PathFigure.Segments>';
    xaml += '</PathFigure>';

    xaml = xaml.replace('#x#', String(x));
    xaml = xaml.replace('#y#', String(y));
    xaml = xaml.replace('#x2#', String(x2));
    xaml = xaml.replace('#x2#', String(x2));
    xaml = xaml.replace('#y2#', String(y2));
    xaml = xaml.replace('#y2#', String(y2));
    return xaml;
}

SilverlightRecipes.Animator.__createWheelPointAnimation__ = function(targetName, x, y, index, duration, begintime) {
    var xaml = '<PointAnimation BeginTime="#begintime#" Duration="#duration#" Storyboard.TargetProperty="(UIElement.Clip).(PathGeometry.Figures)[#index#].(PathFigure.Segments)[1].(LineSegment.Point)" Storyboard.TargetName="#target#" To="#x#,#y#"/>';
    xaml = xaml.replace('#begintime#', SilverlightRecipes.Animator.formatDuration(begintime));
    xaml = xaml.replace('#duration#', SilverlightRecipes.Animator.formatDuration(duration));
    xaml = xaml.replace('#index#', String(index));
    xaml = xaml.replace('#x#', String(x));
    xaml = xaml.replace('#y#', String(y));
    xaml = xaml.replace('#target#', targetName);
    return xaml;
}

SilverlightRecipes.Animator.formatDuration = function(duration) {
    var hours = String(parseInt(duration / 3600));
    var minutes = String(parseInt((duration % 3600) / 60));
    var seconds = String(parseFloat(((duration % 3600) % 60)));
    hours = (hours.length < 2) ? '0' + hours : hours;
    minutes = (minutes.length < 2) ? '0' + minutes : minutes;
    seconds = (seconds.length < 2) ? '0' + seconds : seconds;
    var format = hours + ':' + minutes + ':' + seconds;
    return format;
}

//自定
SilverlightRecipes.Animator.userControl = function(sender, duration, xaml, storyBoardXaml, completeFunctionName) {
    var storyBoard;
    var page = sender.findName("Page");
    var target;
    var temp;

    target = SilverlightRecipes.Animator.createUserControl(sender, xaml);
    storyBoard = sender.getHost().content.createfromXaml(storyBoardXaml);

    for (var i = 0; i < page.resources.count; i++) {
        temp = page.resources.getItem(i);
        if (temp.name == storyBoard.Name) {
            storyBoard.stop();
            storyBoard.begin();
            return;
        }
    }

    //storyBoard.Name = id;
    //storyBoard.RepeatBehavior = '1x';

    storyBoard.Duration = duration;

    page.resources.add(storyBoard);
    storyBoard.AddEventListener("Completed", completeFunctionName);

    storyBoard.Begin();
}

SilverlightRecipes.Animator.createUserControl = function(sender, xaml) {
    var target = sender.getHost().content.createfromXaml(xaml);
    var page = sender.findName("Page");
    var temp;

    temp = page.findName(target.Name);

    if (temp == null) {
        //target.Name = targetName;
        //target["Storyboard.TargetName"] = id;
        page.children.add(target);
    }

    return target;
}
if (!window.SilverlightRecipes)	window.SilverlightRecipes = {};
if (!window.SilverlightRecipes) window.SilverlightRecipes = {};

SilverlightRecipes.XamlObjectFactory = function(){};

//Static utility functions
//Create empty canvas
SilverlightRecipes.XamlObjectFactory.createCanvas = function(id, x, y, width, height){
    var xaml = '<Canvas #Name# #Canvas.Top# #Canvas.Left# #Width# #Height# />';
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Name', id);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Top', y);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Left', x);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Width', width);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Height', height);
    return xaml;
}

//Create rectangle
SilverlightRecipes.XamlObjectFactory.createRect = function(id, x, y, width, height, stroke, fill){
    var xaml = '<Rectangle #Name# #Canvas.Top# #Canvas.Left# #Width# #Height# #Stroke# #Fill# />';
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Name', id);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Top', y);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Left', x);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Width', width);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Height', height);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Stroke', stroke);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Fill', fill);
    return xaml;
}

//Create solid brush
SilverlightRecipes.XamlObjectFactory.createSolidBrush = function(id, color){
    var xaml = '<SolidColorBrush #Name# #Color# />';
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Name', id);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Color', color);
    return xaml;
}

//Create linear gradient brush
SilverlightRecipes.XamlObjectFactory.createLinearGradientBrush = function(id, topColor, bottomColor){
    var xaml = '<LinearGradientBrush #Name# StartPoint="0,0" EndPoint="0,1">';
    xaml += '<LinearGradientBrush.GradientStops>';
    xaml += '<GradientStop Offset="0" #Color# />';
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Name', id);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Color', topColor);
    xaml += '<GradientStop Offset="1" #Color# />';
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Color', bottomColor);
    xaml += '</LinearGradientBrush.GradientStops>';
    xaml += '</LinearGradientBrush>';
    return xaml;
}

//Create a textBlock
SilverlightRecipes.XamlObjectFactory.createTextBlock = function(id, x, y, width, height, text, fontSize, foreground, textWrapping){
    var xaml = '<TextBlock #Name# #Canvas.Top# #Canvas.Left# #Width# #Height# #Text# #FontSize# #Foreground# #TextWrapping# />';
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Name', id);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Top', y);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Left', x);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Width', width);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Height', height);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Text', text);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'FontSize', fontSize);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Foreground', foreground);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'TextWrapping', textWrapping);
    return xaml;
}

//Create image
SilverlightRecipes.XamlObjectFactory.createImage = function(id, x, y, width, height, image){
    var xaml = '<Image #Name# #Canvas.Top# #Canvas.Left# #Width# #Height# #Source# />';
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Name', id);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Top', y);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Left', x);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Width', width);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Height', height);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Source', image);
	return xaml;
}

//Create a rectangle figure using four lines
SilverlightRecipes.XamlObjectFactory.createClipAnimationRectangle = function(id, x, y, width, height){
    var xaml = '<PathFigure IsClosed="True" StartPoint="' + x + ','+ y + '" >';
    xaml += "<PathFigure.Segments>"
    xaml += '<LineSegment Point="' + (x+width) + ',' + y + '" />';
    xaml += '<LineSegment Point="' + (x+width) + ',' + (y+height) + '" />';
    xaml += '<LineSegment Point="' + (x) + ',' + (y+height) + '" />';
    xaml += "</PathFigure.Segments>"
    xaml += "</PathFigure>";
    return xaml;
}

//Create thumbnail
SilverlightRecipes.XamlObjectFactory.createThumbnail = function(id, x, y, width, height, image, url){
    var xaml = '<Canvas #Name# #Canvas.Left# #Canvas.Top# #Width# #Height# Cursor="Hand" #Tag# >';
    xaml +=  '<Rectangle Canvas.Left="0" Canvas.Top="0" Width="56" Height="44" StrokeThickness="3" RadiusX="3" RadiusY="3" Stroke="Black"/>';
    xaml +=  '<Image Canvas.Left="2" Canvas.Top="2" #Source# Width="53" Height="41" />';
    xaml += '</Canvas>';
    
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Name', id);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Top', y);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Canvas.Left', x);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Width', width);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Height', height);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Tag', url);
    xaml = SilverlightRecipes.XamlObjectFactory._setProperty(xaml, 'Source', image);
    return xaml;
}

//Private utility functions for configuring the XAML string
SilverlightRecipes.XamlObjectFactory._setProperty = function(xamlString, name, value){
    if(value && value != ""){
        return xamlString.replace('#'+name+'#', name + '="'+ value + '"');
    }
    else
        return xamlString.replace('#'+name+'#', '');
}
if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();