www/plugins-dist/compagnon/prive/javascript/jquery.twinkle.js

   1 /* jQuery.twinkle 0.8.0 - http://larsjung.de/jquery-twinkle/ */
   2 (function () {
   3 'use strict';
   4
   5 var $ = jQuery;
   6
   7 var defaults = {
   8         widthRatio: 0.5,
   9         heightRatio: 0.5,
  10         delay: 0,
  11         gap: 0,
  12         effect: 'splash',
  13         effectOptions: undefined,
  14         callback: undefined
  15     };
  16
  17 var stopDefaults = {
  18         id: undefined,
  19         effectOptions: undefined,
  20         callback: undefined
  21     };
  22
  23
  24 function TwinkleEvent(offX, offY, element, posX, posY) {
  25
  26     this.offset = {left: offX, top: offY};
  27     this.element = element;
  28     this.position = {left: posX, top: posY};
  29 }
  30
  31
  32 function StopEvent(element) {
  33
  34     this.element = element;
  35 }
  36
  37
  38 function Twinkler() {
  39
  40     var effects = {};
  41     var running = {}; // element => {id: handle}
  42
  43     function effectStarted(element, id, handle) {}
  44     function effectStopped(element, id) {}
  45
  46     this.add = function (effect) {
  47
  48         if (!effects[effect.id]) {
  49             effects[effect.id] = effect;
  50         }
  51         return this;
  52     };
  53
  54     this.remove = function (effect) {
  55
  56         if (effects[effect]) {
  57             delete effects[effect];
  58         } else if (effect.id && effects[effect.id]) {
  59             delete effects[effect.id];
  60         }
  61         return this;
  62     };
  63
  64     this.twinkle = function (event, options) {
  65
  66         var settings = $.extend({}, defaults, options);
  67         var effect = effects[settings.effect];
  68
  69         if (effect) {
  70             event.element = event.element || 'body';
  71             effect.run(event, settings.effectOptions, function () {
  72
  73                 if ($.isFunction(settings.callback)) {
  74                     settings.callback();
  75                 }
  76             });
  77         }
  78         return this;
  79     };
  80
  81     this.stop = function (event, options) {
  82
  83         var settings = $.extend({}, stopDefaults, options);
  84         var effect = effects[settings.effect];
  85
  86         if (effect) {
  87             event.element = event.element || 'body';
  88             effect.stop(event, settings.effectOptions, settings.callback);
  89         }
  90         return this;
  91     };
  92
  93     this.twinkleAtElement = function (htmlElement, options) {
  94
  95         var settings = $.extend({}, defaults, options);
  96         var $htmlElement = $(htmlElement);
  97         var offset = $htmlElement.offset();
  98         var position = $htmlElement.position();
  99         var width = $htmlElement.outerWidth(true);
 100         var height = $htmlElement.outerHeight(true);
 101         var offX = offset.left + width * settings.widthRatio;
 102         var offY = offset.top + height * settings.heightRatio;
 103         var posX = position.left + width * settings.widthRatio;
 104         var posY = position.top + height * settings.heightRatio;
 105
 106         return this.twinkle(new TwinkleEvent(offX, offY, htmlElement, posX, posY), options);
 107     };
 108
 109     this.twinkleAtElements = function (htmlElements, options) {
 110
 111         var self = this;
 112         var settings = $.extend({}, defaults, options);
 113         var delay = settings.delay;
 114         var $htmlElements = $(htmlElements);
 115         var size = $htmlElements.size();
 116
 117         $htmlElements.each(function (idx) {
 118
 119             var htmlElement = this;
 120             var opts = $.extend({}, options);
 121
 122             if (idx !== size - 1) {
 123                 delete opts.callback;
 124             }
 125
 126             setTimeout(function () {
 127                 self.twinkleAtElement(htmlElement, opts);
 128             }, delay);
 129
 130             delay += settings.gap;
 131         });
 132         return this;
 133     };
 134
 135     this.stopAtElement = function (htmlElement, options) {
 136
 137         var settings = $.extend({}, defaults, options);
 138         var $htmlElement = $(htmlElement);
 139         var offset = $htmlElement.offset();
 140         var position = $htmlElement.position();
 141         var width = $htmlElement.outerWidth(true);
 142         var height = $htmlElement.outerHeight(true);
 143         var offX = offset.left + width * settings.widthRatio;
 144         var offY = offset.top + height * settings.heightRatio;
 145         var posX = position.left + width * settings.widthRatio;
 146         var posY = position.top + height * settings.heightRatio;
 147
 148         return this.twinkle(new TwinkleEvent(offX, offY, htmlElement, posX, posY), options);
 149     };
 150
 151     this.stopAtElements = function (htmlElements, options) {
 152
 153         var self = this;
 154         var settings = $.extend({}, stopDefaults, options);
 155         var delay = settings.delay;
 156         var $htmlElements = $(htmlElements);
 157         var size = $htmlElements.size();
 158
 159         $htmlElements.each(function (idx) {
 160
 161             var htmlElement = this,
 162                 opts = $.extend({}, options);
 163
 164             if (idx !== size - 1) {
 165                 delete opts.callback;
 166             }
 167
 168             self.stopAtElement(htmlElement, opts);
 169         });
 170         return this;
 171     };
 172 }
 173
 174
 175
 176 /*!
 177 modplug 1.0
 178 http://larsjung.de/modplug
 179 MIT License
 180 */
 181
 182 // This function is ment to be copied into your plugin file as a local
 183 // variable.
 184 //
 185 // `modplug` expects a string `namespace` and a configuration object
 186 // `options`.
 187 //
 188 //      options = {
 189 //          statics: hash of functions,
 190 //          methods: hash of functions,
 191 //          defaultStatic: String/function,
 192 //          defaultMethod: String/function
 193 //      }
 194 //
 195 // For more details see <http://larsjung.de/modplug>.
 196 var modplug = function (namespace, options) {
 197         'use strict';
 198         /*global jQuery: true */
 199
 200                 // Some references to enhance minification.
 201         var slice = [].slice,
 202                 $ = jQuery,
 203                 extend = $.extend,
 204                 isFn = $.isFunction,
 205
 206                 // Save the initial settings.
 207                 settings = extend({}, options),
 208
 209                 // Helper function to apply default methods.
 210                 applyMethod = function (obj, args, methodName, methods) {
 211
 212                         // If `methodName` is a function apply it to get the actual
 213                         // method name.
 214                         methodName = isFn(methodName) ? methodName.apply(obj, args) : methodName;
 215
 216                         // If method exists then apply it and return the result ...
 217                         if (isFn(methods[methodName])) {
 218                                 return methods[methodName].apply(obj, args);
 219                         }
 220
 221                         // ... otherwise raise an error.
 222                         $.error('Method "' + methodName + '" does not exist on jQuery.' + namespace);
 223                 },
 224
 225                 // This function gets exposed as `$.<namespace>`.
 226                 statics = function () {
 227
 228                         // Try to apply a default method.
 229                         return applyMethod(this, slice.call(arguments), settings.defaultStatic, statics);
 230                 },
 231
 232                 // This function gets exposed as `$(selector).<namespace>`.
 233                 methods = function (method) {
 234
 235                         // If `method` exists then apply it ...
 236                         if (isFn(methods[method])) {
 237                                 return methods[method].apply(this, slice.call(arguments, 1));
 238                         }
 239
 240                         // ... otherwise try to apply a default method.
 241                         return applyMethod(this, slice.call(arguments), settings.defaultMethod, methods);
 242                 },
 243
 244                 // Adds/overwrites plugin methods. This function gets exposed as
 245                 // `$.<namespace>.modplug` to make the plugin extendable.
 246                 plug = function (options) {
 247
 248                         if (options) {
 249                                 extend(statics, options.statics);
 250                                 extend(methods, options.methods);
 251                         }
 252
 253                         // Make sure that `$.<namespace>.modplug` points to this function
 254                         // after adding new methods.
 255                         statics.modplug = plug;
 256                 };
 257
 258         // Save objects or methods previously registered to the desired namespace.
 259         // They are available via `$.<namespace>.modplug.prev`.
 260         plug.prev = {
 261                 statics: $[namespace],
 262                 methods: $.fn[namespace]
 263         };
 264
 265         // Init the plugin by adding the specified statics and methods.
 266         plug(options);
 267
 268         // Register the plugin.
 269         $[namespace] = statics;
 270         $.fn[namespace] = methods;
 271 };
 272
 273
 274 var twinkler = new Twinkler();
 275 modplug('twinkle', {
 276     statics: {
 277         twinkle: function (element, left, top, options) {
 278
 279             twinkler.twinkle(new TwinkleEvent(0, 0, element, left, top), options);
 280             return this;
 281         },
 282         add: function (effect) {
 283
 284             twinkler.add(effect);
 285             return this;
 286         },
 287         remove: function (effect) {
 288
 289             twinkler.remove(effect);
 290             return this;
 291         }
 292     },
 293     methods: {
 294         twinkle: function (options) {
 295
 296             twinkler.twinkleAtElements(this, options);
 297             return this;
 298         },
 299         stop: function (options) {
 300
 301             twinkler.stopAtElements(this, options);
 302             return this;
 303         }
 304     },
 305     defaultStatic: 'twinkle',
 306     defaultMethod: 'twinkle'
 307 });
 308
 309 }());
 310
 311 (function () {
 312 'use strict';
 313 /* CSS Effects */
 314
 315 var $ = jQuery;
 316
 317 function blockEvents(event) {
 318
 319     event.stopImmediatePropagation();
 320     event.preventDefault();
 321     return false;
 322 }
 323
 324 function animation(css, event, settings, callback) {
 325
 326     var $dot;
 327
 328     function cleanUp() {
 329
 330         $dot.remove();
 331         if (callback instanceof Function) {
 332             callback();
 333         }
 334     }
 335
 336     function fadeOut() {
 337
 338         $dot.animate(
 339             {
 340                 left: event.position.left - settings.radius,
 341                 top: event.position.top - settings.radius,
 342                 width: settings.radius * 2,
 343                 height: settings.radius * 2,
 344                 opacity: 0
 345             },
 346             settings.duration * 0.5,
 347             'linear',
 348             cleanUp
 349         );
 350     }
 351
 352     function fadeIn() {
 353
 354         $dot = $('<div />')
 355                 .css(css)
 356                 .on('click dblclick mousedown mouseenter mouseover mousemove', blockEvents);
 357         $(event.element).after($dot);
 358         $dot.animate(
 359             {
 360                 left: event.position.left - settings.radius * 0.5,
 361                 top: event.position.top - settings.radius * 0.5,
 362                 width: settings.radius,
 363                 height: settings.radius,
 364                 opacity: 1
 365             },
 366             settings.duration * 0.5,
 367             'linear',
 368             fadeOut
 369         );
 370     }
 371
 372     function stop() {}
 373
 374     fadeIn();
 375
 376     return {
 377         stop: stop
 378     };
 379 }
 380
 381 var splashDefaults = {
 382         color: 'rgba(255,0,0,0.5)',
 383         radius: 300,
 384         duration: 1000
 385     };
 386
 387 function SplashEffect() {
 388
 389     this.id = 'splash-css';
 390
 391     this.run = function (event, options, callback) {
 392
 393         var settings = $.extend({}, splashDefaults, options);
 394         var css = {
 395                 position: 'absolute',
 396                 zIndex: 1000,
 397                 display: 'block',
 398                 borderRadius: settings.radius,
 399                 backgroundColor: settings.color,
 400                 boxShadow: '0 0 30px ' + settings.color,
 401                 left: event.position.left,
 402                 top: event.position.top,
 403                 width: 0,
 404                 height: 0,
 405                 opacity: 0.4
 406             };
 407
 408         animation(css, event, settings, callback);
 409     };
 410 }
 411
 412 var dropsDefaults = {
 413         color: 'rgba(255,0,0,0.5)',
 414         radius: 300,
 415         duration: 1000,
 416         width: 2,
 417         count: 3,
 418         delay: 300
 419     };
 420
 421 function DropsEffect() {
 422
 423     this.id = 'drops-css';
 424
 425     this.run = function (event, options, callback) {
 426
 427         var settings = $.extend({}, dropsDefaults, options);
 428         var css = {
 429                 position: 'absolute',
 430                 zIndex: 1000,
 431                 display: 'block',
 432                 borderRadius: settings.radius,
 433                 border: settings.width + 'px solid ' + settings.color,
 434                 left: event.position.left,
 435                 top: event.position.top,
 436                 width: 0,
 437                 height: 0,
 438                 opacity: 0.4
 439             };
 440
 441         function setTimer(delay, callback) {
 442             setTimeout(function () {
 443                 animation(css, event, settings, callback);
 444             }, delay);
 445         }
 446
 447         var delay = 0;
 448         var i;
 449
 450         for (i = 0; i < settings.count; i += 1) {
 451             setTimer(delay, i === settings.count - 1 ? callback : undefined);
 452             delay += settings.delay;
 453         }
 454     };
 455 }
 456
 457 function DropEffect() {
 458
 459     var drops = new DropsEffect();
 460
 461     this.id = 'drop-css';
 462
 463     this.run = function (event, options, callback) {
 464
 465         drops.run(event, $.extend(options, { count: 1 }), callback);
 466     };
 467 }
 468
 469 $.twinkle.add(new SplashEffect()).add(new DropEffect()).add(new DropsEffect());
 470
 471 }());
 472
 473 (function () {
 474 'use strict';
 475 /* Canvas Effects */
 476
 477 var $ = jQuery;
 478 var Objects = {};
 479
 480 (function () {
 481
 482 function Interpolator(values) {
 483
 484     var points;
 485
 486     function equiDist(values) {
 487
 488         var dist = 1 / (values.length - 1);
 489         var points = [];
 490         var i;
 491
 492         for (i = 0; i < values.length; i += 1) {
 493             points.push({ x: dist * i , y: values[i] });
 494         }
 495         return points;
 496     }
 497
 498     function interpolate(p1, p2, x) {
 499
 500         var m = (p2.y - p1.y) / (p2.x - p1.x);
 501         var y = p1.y + m * (x - p1.x);
 502
 503         return y;
 504     }
 505
 506     function findSection(x) {
 507
 508         var i, prev, current;
 509
 510         for (i = 1; i < points.length; i += 1) {
 511             prev = points[i-1];
 512             current = points[i];
 513             if (x >= prev.x && x <= current.x) {
 514                 return [ prev, current ];
 515             }
 516         }
 517
 518         return undefined;
 519     }
 520
 521     points = equiDist(values);
 522
 523     this.get = function (x) {
 524
 525         var secPts;
 526
 527         x = Math.max(0, Math.min(1, x));
 528         secPts = findSection(x);
 529         return interpolate(secPts[0], secPts[1], x);
 530     };
 531 }
 532
 533 function scaleit(x, scale, offset) {
 534
 535     scale = scale || 1;
 536     offset = offset || 0;
 537     x = (x - offset) / scale;
 538     return x >= 0 && x <= 1 ? x : undefined;
 539 }
 540
 541 Objects.Interpolator = Interpolator;
 542 Objects.Interpolator.scale =  scaleit;
 543
 544 }());
 545
 546 (function () {
 547
 548 var $ = jQuery;
 549
 550 function Path(ctx) {
 551
 552     var context = ctx.getContext();
 553
 554     context.beginPath();
 555
 556     this.fill = function (fillStyle) {
 557
 558         context.fillStyle = fillStyle;
 559         context.fill();
 560         return ctx;
 561     };
 562
 563     this.stroke = function (lineWidth, strokeStyle) {
 564
 565         context.lineWidth = lineWidth;
 566         context.strokeStyle = strokeStyle;
 567         context.stroke();
 568         return ctx;
 569     };
 570
 571     this.draw = function (lineWidth, strokeStyle, fillStyle) {
 572
 573         this.fill(fillStyle);
 574         this.stroke(lineWidth, strokeStyle);
 575         return ctx;
 576     };
 577
 578     this.circle = function (x, y, radius) {
 579
 580         context.arc(x, y, radius, 0, 2 * Math.PI, false);
 581         return this;
 582     };
 583 }
 584
 585 function Ctx(context) {
 586
 587     if (!context || !context.canvas) {
 588         return undefined;
 589     } else if (!(this instanceof Ctx)) {
 590         return new Ctx(context);
 591     }
 592
 593     var width = $(context.canvas).width();
 594     var height = $(context.canvas).height();
 595
 596     this.getContext = function () {
 597
 598         return context;
 599     };
 600
 601     this.getWidth = function () {
 602
 603         return width;
 604     };
 605
 606     this.getHeight = function () {
 607
 608         return height;
 609     };
 610
 611     this.clear = function () {
 612
 613         this.resetTransform();
 614         context.clearRect(0, 0, width, height);
 615         return this;
 616     };
 617
 618     this.resetTransform = function () {
 619
 620         context.setTransform(1, 0, 0, 1, 0, 0);
 621         return this;
 622     };
 623
 624     this.translate = function (x, y) {
 625
 626         context.translate(x, y);
 627         return this;
 628     };
 629
 630     this.rotate = function (alpha) {
 631
 632         context.rotate(Math.PI * alpha / 180);
 633         return this;
 634     };
 635
 636     this.opacity = function (opacity) {
 637
 638         context.globalAlpha = opacity;
 639         return this;
 640     };
 641
 642     this.path = function () {
 643
 644         return new Path(this);
 645     };
 646 }
 647
 648 Objects.Ctx = Ctx;
 649
 650 }());
 651
 652 (function () {
 653
 654 function CanvasEffect(twinkleEvent, width, height, frame, callback) {
 655
 656     if (!(this instanceof Objects.CanvasEffect)) {
 657         return new Objects.CanvasEffect(twinkleEvent, width, height, frame, callback);
 658     }
 659
 660     var element = twinkleEvent.element;
 661     var x = twinkleEvent.position.left;
 662     var y = twinkleEvent.position.top;
 663     var css = {
 664             position: 'absolute',
 665             zIndex: 1000,
 666             display: 'block',
 667             left: x - width * 0.5,
 668             top: y - height * 0.5,
 669             width: width,
 670             height: height
 671         };
 672
 673     this.run = function (duration, fps) {
 674
 675         var $canvas, ctx, i;
 676         var frameCount = duration / 1000 * fps;
 677         var delta = 1 / frameCount;
 678
 679         function setFrameTimer(fraction) {
 680
 681             setTimeout(function () {
 682
 683                 if (ctx) {
 684                     frame({
 685                         ctx: ctx,
 686                         frac: fraction,
 687                         millis: duration * fraction
 688                     });
 689                 }
 690             }, duration * fraction);
 691         }
 692
 693         function cleanUp() {
 694
 695             $canvas.remove();
 696             $canvas = undefined;
 697             ctx = undefined;
 698             if (callback instanceof Function) {
 699                 callback();
 700             }
 701         }
 702
 703         function blockEvents(event) {
 704
 705             event.stopImmediatePropagation();
 706             event.preventDefault();
 707             return false;
 708         }
 709
 710         $canvas = jQuery('<canvas />').attr('width', width).attr('height', height).css(css);
 711         jQuery(element).after($canvas);
 712         $canvas.on('click dblclick mousedown mouseenter mouseover mousemove', blockEvents);
 713         ctx = new Objects.Ctx($canvas.get(0).getContext('2d'));
 714
 715         for (i = 0; i <= frameCount; i += 1) {
 716             setFrameTimer(i * delta);
 717         }
 718
 719         setTimeout(cleanUp, duration);
 720     };
 721 }
 722
 723 Objects.CanvasEffect = CanvasEffect;
 724
 725 }());
 726
 727 (function () {
 728
 729 var $ = jQuery;
 730
 731 var defaults = {
 732         color: 'rgba(255,0,0,0.5)',
 733         radius: 300,
 734         duration: 1000
 735     };
 736
 737 function SplashEffect() {
 738
 739     this.id = 'splash';
 740
 741     this.run = function (twinkleEvent, options, callback) {
 742
 743         var settings = $.extend({}, defaults, options);
 744         var size = settings.radius * 2;
 745         var opacityIpl = new Objects.Interpolator([ 0.4, 1, 0 ]);
 746         var radiusIpl = new Objects.Interpolator([ 0, settings.radius ]);
 747
 748         function frame(frameEvent) {
 749
 750             var radius = radiusIpl.get(frameEvent.frac);
 751             var opacity = opacityIpl.get(frameEvent.frac);
 752             var ctx = frameEvent.ctx;
 753
 754             ctx
 755                 .clear()
 756                 .opacity(opacity)
 757                 .path()
 758                 .circle(ctx.getWidth() * 0.5, ctx.getHeight() * 0.5, radius)
 759                 .fill(settings.color);
 760         }
 761
 762         new Objects.CanvasEffect(twinkleEvent, size, size, frame, callback).run(settings.duration, 25);
 763     };
 764 }
 765
 766 $.twinkle.add(new SplashEffect());
 767
 768 }());
 769
 770 (function () {
 771
 772 var $ = jQuery;
 773
 774 var defaults = {
 775         color: 'rgba(255,0,0,0.5)',
 776         radius: 300,
 777         duration: 1000,
 778         width: 2
 779     };
 780
 781 function DropEffect() {
 782
 783     this.id = 'drop';
 784
 785     this.run = function (twinkleEvent, options, callback) {
 786
 787         var settings = $.extend({}, defaults, options);
 788         var size = settings.radius * 2;
 789         var opacityIpl = new Objects.Interpolator([ 0.4, 1, 0 ]);
 790         var radiusIpl = new Objects.Interpolator([ 0, settings.radius ]);
 791
 792         function frame(frameEvent) {
 793
 794             var radius = radiusIpl.get(frameEvent.frac);
 795             var opacity = opacityIpl.get(frameEvent.frac);
 796             var ctx = frameEvent.ctx;
 797
 798             ctx
 799                 .clear()
 800                 .opacity(opacity)
 801                 .path()
 802                 .circle(ctx.getWidth() * 0.5, ctx.getHeight() * 0.5, radius)
 803                 .stroke(settings.width, settings.color);
 804         }
 805
 806         new Objects.CanvasEffect(twinkleEvent, size, size, frame, callback).run(settings.duration, 25);
 807     };
 808 }
 809
 810 $.twinkle.add(new DropEffect());
 811
 812 }());
 813
 814 (function () {
 815
 816 var $ = jQuery;
 817
 818 var defaults = {
 819         color: 'rgba(255,0,0,0.5)',
 820         radius: 300,
 821         duration: 1000,
 822         width: 2,
 823         count: 3,
 824         delay: 100
 825     };
 826
 827 function DropsEffect() {
 828
 829     this.id = 'drops';
 830
 831     this.run = function (twinkleEvent, options, callback) {
 832
 833         var settings = $.extend({}, defaults, options);
 834         var size = settings.radius * 2;
 835         var opacityIpl = new Objects.Interpolator([ 0.4, 1, 0 ]);
 836         var radiusIpl = new Objects.Interpolator([ 0, settings.radius ]);
 837         var scale = (settings.duration - (settings.count - 1) * settings.delay) / settings.duration;
 838         var offset = settings.delay / settings.duration;
 839
 840         function frame(frameEvent) {
 841
 842             var i, frac, radius, opacity;
 843             var ctx = frameEvent.ctx;
 844             var width = ctx.getWidth();
 845             var height = ctx.getHeight();
 846
 847             ctx.clear();
 848             for (i = 0; i < settings.count; i += 1) {
 849                 frac = Objects.Interpolator.scale(frameEvent.frac, scale, offset * i);
 850
 851                 if (frac !== undefined) {
 852                     radius = radiusIpl.get(frac);
 853                     opacity = opacityIpl.get(frac);
 854                     ctx
 855                         .opacity(opacity)
 856                         .path()
 857                         .circle(width * 0.5, height * 0.5, radius)
 858                         .stroke(settings.width, settings.color);
 859                 }
 860             }
 861         }
 862
 863         new Objects.CanvasEffect(twinkleEvent, size, size, frame, callback).run(settings.duration, 25);
 864     };
 865 }
 866
 867 $.twinkle.add(new DropsEffect());
 868
 869 }());
 870
 871 (function () {
 872
 873 var $ = jQuery;
 874
 875 var defaults = {
 876         color: 'rgba(255,0,0,0.5)',
 877         radius: 100,
 878         duration: 3000
 879     };
 880
 881 function PulseEffect() {
 882
 883     this.id = 'pulse';
 884
 885     this.run = function (twinkleEvent, options, callback) {
 886
 887         var settings = $.extend({}, defaults, options);
 888         var size = settings.radius * 2;
 889         var opacityIpl = new Objects.Interpolator([ 0, 1, 0.6, 1, 0.6, 1, 0 ]);
 890         var radiusIpl = new Objects.Interpolator([ 0, settings.radius, settings.radius * 0.6, settings.radius, settings.radius * 0.6, settings.radius, 0 ]);
 891
 892         function frame(frameEvent) {
 893
 894             var radius = radiusIpl.get(frameEvent.frac),
 895                 opacity = opacityIpl.get(frameEvent.frac),
 896                 ctx = frameEvent.ctx;
 897
 898             ctx
 899                 .clear()
 900                 .opacity(opacity)
 901                 .path()
 902                 .circle(ctx.getWidth() * 0.5, ctx.getHeight() * 0.5, radius)
 903                 .fill(settings.color);
 904         }
 905
 906         new Objects.CanvasEffect(twinkleEvent, size, size, frame, callback).run(settings.duration, 25);
 907     };
 908 }
 909
 910 $.twinkle.add(new PulseEffect());
 911
 912 }());
 913
 914 (function () {
 915
 916 var $ = jQuery;
 917
 918 var defaults = {
 919         color: 'rgba(255,0,0,0.5)',
 920         radius: 100,
 921         duration: 3000,
 922         satellites: 10,
 923         satellitesRadius: 10,
 924         circulations: 1.5
 925     };
 926
 927 function OrbitEffect() {
 928
 929     this.id = 'orbit';
 930
 931     this.run = function (twinkleEvent, options, callback) {
 932
 933         var settings = $.extend({}, defaults, options);
 934         var size = settings.radius * 2;
 935         var opacityIpl = new Objects.Interpolator([ 0.4, 1, 1, 0.4 ]);
 936         var r = settings.radius - settings.satellitesRadius;
 937         var radiusIpl = new Objects.Interpolator([ 0, r, r, 0 ]);
 938
 939         function frame(frameEvent) {
 940
 941             var radius = radiusIpl.get(frameEvent.frac);
 942             var opacity = opacityIpl.get(frameEvent.frac);
 943             var bog = Math.PI * 2 * settings.circulations * frameEvent.frac;
 944             var ctx = frameEvent.ctx;
 945             var path, i, x, y;
 946
 947             ctx
 948                 .clear()
 949                 .opacity(opacity)
 950                 .translate(ctx.getWidth() * 0.5, ctx.getHeight() * 0.5);
 951
 952             path = ctx.path();
 953             for (i = 0; i < settings.satellites; i += 1) {
 954                 bog += Math.PI * 2 / settings.satellites;
 955                 x = Math.cos(bog) * radius;
 956                 y = Math.sin(bog) * radius;
 957                 ctx.getContext().moveTo(x, y);
 958                 path.circle(x, y, settings.satellitesRadius);
 959             }
 960             path.fill(settings.color);
 961         }
 962
 963         new Objects.CanvasEffect(twinkleEvent, size, size, frame, callback).run(settings.duration, 25);
 964     };
 965 }
 966
 967 $.twinkle.add(new OrbitEffect());
 968
 969 }());
 970
 971 }());
 972