← Back to branch summary

~johnsca/charms/trusty/cloudfoundry/better-basic-reconciler-status

« back to all changes in this revision

Viewing changes to reconciler/ui/static/semantic/uncompressed/modules/shape.js

  • Committer: Whit Morriss
  • Date: 2014-10-13 06:50:17 UTC
  • mto: (132.2.1 reconciler) (145.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 156.
  • Revision ID: whit.morriss@canonical.com-20141013065017-0feo2ku3yllymkol
reorg reconciler

Show diffs side-by-side

added added

removed removed

Lines of Context:
reconciler/ui/static/semantic/uncompressed/modules/shape.js
 
1
/*
 
2
 * # Semantic - Shape
 
3
 * http://github.com/jlukic/semantic-ui/
 
4
 *
 
5
 *
 
6
 * Copyright 2014 Contributors
 
7
 * Released under the MIT license
 
8
 * http://opensource.org/licenses/MIT
 
9
 *
 
10
 */
 
11
 
 
12
;(function ( $, window, document, undefined ) {
 
13
 
 
14
$.fn.shape = function(parameters) {
 
15
  var
 
16
    $allModules     = $(this),
 
17
    $body           = $('body'),
 
18
 
 
19
    time            = new Date().getTime(),
 
20
    performance     = [],
 
21
 
 
22
    query           = arguments[0],
 
23
    methodInvoked   = (typeof query == 'string'),
 
24
    queryArguments  = [].slice.call(arguments, 1),
 
25
    returnedValue
 
26
  ;
 
27
 
 
28
  $allModules
 
29
    .each(function() {
 
30
      var
 
31
        moduleSelector  = $allModules.selector || '',
 
32
        settings        = $.extend(true, {}, $.fn.shape.settings, parameters),
 
33
 
 
34
        // internal aliases
 
35
        namespace     = settings.namespace,
 
36
        selector      = settings.selector,
 
37
        error         = settings.error,
 
38
        className     = settings.className,
 
39
 
 
40
        // define namespaces for modules
 
41
        eventNamespace  = '.' + namespace,
 
42
        moduleNamespace = 'module-' + namespace,
 
43
 
 
44
        // selector cache
 
45
        $module       = $(this),
 
46
        $sides        = $module.find(selector.sides),
 
47
        $side         = $module.find(selector.side),
 
48
 
 
49
        // private variables
 
50
        nextSelector = false,
 
51
        $activeSide,
 
52
        $nextSide,
 
53
 
 
54
        // standard module
 
55
        element       = this,
 
56
        instance      = $module.data(moduleNamespace),
 
57
        module
 
58
      ;
 
59
 
 
60
      module = {
 
61
 
 
62
        initialize: function() {
 
63
          module.verbose('Initializing module for', element);
 
64
          module.set.defaultSide();
 
65
          module.instantiate();
 
66
        },
 
67
 
 
68
        instantiate: function() {
 
69
          module.verbose('Storing instance of module', module);
 
70
          instance = module;
 
71
          $module
 
72
            .data(moduleNamespace, instance)
 
73
          ;
 
74
        },
 
75
 
 
76
        destroy: function() {
 
77
          module.verbose('Destroying previous module for', element);
 
78
          $module
 
79
            .removeData(moduleNamespace)
 
80
            .off(eventNamespace)
 
81
          ;
 
82
        },
 
83
 
 
84
        refresh: function() {
 
85
          module.verbose('Refreshing selector cache for', element);
 
86
          $module = $(element);
 
87
          $sides  = $(this).find(selector.shape);
 
88
          $side   = $(this).find(selector.side);
 
89
        },
 
90
 
 
91
        repaint: function() {
 
92
          module.verbose('Forcing repaint event');
 
93
          var
 
94
            shape          = $sides.get(0) || document.createElement('div'),
 
95
            fakeAssignment = shape.offsetWidth
 
96
          ;
 
97
        },
 
98
 
 
99
        animate: function(propertyObject, callback) {
 
100
          module.verbose('Animating box with properties', propertyObject);
 
101
          callback = callback || function(event) {
 
102
            module.verbose('Executing animation callback');
 
103
            if(event !== undefined) {
 
104
              event.stopPropagation();
 
105
            }
 
106
            module.reset();
 
107
            module.set.active();
 
108
          };
 
109
          $.proxy(settings.beforeChange, $nextSide[0])();
 
110
          if(module.get.transitionEvent()) {
 
111
            module.verbose('Starting CSS animation');
 
112
            $module
 
113
              .addClass(className.animating)
 
114
            ;
 
115
            module.repaint();
 
116
            $module
 
117
              .addClass(className.animating)
 
118
            ;
 
119
            $activeSide
 
120
              .addClass(className.hidden)
 
121
            ;
 
122
            $sides
 
123
              .css(propertyObject)
 
124
              .one(module.get.transitionEvent(), callback)
 
125
            ;
 
126
            module.set.duration(settings.duration);
 
127
          }
 
128
          else {
 
129
            callback();
 
130
          }
 
131
        },
 
132
 
 
133
        queue: function(method) {
 
134
          module.debug('Queueing animation of', method);
 
135
          $sides
 
136
            .one(module.get.transitionEvent(), function() {
 
137
              module.debug('Executing queued animation');
 
138
              setTimeout(function(){
 
139
                $module.shape(method);
 
140
              }, 0);
 
141
            })
 
142
          ;
 
143
        },
 
144
 
 
145
        reset: function() {
 
146
          module.verbose('Animating states reset');
 
147
          $module
 
148
            .removeClass(className.animating)
 
149
            .attr('style', '')
 
150
            .removeAttr('style')
 
151
          ;
 
152
          // removeAttr style does not consistently work in safari
 
153
          $sides
 
154
            .attr('style', '')
 
155
            .removeAttr('style')
 
156
          ;
 
157
          $side
 
158
            .attr('style', '')
 
159
            .removeAttr('style')
 
160
            .removeClass(className.hidden)
 
161
          ;
 
162
          $nextSide
 
163
            .removeClass(className.animating)
 
164
            .attr('style', '')
 
165
            .removeAttr('style')
 
166
          ;
 
167
        },
 
168
 
 
169
        is: {
 
170
          animating: function() {
 
171
            return $module.hasClass(className.animating);
 
172
          }
 
173
        },
 
174
 
 
175
        set: {
 
176
 
 
177
          defaultSide: function() {
 
178
            $activeSide = $module.find('.' + settings.className.active);
 
179
            $nextSide   = ( $activeSide.next(selector.side).size() > 0 )
 
180
              ? $activeSide.next(selector.side)
 
181
              : $module.find(selector.side).first()
 
182
            ;
 
183
            nextSelector = false;
 
184
            module.verbose('Active side set to', $activeSide);
 
185
            module.verbose('Next side set to', $nextSide);
 
186
          },
 
187
 
 
188
          duration: function(duration) {
 
189
            duration = duration || settings.duration;
 
190
            duration = (typeof duration == 'number')
 
191
              ? duration + 'ms'
 
192
              : duration
 
193
            ;
 
194
            module.verbose('Setting animation duration', duration);
 
195
            $sides.add($side)
 
196
              .css({
 
197
                '-webkit-transition-duration': duration,
 
198
                '-moz-transition-duration': duration,
 
199
                '-ms-transition-duration': duration,
 
200
                '-o-transition-duration': duration,
 
201
                'transition-duration': duration
 
202
              })
 
203
            ;
 
204
          },
 
205
 
 
206
          stageSize: function() {
 
207
            var
 
208
              $clone      = $module.clone().addClass(className.loading),
 
209
              $activeSide = $clone.find('.' + settings.className.active),
 
210
              $nextSide   = (nextSelector)
 
211
                ? $clone.find(nextSelector)
 
212
                : ( $activeSide.next(selector.side).size() > 0 )
 
213
                  ? $activeSide.next(selector.side)
 
214
                  : $clone.find(selector.side).first(),
 
215
              newSize = {}
 
216
            ;
 
217
            $activeSide.removeClass(className.active);
 
218
            $nextSide.addClass(className.active);
 
219
            $clone.prependTo($body);
 
220
            newSize = {
 
221
              width  : $nextSide.outerWidth(),
 
222
              height : $nextSide.outerHeight()
 
223
            };
 
224
            $clone.remove();
 
225
            $module
 
226
              .css(newSize)
 
227
            ;
 
228
            module.verbose('Resizing stage to fit new content', newSize);
 
229
          },
 
230
 
 
231
          nextSide: function(selector) {
 
232
            nextSelector = selector;
 
233
            $nextSide = $module.find(selector);
 
234
            if($nextSide.size() === 0) {
 
235
              module.error(error.side);
 
236
            }
 
237
            module.verbose('Next side manually set to', $nextSide);
 
238
          },
 
239
 
 
240
          active: function() {
 
241
            module.verbose('Setting new side to active', $nextSide);
 
242
            $side
 
243
              .removeClass(className.active)
 
244
            ;
 
245
            $nextSide
 
246
              .addClass(className.active)
 
247
            ;
 
248
            $.proxy(settings.onChange, $nextSide[0])();
 
249
            module.set.defaultSide();
 
250
          }
 
251
        },
 
252
 
 
253
        flip: {
 
254
 
 
255
          up: function() {
 
256
            module.debug('Flipping up', $nextSide);
 
257
            if( !module.is.animating() ) {
 
258
              module.set.stageSize();
 
259
              module.stage.above();
 
260
              module.animate( module.get.transform.up() );
 
261
            }
 
262
            else {
 
263
              module.queue('flip up');
 
264
            }
 
265
          },
 
266
 
 
267
          down: function() {
 
268
            module.debug('Flipping down', $nextSide);
 
269
            if( !module.is.animating() ) {
 
270
              module.set.stageSize();
 
271
              module.stage.below();
 
272
              module.animate( module.get.transform.down() );
 
273
            }
 
274
            else {
 
275
              module.queue('flip down');
 
276
            }
 
277
          },
 
278
 
 
279
          left: function() {
 
280
            module.debug('Flipping left', $nextSide);
 
281
            if( !module.is.animating() ) {
 
282
              module.set.stageSize();
 
283
              module.stage.left();
 
284
              module.animate(module.get.transform.left() );
 
285
            }
 
286
            else {
 
287
              module.queue('flip left');
 
288
            }
 
289
          },
 
290
 
 
291
          right: function() {
 
292
            module.debug('Flipping right', $nextSide);
 
293
            if( !module.is.animating() ) {
 
294
              module.set.stageSize();
 
295
              module.stage.right();
 
296
              module.animate(module.get.transform.right() );
 
297
            }
 
298
            else {
 
299
              module.queue('flip right');
 
300
            }
 
301
          },
 
302
 
 
303
          over: function() {
 
304
            module.debug('Flipping over', $nextSide);
 
305
            if( !module.is.animating() ) {
 
306
              module.set.stageSize();
 
307
              module.stage.behind();
 
308
              module.animate(module.get.transform.over() );
 
309
            }
 
310
            else {
 
311
              module.queue('flip over');
 
312
            }
 
313
          },
 
314
 
 
315
          back: function() {
 
316
            module.debug('Flipping back', $nextSide);
 
317
            if( !module.is.animating() ) {
 
318
              module.set.stageSize();
 
319
              module.stage.behind();
 
320
              module.animate(module.get.transform.back() );
 
321
            }
 
322
            else {
 
323
              module.queue('flip back');
 
324
            }
 
325
          }
 
326
 
 
327
        },
 
328
 
 
329
        get: {
 
330
 
 
331
          transform: {
 
332
            up: function() {
 
333
              var
 
334
                translate = {
 
335
                  y: -(($activeSide.outerHeight() - $nextSide.outerHeight()) / 2),
 
336
                  z: -($activeSide.outerHeight() / 2)
 
337
                }
 
338
              ;
 
339
              return {
 
340
                transform: 'translateY(' + translate.y + 'px) translateZ('+ translate.z + 'px) rotateX(-90deg)'
 
341
              };
 
342
            },
 
343
 
 
344
            down: function() {
 
345
              var
 
346
                translate = {
 
347
                  y: -(($activeSide.outerHeight() - $nextSide.outerHeight()) / 2),
 
348
                  z: -($activeSide.outerHeight() / 2)
 
349
                }
 
350
              ;
 
351
              return {
 
352
                transform: 'translateY(' + translate.y + 'px) translateZ('+ translate.z + 'px) rotateX(90deg)'
 
353
              };
 
354
            },
 
355
 
 
356
            left: function() {
 
357
              var
 
358
                translate = {
 
359
                  x : -(($activeSide.outerWidth() - $nextSide.outerWidth()) / 2),
 
360
                  z : -($activeSide.outerWidth() / 2)
 
361
                }
 
362
              ;
 
363
              return {
 
364
                transform: 'translateX(' + translate.x + 'px) translateZ(' + translate.z + 'px) rotateY(90deg)'
 
365
              };
 
366
            },
 
367
 
 
368
            right: function() {
 
369
              var
 
370
                translate = {
 
371
                  x : -(($activeSide.outerWidth() - $nextSide.outerWidth()) / 2),
 
372
                  z : -($activeSide.outerWidth() / 2)
 
373
                }
 
374
              ;
 
375
              return {
 
376
                transform: 'translateX(' + translate.x + 'px) translateZ(' + translate.z + 'px) rotateY(-90deg)'
 
377
              };
 
378
            },
 
379
 
 
380
            over: function() {
 
381
              var
 
382
                translate = {
 
383
                  x : -(($activeSide.outerWidth() - $nextSide.outerWidth()) / 2)
 
384
                }
 
385
              ;
 
386
              return {
 
387
                transform: 'translateX(' + translate.x + 'px) rotateY(180deg)'
 
388
              };
 
389
            },
 
390
 
 
391
            back: function() {
 
392
              var
 
393
                translate = {
 
394
                  x : -(($activeSide.outerWidth() - $nextSide.outerWidth()) / 2)
 
395
                }
 
396
              ;
 
397
              return {
 
398
                transform: 'translateX(' + translate.x + 'px) rotateY(-180deg)'
 
399
              };
 
400
            }
 
401
          },
 
402
 
 
403
          transitionEvent: function() {
 
404
            var
 
405
              element     = document.createElement('element'),
 
406
              transitions = {
 
407
                'transition'       :'transitionend',
 
408
                'OTransition'      :'oTransitionEnd',
 
409
                'MozTransition'    :'transitionend',
 
410
                'WebkitTransition' :'webkitTransitionEnd'
 
411
              },
 
412
              transition
 
413
            ;
 
414
            for(transition in transitions){
 
415
              if( element.style[transition] !== undefined ){
 
416
                return transitions[transition];
 
417
              }
 
418
            }
 
419
          },
 
420
 
 
421
          nextSide: function() {
 
422
            return ( $activeSide.next(selector.side).size() > 0 )
 
423
              ? $activeSide.next(selector.side)
 
424
              : $module.find(selector.side).first()
 
425
            ;
 
426
          }
 
427
 
 
428
        },
 
429
 
 
430
        stage: {
 
431
 
 
432
          above: function() {
 
433
            var
 
434
              box = {
 
435
                origin : (($activeSide.outerHeight() - $nextSide.outerHeight()) / 2),
 
436
                depth  : {
 
437
                  active : ($nextSide.outerHeight() / 2),
 
438
                  next   : ($activeSide.outerHeight() / 2)
 
439
                }
 
440
              }
 
441
            ;
 
442
            module.verbose('Setting the initial animation position as above', $nextSide, box);
 
443
            $activeSide
 
444
              .css({
 
445
                'transform' : 'rotateY(0deg) translateZ(' + box.depth.active + 'px)'
 
446
              })
 
447
            ;
 
448
            $nextSide
 
449
              .addClass(className.animating)
 
450
              .css({
 
451
                'display'   : 'block',
 
452
                'top'       : box.origin + 'px',
 
453
                'transform' : 'rotateX(90deg) translateZ(' + box.depth.next + 'px)'
 
454
              })
 
455
            ;
 
456
          },
 
457
 
 
458
          below: function() {
 
459
            var
 
460
              box = {
 
461
                origin : (($activeSide.outerHeight() - $nextSide.outerHeight()) / 2),
 
462
                depth  : {
 
463
                  active : ($nextSide.outerHeight() / 2),
 
464
                  next   : ($activeSide.outerHeight() / 2)
 
465
                }
 
466
              }
 
467
            ;
 
468
            module.verbose('Setting the initial animation position as below', $nextSide, box);
 
469
            $activeSide
 
470
              .css({
 
471
                'transform' : 'rotateY(0deg) translateZ(' + box.depth.active + 'px)'
 
472
              })
 
473
            ;
 
474
            $nextSide
 
475
              .addClass(className.animating)
 
476
              .css({
 
477
                'display'   : 'block',
 
478
                'top'       : box.origin + 'px',
 
479
                'transform' : 'rotateX(-90deg) translateZ(' + box.depth.next + 'px)'
 
480
              })
 
481
            ;
 
482
          },
 
483
 
 
484
          left: function() {
 
485
            var
 
486
              box = {
 
487
                origin : ( ( $activeSide.outerWidth() - $nextSide.outerWidth() ) / 2),
 
488
                depth  : {
 
489
                  active : ($nextSide.outerWidth() / 2),
 
490
                  next   : ($activeSide.outerWidth() / 2)
 
491
                }
 
492
              }
 
493
            ;
 
494
            module.verbose('Setting the initial animation position as left', $nextSide, box);
 
495
            $activeSide
 
496
              .css({
 
497
                'transform' : 'rotateY(0deg) translateZ(' + box.depth.active + 'px)'
 
498
              })
 
499
            ;
 
500
            $nextSide
 
501
              .addClass(className.animating)
 
502
              .css({
 
503
                'display'   : 'block',
 
504
                'left'      : box.origin + 'px',
 
505
                'transform' : 'rotateY(-90deg) translateZ(' + box.depth.next + 'px)'
 
506
              })
 
507
            ;
 
508
          },
 
509
 
 
510
          right: function() {
 
511
            var
 
512
              box = {
 
513
                origin : ( ( $activeSide.outerWidth() - $nextSide.outerWidth() ) / 2),
 
514
                depth  : {
 
515
                  active : ($nextSide.outerWidth() / 2),
 
516
                  next   : ($activeSide.outerWidth() / 2)
 
517
                }
 
518
              }
 
519
            ;
 
520
            module.verbose('Setting the initial animation position as left', $nextSide, box);
 
521
            $activeSide
 
522
              .css({
 
523
                'transform' : 'rotateY(0deg) translateZ(' + box.depth.active + 'px)'
 
524
              })
 
525
            ;
 
526
            $nextSide
 
527
              .addClass(className.animating)
 
528
              .css({
 
529
                'display'   : 'block',
 
530
                'left'      : box.origin + 'px',
 
531
                'transform' : 'rotateY(90deg) translateZ(' + box.depth.next + 'px)'
 
532
              })
 
533
            ;
 
534
          },
 
535
 
 
536
          behind: function() {
 
537
            var
 
538
              box = {
 
539
                origin : ( ( $activeSide.outerWidth() - $nextSide.outerWidth() ) / 2),
 
540
                depth  : {
 
541
                  active : ($nextSide.outerWidth() / 2),
 
542
                  next   : ($activeSide.outerWidth() / 2)
 
543
                }
 
544
              }
 
545
            ;
 
546
            module.verbose('Setting the initial animation position as behind', $nextSide, box);
 
547
            $activeSide
 
548
              .css({
 
549
                'transform' : 'rotateY(0deg)'
 
550
              })
 
551
            ;
 
552
            $nextSide
 
553
              .addClass(className.animating)
 
554
              .css({
 
555
                'display'   : 'block',
 
556
                'left'      : box.origin + 'px',
 
557
                'transform' : 'rotateY(-180deg)'
 
558
              })
 
559
            ;
 
560
          }
 
561
        },
 
562
        setting: function(name, value) {
 
563
          if( $.isPlainObject(name) ) {
 
564
            $.extend(true, settings, name);
 
565
          }
 
566
          else if(value !== undefined) {
 
567
            settings[name] = value;
 
568
          }
 
569
          else {
 
570
            return settings[name];
 
571
          }
 
572
        },
 
573
        internal: function(name, value) {
 
574
          if( $.isPlainObject(name) ) {
 
575
            $.extend(true, module, name);
 
576
          }
 
577
          else if(value !== undefined) {
 
578
            module[name] = value;
 
579
          }
 
580
          else {
 
581
            return module[name];
 
582
          }
 
583
        },
 
584
        debug: function() {
 
585
          if(settings.debug) {
 
586
            if(settings.performance) {
 
587
              module.performance.log(arguments);
 
588
            }
 
589
            else {
 
590
              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
 
591
              module.debug.apply(console, arguments);
 
592
            }
 
593
          }
 
594
        },
 
595
        verbose: function() {
 
596
          if(settings.verbose && settings.debug) {
 
597
            if(settings.performance) {
 
598
              module.performance.log(arguments);
 
599
            }
 
600
            else {
 
601
              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
 
602
              module.verbose.apply(console, arguments);
 
603
            }
 
604
          }
 
605
        },
 
606
        error: function() {
 
607
          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
 
608
          module.error.apply(console, arguments);
 
609
        },
 
610
        performance: {
 
611
          log: function(message) {
 
612
            var
 
613
              currentTime,
 
614
              executionTime,
 
615
              previousTime
 
616
            ;
 
617
            if(settings.performance) {
 
618
              currentTime   = new Date().getTime();
 
619
              previousTime  = time || currentTime;
 
620
              executionTime = currentTime - previousTime;
 
621
              time          = currentTime;
 
622
              performance.push({
 
623
                'Element'        : element,
 
624
                'Name'           : message[0],
 
625
                'Arguments'      : [].slice.call(message, 1) || '',
 
626
                'Execution Time' : executionTime
 
627
              });
 
628
            }
 
629
            clearTimeout(module.performance.timer);
 
630
            module.performance.timer = setTimeout(module.performance.display, 100);
 
631
          },
 
632
          display: function() {
 
633
            var
 
634
              title = settings.name + ':',
 
635
              totalTime = 0
 
636
            ;
 
637
            time = false;
 
638
            clearTimeout(module.performance.timer);
 
639
            $.each(performance, function(index, data) {
 
640
              totalTime += data['Execution Time'];
 
641
            });
 
642
            title += ' ' + totalTime + 'ms';
 
643
            if(moduleSelector) {
 
644
              title += ' \'' + moduleSelector + '\'';
 
645
            }
 
646
            if($allModules.size() > 1) {
 
647
              title += ' ' + '(' + $allModules.size() + ')';
 
648
            }
 
649
            if( (console.group !== undefined || console.table !== undefined) && performance.length > 0) {
 
650
              console.groupCollapsed(title);
 
651
              if(console.table) {
 
652
                console.table(performance);
 
653
              }
 
654
              else {
 
655
                $.each(performance, function(index, data) {
 
656
                  console.log(data['Name'] + ': ' + data['Execution Time']+'ms');
 
657
                });
 
658
              }
 
659
              console.groupEnd();
 
660
            }
 
661
            performance = [];
 
662
          }
 
663
        },
 
664
        invoke: function(query, passedArguments, context) {
 
665
          var
 
666
            object = instance,
 
667
            maxDepth,
 
668
            found,
 
669
            response
 
670
          ;
 
671
          passedArguments = passedArguments || queryArguments;
 
672
          context         = element         || context;
 
673
          if(typeof query == 'string' && object !== undefined) {
 
674
            query    = query.split(/[\. ]/);
 
675
            maxDepth = query.length - 1;
 
676
            $.each(query, function(depth, value) {
 
677
              var camelCaseValue = (depth != maxDepth)
 
678
                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
 
679
                : query
 
680
              ;
 
681
              if( $.isPlainObject( object[camelCaseValue] ) && (depth != maxDepth) ) {
 
682
                object = object[camelCaseValue];
 
683
              }
 
684
              else if( object[camelCaseValue] !== undefined ) {
 
685
                found = object[camelCaseValue];
 
686
                return false;
 
687
              }
 
688
              else if( $.isPlainObject( object[value] ) && (depth != maxDepth) ) {
 
689
                object = object[value];
 
690
              }
 
691
              else if( object[value] !== undefined ) {
 
692
                found = object[value];
 
693
                return false;
 
694
              }
 
695
              else {
 
696
                return false;
 
697
              }
 
698
            });
 
699
          }
 
700
          if ( $.isFunction( found ) ) {
 
701
            response = found.apply(context, passedArguments);
 
702
          }
 
703
          else if(found !== undefined) {
 
704
            response = found;
 
705
          }
 
706
          if($.isArray(returnedValue)) {
 
707
            returnedValue.push(response);
 
708
          }
 
709
          else if(returnedValue !== undefined) {
 
710
            returnedValue = [returnedValue, response];
 
711
          }
 
712
          else if(response !== undefined) {
 
713
            returnedValue = response;
 
714
          }
 
715
          return found;
 
716
        }
 
717
      };
 
718
 
 
719
      if(methodInvoked) {
 
720
        if(instance === undefined) {
 
721
          module.initialize();
 
722
        }
 
723
        module.invoke(query);
 
724
      }
 
725
      else {
 
726
        if(instance !== undefined) {
 
727
          module.destroy();
 
728
        }
 
729
        module.initialize();
 
730
      }
 
731
    })
 
732
  ;
 
733
 
 
734
  return (returnedValue !== undefined)
 
735
    ? returnedValue
 
736
    : this
 
737
  ;
 
738
};
 
739
 
 
740
$.fn.shape.settings = {
 
741
 
 
742
  // module info
 
743
  name : 'Shape',
 
744
 
 
745
  // debug content outputted to console
 
746
  debug      : false,
 
747
 
 
748
  // verbose debug output
 
749
  verbose    : true,
 
750
 
 
751
  // performance data output
 
752
  performance: true,
 
753
 
 
754
  // event namespace
 
755
  namespace  : 'shape',
 
756
 
 
757
  // callback occurs on side change
 
758
  beforeChange : function() {},
 
759
  onChange     : function() {},
 
760
 
 
761
  // animation duration
 
762
  duration   : 700,
 
763
 
 
764
  // possible errors
 
765
  error: {
 
766
    side   : 'You tried to switch to a side that does not exist.',
 
767
    method : 'The method you called is not defined'
 
768
  },
 
769
 
 
770
  // classnames used
 
771
  className   : {
 
772
    animating : 'animating',
 
773
    hidden    : 'hidden',
 
774
    loading   : 'loading',
 
775
    active    : 'active'
 
776
  },
 
777
 
 
778
  // selectors used
 
779
  selector    : {
 
780
    sides : '.sides',
 
781
    side  : '.side'
 
782
  }
 
783
 
 
784
};
 
785
 
 
786
 
 
787
})( jQuery, window , document );
 
 
b'\\ No newline at end of file'