← Back to branch summary

~mga/openerp-india/openerpbook

« back to all changes in this revision

Viewing changes to build/html/_static/bootstrap-3.1.0/js/bootstrap.js

  • Committer: Mantavya Gajjar
  • Date: 2014-03-28 12:22:54 UTC
  • Revision ID: mga@tinyerp.com-20140328122254-bh9qa0anqhraa5af
[ADD]: add new pages and rebuild

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/html/_static/bootstrap-3.1.0/js/bootstrap.js
 
1
/*!
 
2
 * Bootstrap v3.1.0 (http://getbootstrap.com)
 
3
 * Copyright 2011-2014 Twitter, Inc.
 
4
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
5
 */
 
6
 
 
7
if (typeof jQuery === 'undefined') { throw new Error('Bootstrap requires jQuery') }
 
8
 
 
9
/* ========================================================================
 
10
 * Bootstrap: transition.js v3.1.0
 
11
 * http://getbootstrap.com/javascript/#transitions
 
12
 * ========================================================================
 
13
 * Copyright 2011-2014 Twitter, Inc.
 
14
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
15
 * ======================================================================== */
 
16
 
 
17
 
 
18
+function ($) {
 
19
  'use strict';
 
20
 
 
21
  // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
 
22
  // ============================================================
 
23
 
 
24
  function transitionEnd() {
 
25
    var el = document.createElement('bootstrap')
 
26
 
 
27
    var transEndEventNames = {
 
28
      'WebkitTransition' : 'webkitTransitionEnd',
 
29
      'MozTransition'    : 'transitionend',
 
30
      'OTransition'      : 'oTransitionEnd otransitionend',
 
31
      'transition'       : 'transitionend'
 
32
    }
 
33
 
 
34
    for (var name in transEndEventNames) {
 
35
      if (el.style[name] !== undefined) {
 
36
        return { end: transEndEventNames[name] }
 
37
      }
 
38
    }
 
39
 
 
40
    return false // explicit for ie8 (  ._.)
 
41
  }
 
42
 
 
43
  // http://blog.alexmaccaw.com/css-transitions
 
44
  $.fn.emulateTransitionEnd = function (duration) {
 
45
    var called = false, $el = this
 
46
    $(this).one($.support.transition.end, function () { called = true })
 
47
    var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
 
48
    setTimeout(callback, duration)
 
49
    return this
 
50
  }
 
51
 
 
52
  $(function () {
 
53
    $.support.transition = transitionEnd()
 
54
  })
 
55
 
 
56
}(window.$jqTheme||window.jQuery);
 
57
 
 
58
/* ========================================================================
 
59
 * Bootstrap: alert.js v3.1.0
 
60
 * http://getbootstrap.com/javascript/#alerts
 
61
 * ========================================================================
 
62
 * Copyright 2011-2014 Twitter, Inc.
 
63
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
64
 * ======================================================================== */
 
65
 
 
66
 
 
67
+function ($) {
 
68
  'use strict';
 
69
 
 
70
  // ALERT CLASS DEFINITION
 
71
  // ======================
 
72
 
 
73
  var dismiss = '[data-dismiss="alert"]'
 
74
  var Alert   = function (el) {
 
75
    $(el).on('click', dismiss, this.close)
 
76
  }
 
77
 
 
78
  Alert.prototype.close = function (e) {
 
79
    var $this    = $(this)
 
80
    var selector = $this.attr('data-target')
 
81
 
 
82
    if (!selector) {
 
83
      selector = $this.attr('href')
 
84
      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
 
85
    }
 
86
 
 
87
    var $parent = $(selector)
 
88
 
 
89
    if (e) e.preventDefault()
 
90
 
 
91
    if (!$parent.length) {
 
92
      $parent = $this.hasClass('alert') ? $this : $this.parent()
 
93
    }
 
94
 
 
95
    $parent.trigger(e = $.Event('close.bs.alert'))
 
96
 
 
97
    if (e.isDefaultPrevented()) return
 
98
 
 
99
    $parent.removeClass('in')
 
100
 
 
101
    function removeElement() {
 
102
      $parent.trigger('closed.bs.alert').remove()
 
103
    }
 
104
 
 
105
    $.support.transition && $parent.hasClass('fade') ?
 
106
      $parent
 
107
        .one($.support.transition.end, removeElement)
 
108
        .emulateTransitionEnd(150) :
 
109
      removeElement()
 
110
  }
 
111
 
 
112
 
 
113
  // ALERT PLUGIN DEFINITION
 
114
  // =======================
 
115
 
 
116
  var old = $.fn.alert
 
117
 
 
118
  $.fn.alert = function (option) {
 
119
    return this.each(function () {
 
120
      var $this = $(this)
 
121
      var data  = $this.data('bs.alert')
 
122
 
 
123
      if (!data) $this.data('bs.alert', (data = new Alert(this)))
 
124
      if (typeof option == 'string') data[option].call($this)
 
125
    })
 
126
  }
 
127
 
 
128
  $.fn.alert.Constructor = Alert
 
129
 
 
130
 
 
131
  // ALERT NO CONFLICT
 
132
  // =================
 
133
 
 
134
  $.fn.alert.noConflict = function () {
 
135
    $.fn.alert = old
 
136
    return this
 
137
  }
 
138
 
 
139
 
 
140
  // ALERT DATA-API
 
141
  // ==============
 
142
 
 
143
  $(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)
 
144
 
 
145
}(window.$jqTheme||window.jQuery);
 
146
 
 
147
/* ========================================================================
 
148
 * Bootstrap: button.js v3.1.0
 
149
 * http://getbootstrap.com/javascript/#buttons
 
150
 * ========================================================================
 
151
 * Copyright 2011-2014 Twitter, Inc.
 
152
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
153
 * ======================================================================== */
 
154
 
 
155
 
 
156
+function ($) {
 
157
  'use strict';
 
158
 
 
159
  // BUTTON PUBLIC CLASS DEFINITION
 
160
  // ==============================
 
161
 
 
162
  var Button = function (element, options) {
 
163
    this.$element  = $(element)
 
164
    this.options   = $.extend({}, Button.DEFAULTS, options)
 
165
    this.isLoading = false
 
166
  }
 
167
 
 
168
  Button.DEFAULTS = {
 
169
    loadingText: 'loading...'
 
170
  }
 
171
 
 
172
  Button.prototype.setState = function (state) {
 
173
    var d    = 'disabled'
 
174
    var $el  = this.$element
 
175
    var val  = $el.is('input') ? 'val' : 'html'
 
176
    var data = $el.data()
 
177
 
 
178
    state = state + 'Text'
 
179
 
 
180
    if (!data.resetText) $el.data('resetText', $el[val]())
 
181
 
 
182
    $el[val](data[state] || this.options[state])
 
183
 
 
184
    // push to event loop to allow forms to submit
 
185
    setTimeout($.proxy(function () {
 
186
      if (state == 'loadingText') {
 
187
        this.isLoading = true
 
188
        $el.addClass(d).attr(d, d)
 
189
      } else if (this.isLoading) {
 
190
        this.isLoading = false
 
191
        $el.removeClass(d).removeAttr(d)
 
192
      }
 
193
    }, this), 0)
 
194
  }
 
195
 
 
196
  Button.prototype.toggle = function () {
 
197
    var changed = true
 
198
    var $parent = this.$element.closest('[data-toggle="buttons"]')
 
199
 
 
200
    if ($parent.length) {
 
201
      var $input = this.$element.find('input')
 
202
      if ($input.prop('type') == 'radio') {
 
203
        if ($input.prop('checked') && this.$element.hasClass('active')) changed = false
 
204
        else $parent.find('.active').removeClass('active')
 
205
      }
 
206
      if (changed) $input.prop('checked', !this.$element.hasClass('active')).trigger('change')
 
207
    }
 
208
 
 
209
    if (changed) this.$element.toggleClass('active')
 
210
  }
 
211
 
 
212
 
 
213
  // BUTTON PLUGIN DEFINITION
 
214
  // ========================
 
215
 
 
216
  var old = $.fn.button
 
217
 
 
218
  $.fn.button = function (option) {
 
219
    return this.each(function () {
 
220
      var $this   = $(this)
 
221
      var data    = $this.data('bs.button')
 
222
      var options = typeof option == 'object' && option
 
223
 
 
224
      if (!data) $this.data('bs.button', (data = new Button(this, options)))
 
225
 
 
226
      if (option == 'toggle') data.toggle()
 
227
      else if (option) data.setState(option)
 
228
    })
 
229
  }
 
230
 
 
231
  $.fn.button.Constructor = Button
 
232
 
 
233
 
 
234
  // BUTTON NO CONFLICT
 
235
  // ==================
 
236
 
 
237
  $.fn.button.noConflict = function () {
 
238
    $.fn.button = old
 
239
    return this
 
240
  }
 
241
 
 
242
 
 
243
  // BUTTON DATA-API
 
244
  // ===============
 
245
 
 
246
  $(document).on('click.bs.button.data-api', '[data-toggle^=button]', function (e) {
 
247
    var $btn = $(e.target)
 
248
    if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')
 
249
    $btn.button('toggle')
 
250
    e.preventDefault()
 
251
  })
 
252
 
 
253
}(window.$jqTheme||window.jQuery);
 
254
 
 
255
/* ========================================================================
 
256
 * Bootstrap: carousel.js v3.1.0
 
257
 * http://getbootstrap.com/javascript/#carousel
 
258
 * ========================================================================
 
259
 * Copyright 2011-2014 Twitter, Inc.
 
260
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
261
 * ======================================================================== */
 
262
 
 
263
 
 
264
+function ($) {
 
265
  'use strict';
 
266
 
 
267
  // CAROUSEL CLASS DEFINITION
 
268
  // =========================
 
269
 
 
270
  var Carousel = function (element, options) {
 
271
    this.$element    = $(element)
 
272
    this.$indicators = this.$element.find('.carousel-indicators')
 
273
    this.options     = options
 
274
    this.paused      =
 
275
    this.sliding     =
 
276
    this.interval    =
 
277
    this.$active     =
 
278
    this.$items      = null
 
279
 
 
280
    this.options.pause == 'hover' && this.$element
 
281
      .on('mouseenter', $.proxy(this.pause, this))
 
282
      .on('mouseleave', $.proxy(this.cycle, this))
 
283
  }
 
284
 
 
285
  Carousel.DEFAULTS = {
 
286
    interval: 5000,
 
287
    pause: 'hover',
 
288
    wrap: true
 
289
  }
 
290
 
 
291
  Carousel.prototype.cycle =  function (e) {
 
292
    e || (this.paused = false)
 
293
 
 
294
    this.interval && clearInterval(this.interval)
 
295
 
 
296
    this.options.interval
 
297
      && !this.paused
 
298
      && (this.interval = setInterval($.proxy(this.next, this), this.options.interval))
 
299
 
 
300
    return this
 
301
  }
 
302
 
 
303
  Carousel.prototype.getActiveIndex = function () {
 
304
    this.$active = this.$element.find('.item.active')
 
305
    this.$items  = this.$active.parent().children()
 
306
 
 
307
    return this.$items.index(this.$active)
 
308
  }
 
309
 
 
310
  Carousel.prototype.to = function (pos) {
 
311
    var that        = this
 
312
    var activeIndex = this.getActiveIndex()
 
313
 
 
314
    if (pos > (this.$items.length - 1) || pos < 0) return
 
315
 
 
316
    if (this.sliding)       return this.$element.one('slid.bs.carousel', function () { that.to(pos) })
 
317
    if (activeIndex == pos) return this.pause().cycle()
 
318
 
 
319
    return this.slide(pos > activeIndex ? 'next' : 'prev', $(this.$items[pos]))
 
320
  }
 
321
 
 
322
  Carousel.prototype.pause = function (e) {
 
323
    e || (this.paused = true)
 
324
 
 
325
    if (this.$element.find('.next, .prev').length && $.support.transition) {
 
326
      this.$element.trigger($.support.transition.end)
 
327
      this.cycle(true)
 
328
    }
 
329
 
 
330
    this.interval = clearInterval(this.interval)
 
331
 
 
332
    return this
 
333
  }
 
334
 
 
335
  Carousel.prototype.next = function () {
 
336
    if (this.sliding) return
 
337
    return this.slide('next')
 
338
  }
 
339
 
 
340
  Carousel.prototype.prev = function () {
 
341
    if (this.sliding) return
 
342
    return this.slide('prev')
 
343
  }
 
344
 
 
345
  Carousel.prototype.slide = function (type, next) {
 
346
    var $active   = this.$element.find('.item.active')
 
347
    var $next     = next || $active[type]()
 
348
    var isCycling = this.interval
 
349
    var direction = type == 'next' ? 'left' : 'right'
 
350
    var fallback  = type == 'next' ? 'first' : 'last'
 
351
    var that      = this
 
352
 
 
353
    if (!$next.length) {
 
354
      if (!this.options.wrap) return
 
355
      $next = this.$element.find('.item')[fallback]()
 
356
    }
 
357
 
 
358
    if ($next.hasClass('active')) return this.sliding = false
 
359
 
 
360
    var e = $.Event('slide.bs.carousel', { relatedTarget: $next[0], direction: direction })
 
361
    this.$element.trigger(e)
 
362
    if (e.isDefaultPrevented()) return
 
363
 
 
364
    this.sliding = true
 
365
 
 
366
    isCycling && this.pause()
 
367
 
 
368
    if (this.$indicators.length) {
 
369
      this.$indicators.find('.active').removeClass('active')
 
370
      this.$element.one('slid.bs.carousel', function () {
 
371
        var $nextIndicator = $(that.$indicators.children()[that.getActiveIndex()])
 
372
        $nextIndicator && $nextIndicator.addClass('active')
 
373
      })
 
374
    }
 
375
 
 
376
    if ($.support.transition && this.$element.hasClass('slide')) {
 
377
      $next.addClass(type)
 
378
      $next[0].offsetWidth // force reflow
 
379
      $active.addClass(direction)
 
380
      $next.addClass(direction)
 
381
      $active
 
382
        .one($.support.transition.end, function () {
 
383
          $next.removeClass([type, direction].join(' ')).addClass('active')
 
384
          $active.removeClass(['active', direction].join(' '))
 
385
          that.sliding = false
 
386
          setTimeout(function () { that.$element.trigger('slid.bs.carousel') }, 0)
 
387
        })
 
388
        .emulateTransitionEnd($active.css('transition-duration').slice(0, -1) * 1000)
 
389
    } else {
 
390
      $active.removeClass('active')
 
391
      $next.addClass('active')
 
392
      this.sliding = false
 
393
      this.$element.trigger('slid.bs.carousel')
 
394
    }
 
395
 
 
396
    isCycling && this.cycle()
 
397
 
 
398
    return this
 
399
  }
 
400
 
 
401
 
 
402
  // CAROUSEL PLUGIN DEFINITION
 
403
  // ==========================
 
404
 
 
405
  var old = $.fn.carousel
 
406
 
 
407
  $.fn.carousel = function (option) {
 
408
    return this.each(function () {
 
409
      var $this   = $(this)
 
410
      var data    = $this.data('bs.carousel')
 
411
      var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)
 
412
      var action  = typeof option == 'string' ? option : options.slide
 
413
 
 
414
      if (!data) $this.data('bs.carousel', (data = new Carousel(this, options)))
 
415
      if (typeof option == 'number') data.to(option)
 
416
      else if (action) data[action]()
 
417
      else if (options.interval) data.pause().cycle()
 
418
    })
 
419
  }
 
420
 
 
421
  $.fn.carousel.Constructor = Carousel
 
422
 
 
423
 
 
424
  // CAROUSEL NO CONFLICT
 
425
  // ====================
 
426
 
 
427
  $.fn.carousel.noConflict = function () {
 
428
    $.fn.carousel = old
 
429
    return this
 
430
  }
 
431
 
 
432
 
 
433
  // CAROUSEL DATA-API
 
434
  // =================
 
435
 
 
436
  $(document).on('click.bs.carousel.data-api', '[data-slide], [data-slide-to]', function (e) {
 
437
    var $this   = $(this), href
 
438
    var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) //strip for ie7
 
439
    var options = $.extend({}, $target.data(), $this.data())
 
440
    var slideIndex = $this.attr('data-slide-to')
 
441
    if (slideIndex) options.interval = false
 
442
 
 
443
    $target.carousel(options)
 
444
 
 
445
    if (slideIndex = $this.attr('data-slide-to')) {
 
446
      $target.data('bs.carousel').to(slideIndex)
 
447
    }
 
448
 
 
449
    e.preventDefault()
 
450
  })
 
451
 
 
452
  $(window).on('load', function () {
 
453
    $('[data-ride="carousel"]').each(function () {
 
454
      var $carousel = $(this)
 
455
      $carousel.carousel($carousel.data())
 
456
    })
 
457
  })
 
458
 
 
459
}(window.$jqTheme||window.jQuery);
 
460
 
 
461
/* ========================================================================
 
462
 * Bootstrap: collapse.js v3.1.0
 
463
 * http://getbootstrap.com/javascript/#collapse
 
464
 * ========================================================================
 
465
 * Copyright 2011-2014 Twitter, Inc.
 
466
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
467
 * ======================================================================== */
 
468
 
 
469
 
 
470
+function ($) {
 
471
  'use strict';
 
472
 
 
473
  // COLLAPSE PUBLIC CLASS DEFINITION
 
474
  // ================================
 
475
 
 
476
  var Collapse = function (element, options) {
 
477
    this.$element      = $(element)
 
478
    this.options       = $.extend({}, Collapse.DEFAULTS, options)
 
479
    this.transitioning = null
 
480
 
 
481
    if (this.options.parent) this.$parent = $(this.options.parent)
 
482
    if (this.options.toggle) this.toggle()
 
483
  }
 
484
 
 
485
  Collapse.DEFAULTS = {
 
486
    toggle: true
 
487
  }
 
488
 
 
489
  Collapse.prototype.dimension = function () {
 
490
    var hasWidth = this.$element.hasClass('width')
 
491
    return hasWidth ? 'width' : 'height'
 
492
  }
 
493
 
 
494
  Collapse.prototype.show = function () {
 
495
    if (this.transitioning || this.$element.hasClass('in')) return
 
496
 
 
497
    var startEvent = $.Event('show.bs.collapse')
 
498
    this.$element.trigger(startEvent)
 
499
    if (startEvent.isDefaultPrevented()) return
 
500
 
 
501
    var actives = this.$parent && this.$parent.find('> .panel > .in')
 
502
 
 
503
    if (actives && actives.length) {
 
504
      var hasData = actives.data('bs.collapse')
 
505
      if (hasData && hasData.transitioning) return
 
506
      actives.collapse('hide')
 
507
      hasData || actives.data('bs.collapse', null)
 
508
    }
 
509
 
 
510
    var dimension = this.dimension()
 
511
 
 
512
    this.$element
 
513
      .removeClass('collapse')
 
514
      .addClass('collapsing')
 
515
      [dimension](0)
 
516
 
 
517
    this.transitioning = 1
 
518
 
 
519
    var complete = function () {
 
520
      this.$element
 
521
        .removeClass('collapsing')
 
522
        .addClass('collapse in')
 
523
        [dimension]('auto')
 
524
      this.transitioning = 0
 
525
      this.$element.trigger('shown.bs.collapse')
 
526
    }
 
527
 
 
528
    if (!$.support.transition) return complete.call(this)
 
529
 
 
530
    var scrollSize = $.camelCase(['scroll', dimension].join('-'))
 
531
 
 
532
    this.$element
 
533
      .one($.support.transition.end, $.proxy(complete, this))
 
534
      .emulateTransitionEnd(350)
 
535
      [dimension](this.$element[0][scrollSize])
 
536
  }
 
537
 
 
538
  Collapse.prototype.hide = function () {
 
539
    if (this.transitioning || !this.$element.hasClass('in')) return
 
540
 
 
541
    var startEvent = $.Event('hide.bs.collapse')
 
542
    this.$element.trigger(startEvent)
 
543
    if (startEvent.isDefaultPrevented()) return
 
544
 
 
545
    var dimension = this.dimension()
 
546
 
 
547
    this.$element
 
548
      [dimension](this.$element[dimension]())
 
549
      [0].offsetHeight
 
550
 
 
551
    this.$element
 
552
      .addClass('collapsing')
 
553
      .removeClass('collapse')
 
554
      .removeClass('in')
 
555
 
 
556
    this.transitioning = 1
 
557
 
 
558
    var complete = function () {
 
559
      this.transitioning = 0
 
560
      this.$element
 
561
        .trigger('hidden.bs.collapse')
 
562
        .removeClass('collapsing')
 
563
        .addClass('collapse')
 
564
    }
 
565
 
 
566
    if (!$.support.transition) return complete.call(this)
 
567
 
 
568
    this.$element
 
569
      [dimension](0)
 
570
      .one($.support.transition.end, $.proxy(complete, this))
 
571
      .emulateTransitionEnd(350)
 
572
  }
 
573
 
 
574
  Collapse.prototype.toggle = function () {
 
575
    this[this.$element.hasClass('in') ? 'hide' : 'show']()
 
576
  }
 
577
 
 
578
 
 
579
  // COLLAPSE PLUGIN DEFINITION
 
580
  // ==========================
 
581
 
 
582
  var old = $.fn.collapse
 
583
 
 
584
  $.fn.collapse = function (option) {
 
585
    return this.each(function () {
 
586
      var $this   = $(this)
 
587
      var data    = $this.data('bs.collapse')
 
588
      var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)
 
589
 
 
590
      if (!data && options.toggle && option == 'show') option = !option
 
591
      if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))
 
592
      if (typeof option == 'string') data[option]()
 
593
    })
 
594
  }
 
595
 
 
596
  $.fn.collapse.Constructor = Collapse
 
597
 
 
598
 
 
599
  // COLLAPSE NO CONFLICT
 
600
  // ====================
 
601
 
 
602
  $.fn.collapse.noConflict = function () {
 
603
    $.fn.collapse = old
 
604
    return this
 
605
  }
 
606
 
 
607
 
 
608
  // COLLAPSE DATA-API
 
609
  // =================
 
610
 
 
611
  $(document).on('click.bs.collapse.data-api', '[data-toggle=collapse]', function (e) {
 
612
    var $this   = $(this), href
 
613
    var target  = $this.attr('data-target')
 
614
        || e.preventDefault()
 
615
        || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') //strip for ie7
 
616
    var $target = $(target)
 
617
    var data    = $target.data('bs.collapse')
 
618
    var option  = data ? 'toggle' : $this.data()
 
619
    var parent  = $this.attr('data-parent')
 
620
    var $parent = parent && $(parent)
 
621
 
 
622
    if (!data || !data.transitioning) {
 
623
      if ($parent) $parent.find('[data-toggle=collapse][data-parent="' + parent + '"]').not($this).addClass('collapsed')
 
624
      $this[$target.hasClass('in') ? 'addClass' : 'removeClass']('collapsed')
 
625
    }
 
626
 
 
627
    $target.collapse(option)
 
628
  })
 
629
 
 
630
}(window.$jqTheme||window.jQuery);
 
631
 
 
632
/* ========================================================================
 
633
 * Bootstrap: dropdown.js v3.1.0
 
634
 * http://getbootstrap.com/javascript/#dropdowns
 
635
 * ========================================================================
 
636
 * Copyright 2011-2014 Twitter, Inc.
 
637
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
638
 * ======================================================================== */
 
639
 
 
640
 
 
641
+function ($) {
 
642
  'use strict';
 
643
 
 
644
  // DROPDOWN CLASS DEFINITION
 
645
  // =========================
 
646
 
 
647
  var backdrop = '.dropdown-backdrop'
 
648
  var toggle   = '[data-toggle=dropdown]'
 
649
  var Dropdown = function (element) {
 
650
    $(element).on('click.bs.dropdown', this.toggle)
 
651
  }
 
652
 
 
653
  Dropdown.prototype.toggle = function (e) {
 
654
    var $this = $(this)
 
655
 
 
656
    if ($this.is('.disabled, :disabled')) return
 
657
 
 
658
    var $parent  = getParent($this)
 
659
    var isActive = $parent.hasClass('open')
 
660
 
 
661
    clearMenus()
 
662
 
 
663
    if (!isActive) {
 
664
      if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {
 
665
        // if mobile we use a backdrop because click events don't delegate
 
666
        $('<div class="dropdown-backdrop"/>').insertAfter($(this)).on('click', clearMenus)
 
667
      }
 
668
 
 
669
      var relatedTarget = { relatedTarget: this }
 
670
      $parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))
 
671
 
 
672
      if (e.isDefaultPrevented()) return
 
673
 
 
674
      $parent
 
675
        .toggleClass('open')
 
676
        .trigger('shown.bs.dropdown', relatedTarget)
 
677
 
 
678
      $this.focus()
 
679
    }
 
680
 
 
681
    return false
 
682
  }
 
683
 
 
684
  Dropdown.prototype.keydown = function (e) {
 
685
    if (!/(38|40|27)/.test(e.keyCode)) return
 
686
 
 
687
    var $this = $(this)
 
688
 
 
689
    e.preventDefault()
 
690
    e.stopPropagation()
 
691
 
 
692
    if ($this.is('.disabled, :disabled')) return
 
693
 
 
694
    var $parent  = getParent($this)
 
695
    var isActive = $parent.hasClass('open')
 
696
 
 
697
    if (!isActive || (isActive && e.keyCode == 27)) {
 
698
      if (e.which == 27) $parent.find(toggle).focus()
 
699
      return $this.click()
 
700
    }
 
701
 
 
702
    var desc = ' li:not(.divider):visible a'
 
703
    var $items = $parent.find('[role=menu]' + desc + ', [role=listbox]' + desc)
 
704
 
 
705
    if (!$items.length) return
 
706
 
 
707
    var index = $items.index($items.filter(':focus'))
 
708
 
 
709
    if (e.keyCode == 38 && index > 0)                 index--                        // up
 
710
    if (e.keyCode == 40 && index < $items.length - 1) index++                        // down
 
711
    if (!~index)                                      index = 0
 
712
 
 
713
    $items.eq(index).focus()
 
714
  }
 
715
 
 
716
  function clearMenus(e) {
 
717
    $(backdrop).remove()
 
718
    $(toggle).each(function () {
 
719
      var $parent = getParent($(this))
 
720
      var relatedTarget = { relatedTarget: this }
 
721
      if (!$parent.hasClass('open')) return
 
722
      $parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))
 
723
      if (e.isDefaultPrevented()) return
 
724
      $parent.removeClass('open').trigger('hidden.bs.dropdown', relatedTarget)
 
725
    })
 
726
  }
 
727
 
 
728
  function getParent($this) {
 
729
    var selector = $this.attr('data-target')
 
730
 
 
731
    if (!selector) {
 
732
      selector = $this.attr('href')
 
733
      selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
 
734
    }
 
735
 
 
736
    var $parent = selector && $(selector)
 
737
 
 
738
    return $parent && $parent.length ? $parent : $this.parent()
 
739
  }
 
740
 
 
741
 
 
742
  // DROPDOWN PLUGIN DEFINITION
 
743
  // ==========================
 
744
 
 
745
  var old = $.fn.dropdown
 
746
 
 
747
  $.fn.dropdown = function (option) {
 
748
    return this.each(function () {
 
749
      var $this = $(this)
 
750
      var data  = $this.data('bs.dropdown')
 
751
 
 
752
      if (!data) $this.data('bs.dropdown', (data = new Dropdown(this)))
 
753
      if (typeof option == 'string') data[option].call($this)
 
754
    })
 
755
  }
 
756
 
 
757
  $.fn.dropdown.Constructor = Dropdown
 
758
 
 
759
 
 
760
  // DROPDOWN NO CONFLICT
 
761
  // ====================
 
762
 
 
763
  $.fn.dropdown.noConflict = function () {
 
764
    $.fn.dropdown = old
 
765
    return this
 
766
  }
 
767
 
 
768
 
 
769
  // APPLY TO STANDARD DROPDOWN ELEMENTS
 
770
  // ===================================
 
771
 
 
772
  $(document)
 
773
    .on('click.bs.dropdown.data-api', clearMenus)
 
774
    .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
 
775
    .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)
 
776
    .on('keydown.bs.dropdown.data-api', toggle + ', [role=menu], [role=listbox]', Dropdown.prototype.keydown)
 
777
 
 
778
}(window.$jqTheme||window.jQuery);
 
779
 
 
780
/* ========================================================================
 
781
 * Bootstrap: modal.js v3.1.0
 
782
 * http://getbootstrap.com/javascript/#modals
 
783
 * ========================================================================
 
784
 * Copyright 2011-2014 Twitter, Inc.
 
785
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
786
 * ======================================================================== */
 
787
 
 
788
 
 
789
+function ($) {
 
790
  'use strict';
 
791
 
 
792
  // MODAL CLASS DEFINITION
 
793
  // ======================
 
794
 
 
795
  var Modal = function (element, options) {
 
796
    this.options   = options
 
797
    this.$element  = $(element)
 
798
    this.$backdrop =
 
799
    this.isShown   = null
 
800
 
 
801
    if (this.options.remote) {
 
802
      this.$element
 
803
        .find('.modal-content')
 
804
        .load(this.options.remote, $.proxy(function () {
 
805
          this.$element.trigger('loaded.bs.modal')
 
806
        }, this))
 
807
    }
 
808
  }
 
809
 
 
810
  Modal.DEFAULTS = {
 
811
    backdrop: true,
 
812
    keyboard: true,
 
813
    show: true
 
814
  }
 
815
 
 
816
  Modal.prototype.toggle = function (_relatedTarget) {
 
817
    return this[!this.isShown ? 'show' : 'hide'](_relatedTarget)
 
818
  }
 
819
 
 
820
  Modal.prototype.show = function (_relatedTarget) {
 
821
    var that = this
 
822
    var e    = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
 
823
 
 
824
    this.$element.trigger(e)
 
825
 
 
826
    if (this.isShown || e.isDefaultPrevented()) return
 
827
 
 
828
    this.isShown = true
 
829
 
 
830
    this.escape()
 
831
 
 
832
    this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))
 
833
 
 
834
    this.backdrop(function () {
 
835
      var transition = $.support.transition && that.$element.hasClass('fade')
 
836
 
 
837
      if (!that.$element.parent().length) {
 
838
        that.$element.appendTo(document.body) // don't move modals dom position
 
839
      }
 
840
 
 
841
      that.$element
 
842
        .show()
 
843
        .scrollTop(0)
 
844
 
 
845
      if (transition) {
 
846
        that.$element[0].offsetWidth // force reflow
 
847
      }
 
848
 
 
849
      that.$element
 
850
        .addClass('in')
 
851
        .attr('aria-hidden', false)
 
852
 
 
853
      that.enforceFocus()
 
854
 
 
855
      var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })
 
856
 
 
857
      transition ?
 
858
        that.$element.find('.modal-dialog') // wait for modal to slide in
 
859
          .one($.support.transition.end, function () {
 
860
            that.$element.focus().trigger(e)
 
861
          })
 
862
          .emulateTransitionEnd(300) :
 
863
        that.$element.focus().trigger(e)
 
864
    })
 
865
  }
 
866
 
 
867
  Modal.prototype.hide = function (e) {
 
868
    if (e) e.preventDefault()
 
869
 
 
870
    e = $.Event('hide.bs.modal')
 
871
 
 
872
    this.$element.trigger(e)
 
873
 
 
874
    if (!this.isShown || e.isDefaultPrevented()) return
 
875
 
 
876
    this.isShown = false
 
877
 
 
878
    this.escape()
 
879
 
 
880
    $(document).off('focusin.bs.modal')
 
881
 
 
882
    this.$element
 
883
      .removeClass('in')
 
884
      .attr('aria-hidden', true)
 
885
      .off('click.dismiss.bs.modal')
 
886
 
 
887
    $.support.transition && this.$element.hasClass('fade') ?
 
888
      this.$element
 
889
        .one($.support.transition.end, $.proxy(this.hideModal, this))
 
890
        .emulateTransitionEnd(300) :
 
891
      this.hideModal()
 
892
  }
 
893
 
 
894
  Modal.prototype.enforceFocus = function () {
 
895
    $(document)
 
896
      .off('focusin.bs.modal') // guard against infinite focus loop
 
897
      .on('focusin.bs.modal', $.proxy(function (e) {
 
898
        if (this.$element[0] !== e.target && !this.$element.has(e.target).length) {
 
899
          this.$element.focus()
 
900
        }
 
901
      }, this))
 
902
  }
 
903
 
 
904
  Modal.prototype.escape = function () {
 
905
    if (this.isShown && this.options.keyboard) {
 
906
      this.$element.on('keyup.dismiss.bs.modal', $.proxy(function (e) {
 
907
        e.which == 27 && this.hide()
 
908
      }, this))
 
909
    } else if (!this.isShown) {
 
910
      this.$element.off('keyup.dismiss.bs.modal')
 
911
    }
 
912
  }
 
913
 
 
914
  Modal.prototype.hideModal = function () {
 
915
    var that = this
 
916
    this.$element.hide()
 
917
    this.backdrop(function () {
 
918
      that.removeBackdrop()
 
919
      that.$element.trigger('hidden.bs.modal')
 
920
    })
 
921
  }
 
922
 
 
923
  Modal.prototype.removeBackdrop = function () {
 
924
    this.$backdrop && this.$backdrop.remove()
 
925
    this.$backdrop = null
 
926
  }
 
927
 
 
928
  Modal.prototype.backdrop = function (callback) {
 
929
    var animate = this.$element.hasClass('fade') ? 'fade' : ''
 
930
 
 
931
    if (this.isShown && this.options.backdrop) {
 
932
      var doAnimate = $.support.transition && animate
 
933
 
 
934
      this.$backdrop = $('<div class="modal-backdrop ' + animate + '" />')
 
935
        .appendTo(document.body)
 
936
 
 
937
      this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
 
938
        if (e.target !== e.currentTarget) return
 
939
        this.options.backdrop == 'static'
 
940
          ? this.$element[0].focus.call(this.$element[0])
 
941
          : this.hide.call(this)
 
942
      }, this))
 
943
 
 
944
      if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
 
945
 
 
946
      this.$backdrop.addClass('in')
 
947
 
 
948
      if (!callback) return
 
949
 
 
950
      doAnimate ?
 
951
        this.$backdrop
 
952
          .one($.support.transition.end, callback)
 
953
          .emulateTransitionEnd(150) :
 
954
        callback()
 
955
 
 
956
    } else if (!this.isShown && this.$backdrop) {
 
957
      this.$backdrop.removeClass('in')
 
958
 
 
959
      $.support.transition && this.$element.hasClass('fade') ?
 
960
        this.$backdrop
 
961
          .one($.support.transition.end, callback)
 
962
          .emulateTransitionEnd(150) :
 
963
        callback()
 
964
 
 
965
    } else if (callback) {
 
966
      callback()
 
967
    }
 
968
  }
 
969
 
 
970
 
 
971
  // MODAL PLUGIN DEFINITION
 
972
  // =======================
 
973
 
 
974
  var old = $.fn.modal
 
975
 
 
976
  $.fn.modal = function (option, _relatedTarget) {
 
977
    return this.each(function () {
 
978
      var $this   = $(this)
 
979
      var data    = $this.data('bs.modal')
 
980
      var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
 
981
 
 
982
      if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
 
983
      if (typeof option == 'string') data[option](_relatedTarget)
 
984
      else if (options.show) data.show(_relatedTarget)
 
985
    })
 
986
  }
 
987
 
 
988
  $.fn.modal.Constructor = Modal
 
989
 
 
990
 
 
991
  // MODAL NO CONFLICT
 
992
  // =================
 
993
 
 
994
  $.fn.modal.noConflict = function () {
 
995
    $.fn.modal = old
 
996
    return this
 
997
  }
 
998
 
 
999
 
 
1000
  // MODAL DATA-API
 
1001
  // ==============
 
1002
 
 
1003
  $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
 
1004
    var $this   = $(this)
 
1005
    var href    = $this.attr('href')
 
1006
    var $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) //strip for ie7
 
1007
    var option  = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
 
1008
 
 
1009
    if ($this.is('a')) e.preventDefault()
 
1010
 
 
1011
    $target
 
1012
      .modal(option, this)
 
1013
      .one('hide', function () {
 
1014
        $this.is(':visible') && $this.focus()
 
1015
      })
 
1016
  })
 
1017
 
 
1018
  $(document)
 
1019
    .on('show.bs.modal', '.modal', function () { $(document.body).addClass('modal-open') })
 
1020
    .on('hidden.bs.modal', '.modal', function () { $(document.body).removeClass('modal-open') })
 
1021
 
 
1022
}(window.$jqTheme||window.jQuery);
 
1023
 
 
1024
/* ========================================================================
 
1025
 * Bootstrap: tooltip.js v3.1.0
 
1026
 * http://getbootstrap.com/javascript/#tooltip
 
1027
 * Inspired by the original jQuery.tipsy by Jason Frame
 
1028
 * ========================================================================
 
1029
 * Copyright 2011-2014 Twitter, Inc.
 
1030
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
1031
 * ======================================================================== */
 
1032
 
 
1033
 
 
1034
+function ($) {
 
1035
  'use strict';
 
1036
 
 
1037
  // TOOLTIP PUBLIC CLASS DEFINITION
 
1038
  // ===============================
 
1039
 
 
1040
  var Tooltip = function (element, options) {
 
1041
    this.type       =
 
1042
    this.options    =
 
1043
    this.enabled    =
 
1044
    this.timeout    =
 
1045
    this.hoverState =
 
1046
    this.$element   = null
 
1047
 
 
1048
    this.init('tooltip', element, options)
 
1049
  }
 
1050
 
 
1051
  Tooltip.DEFAULTS = {
 
1052
    animation: true,
 
1053
    placement: 'top',
 
1054
    selector: false,
 
1055
    template: '<div class="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
 
1056
    trigger: 'hover focus',
 
1057
    title: '',
 
1058
    delay: 0,
 
1059
    html: false,
 
1060
    container: false
 
1061
  }
 
1062
 
 
1063
  Tooltip.prototype.init = function (type, element, options) {
 
1064
    this.enabled  = true
 
1065
    this.type     = type
 
1066
    this.$element = $(element)
 
1067
    this.options  = this.getOptions(options)
 
1068
 
 
1069
    var triggers = this.options.trigger.split(' ')
 
1070
 
 
1071
    for (var i = triggers.length; i--;) {
 
1072
      var trigger = triggers[i]
 
1073
 
 
1074
      if (trigger == 'click') {
 
1075
        this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
 
1076
      } else if (trigger != 'manual') {
 
1077
        var eventIn  = trigger == 'hover' ? 'mouseenter' : 'focusin'
 
1078
        var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
 
1079
 
 
1080
        this.$element.on(eventIn  + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
 
1081
        this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
 
1082
      }
 
1083
    }
 
1084
 
 
1085
    this.options.selector ?
 
1086
      (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
 
1087
      this.fixTitle()
 
1088
  }
 
1089
 
 
1090
  Tooltip.prototype.getDefaults = function () {
 
1091
    return Tooltip.DEFAULTS
 
1092
  }
 
1093
 
 
1094
  Tooltip.prototype.getOptions = function (options) {
 
1095
    options = $.extend({}, this.getDefaults(), this.$element.data(), options)
 
1096
 
 
1097
    if (options.delay && typeof options.delay == 'number') {
 
1098
      options.delay = {
 
1099
        show: options.delay,
 
1100
        hide: options.delay
 
1101
      }
 
1102
    }
 
1103
 
 
1104
    return options
 
1105
  }
 
1106
 
 
1107
  Tooltip.prototype.getDelegateOptions = function () {
 
1108
    var options  = {}
 
1109
    var defaults = this.getDefaults()
 
1110
 
 
1111
    this._options && $.each(this._options, function (key, value) {
 
1112
      if (defaults[key] != value) options[key] = value
 
1113
    })
 
1114
 
 
1115
    return options
 
1116
  }
 
1117
 
 
1118
  Tooltip.prototype.enter = function (obj) {
 
1119
    var self = obj instanceof this.constructor ?
 
1120
      obj : $(obj.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type)
 
1121
 
 
1122
    clearTimeout(self.timeout)
 
1123
 
 
1124
    self.hoverState = 'in'
 
1125
 
 
1126
    if (!self.options.delay || !self.options.delay.show) return self.show()
 
1127
 
 
1128
    self.timeout = setTimeout(function () {
 
1129
      if (self.hoverState == 'in') self.show()
 
1130
    }, self.options.delay.show)
 
1131
  }
 
1132
 
 
1133
  Tooltip.prototype.leave = function (obj) {
 
1134
    var self = obj instanceof this.constructor ?
 
1135
      obj : $(obj.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type)
 
1136
 
 
1137
    clearTimeout(self.timeout)
 
1138
 
 
1139
    self.hoverState = 'out'
 
1140
 
 
1141
    if (!self.options.delay || !self.options.delay.hide) return self.hide()
 
1142
 
 
1143
    self.timeout = setTimeout(function () {
 
1144
      if (self.hoverState == 'out') self.hide()
 
1145
    }, self.options.delay.hide)
 
1146
  }
 
1147
 
 
1148
  Tooltip.prototype.show = function () {
 
1149
    var e = $.Event('show.bs.' + this.type)
 
1150
 
 
1151
    if (this.hasContent() && this.enabled) {
 
1152
      this.$element.trigger(e)
 
1153
 
 
1154
      if (e.isDefaultPrevented()) return
 
1155
      var that = this;
 
1156
 
 
1157
      var $tip = this.tip()
 
1158
 
 
1159
      this.setContent()
 
1160
 
 
1161
      if (this.options.animation) $tip.addClass('fade')
 
1162
 
 
1163
      var placement = typeof this.options.placement == 'function' ?
 
1164
        this.options.placement.call(this, $tip[0], this.$element[0]) :
 
1165
        this.options.placement
 
1166
 
 
1167
      var autoToken = /\s?auto?\s?/i
 
1168
      var autoPlace = autoToken.test(placement)
 
1169
      if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
 
1170
 
 
1171
      $tip
 
1172
        .detach()
 
1173
        .css({ top: 0, left: 0, display: 'block' })
 
1174
        .addClass(placement)
 
1175
 
 
1176
      this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
 
1177
 
 
1178
      var pos          = this.getPosition()
 
1179
      var actualWidth  = $tip[0].offsetWidth
 
1180
      var actualHeight = $tip[0].offsetHeight
 
1181
 
 
1182
      if (autoPlace) {
 
1183
        var $parent = this.$element.parent()
 
1184
 
 
1185
        var orgPlacement = placement
 
1186
        var docScroll    = document.documentElement.scrollTop || document.body.scrollTop
 
1187
        var parentWidth  = this.options.container == 'body' ? window.innerWidth  : $parent.outerWidth()
 
1188
        var parentHeight = this.options.container == 'body' ? window.innerHeight : $parent.outerHeight()
 
1189
        var parentLeft   = this.options.container == 'body' ? 0 : $parent.offset().left
 
1190
 
 
1191
        placement = placement == 'bottom' && pos.top   + pos.height  + actualHeight - docScroll > parentHeight  ? 'top'    :
 
1192
                    placement == 'top'    && pos.top   - docScroll   - actualHeight < 0                         ? 'bottom' :
 
1193
                    placement == 'right'  && pos.right + actualWidth > parentWidth                              ? 'left'   :
 
1194
                    placement == 'left'   && pos.left  - actualWidth < parentLeft                               ? 'right'  :
 
1195
                    placement
 
1196
 
 
1197
        $tip
 
1198
          .removeClass(orgPlacement)
 
1199
          .addClass(placement)
 
1200
      }
 
1201
 
 
1202
      var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
 
1203
 
 
1204
      this.applyPlacement(calculatedOffset, placement)
 
1205
      this.hoverState = null
 
1206
 
 
1207
      var complete = function() {
 
1208
        that.$element.trigger('shown.bs.' + that.type)
 
1209
      }
 
1210
 
 
1211
      $.support.transition && this.$tip.hasClass('fade') ?
 
1212
        $tip
 
1213
          .one($.support.transition.end, complete)
 
1214
          .emulateTransitionEnd(150) :
 
1215
        complete()
 
1216
    }
 
1217
  }
 
1218
 
 
1219
  Tooltip.prototype.applyPlacement = function (offset, placement) {
 
1220
    var replace
 
1221
    var $tip   = this.tip()
 
1222
    var width  = $tip[0].offsetWidth
 
1223
    var height = $tip[0].offsetHeight
 
1224
 
 
1225
    // manually read margins because getBoundingClientRect includes difference
 
1226
    var marginTop = parseInt($tip.css('margin-top'), 10)
 
1227
    var marginLeft = parseInt($tip.css('margin-left'), 10)
 
1228
 
 
1229
    // we must check for NaN for ie 8/9
 
1230
    if (isNaN(marginTop))  marginTop  = 0
 
1231
    if (isNaN(marginLeft)) marginLeft = 0
 
1232
 
 
1233
    offset.top  = offset.top  + marginTop
 
1234
    offset.left = offset.left + marginLeft
 
1235
 
 
1236
    // $.fn.offset doesn't round pixel values
 
1237
    // so we use setOffset directly with our own function B-0
 
1238
    $.offset.setOffset($tip[0], $.extend({
 
1239
      using: function (props) {
 
1240
        $tip.css({
 
1241
          top: Math.round(props.top),
 
1242
          left: Math.round(props.left)
 
1243
        })
 
1244
      }
 
1245
    }, offset), 0)
 
1246
 
 
1247
    $tip.addClass('in')
 
1248
 
 
1249
    // check to see if placing tip in new offset caused the tip to resize itself
 
1250
    var actualWidth  = $tip[0].offsetWidth
 
1251
    var actualHeight = $tip[0].offsetHeight
 
1252
 
 
1253
    if (placement == 'top' && actualHeight != height) {
 
1254
      replace = true
 
1255
      offset.top = offset.top + height - actualHeight
 
1256
    }
 
1257
 
 
1258
    if (/bottom|top/.test(placement)) {
 
1259
      var delta = 0
 
1260
 
 
1261
      if (offset.left < 0) {
 
1262
        delta       = offset.left * -2
 
1263
        offset.left = 0
 
1264
 
 
1265
        $tip.offset(offset)
 
1266
 
 
1267
        actualWidth  = $tip[0].offsetWidth
 
1268
        actualHeight = $tip[0].offsetHeight
 
1269
      }
 
1270
 
 
1271
      this.replaceArrow(delta - width + actualWidth, actualWidth, 'left')
 
1272
    } else {
 
1273
      this.replaceArrow(actualHeight - height, actualHeight, 'top')
 
1274
    }
 
1275
 
 
1276
    if (replace) $tip.offset(offset)
 
1277
  }
 
1278
 
 
1279
  Tooltip.prototype.replaceArrow = function (delta, dimension, position) {
 
1280
    this.arrow().css(position, delta ? (50 * (1 - delta / dimension) + '%') : '')
 
1281
  }
 
1282
 
 
1283
  Tooltip.prototype.setContent = function () {
 
1284
    var $tip  = this.tip()
 
1285
    var title = this.getTitle()
 
1286
 
 
1287
    $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
 
1288
    $tip.removeClass('fade in top bottom left right')
 
1289
  }
 
1290
 
 
1291
  Tooltip.prototype.hide = function () {
 
1292
    var that = this
 
1293
    var $tip = this.tip()
 
1294
    var e    = $.Event('hide.bs.' + this.type)
 
1295
 
 
1296
    function complete() {
 
1297
      if (that.hoverState != 'in') $tip.detach()
 
1298
      that.$element.trigger('hidden.bs.' + that.type)
 
1299
    }
 
1300
 
 
1301
    this.$element.trigger(e)
 
1302
 
 
1303
    if (e.isDefaultPrevented()) return
 
1304
 
 
1305
    $tip.removeClass('in')
 
1306
 
 
1307
    $.support.transition && this.$tip.hasClass('fade') ?
 
1308
      $tip
 
1309
        .one($.support.transition.end, complete)
 
1310
        .emulateTransitionEnd(150) :
 
1311
      complete()
 
1312
 
 
1313
    this.hoverState = null
 
1314
 
 
1315
    return this
 
1316
  }
 
1317
 
 
1318
  Tooltip.prototype.fixTitle = function () {
 
1319
    var $e = this.$element
 
1320
    if ($e.attr('title') || typeof($e.attr('data-original-title')) != 'string') {
 
1321
      $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
 
1322
    }
 
1323
  }
 
1324
 
 
1325
  Tooltip.prototype.hasContent = function () {
 
1326
    return this.getTitle()
 
1327
  }
 
1328
 
 
1329
  Tooltip.prototype.getPosition = function () {
 
1330
    var el = this.$element[0]
 
1331
    return $.extend({}, (typeof el.getBoundingClientRect == 'function') ? el.getBoundingClientRect() : {
 
1332
      width: el.offsetWidth,
 
1333
      height: el.offsetHeight
 
1334
    }, this.$element.offset())
 
1335
  }
 
1336
 
 
1337
  Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
 
1338
    return placement == 'bottom' ? { top: pos.top + pos.height,   left: pos.left + pos.width / 2 - actualWidth / 2  } :
 
1339
           placement == 'top'    ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2  } :
 
1340
           placement == 'left'   ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
 
1341
        /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width   }
 
1342
  }
 
1343
 
 
1344
  Tooltip.prototype.getTitle = function () {
 
1345
    var title
 
1346
    var $e = this.$element
 
1347
    var o  = this.options
 
1348
 
 
1349
    title = $e.attr('data-original-title')
 
1350
      || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)
 
1351
 
 
1352
    return title
 
1353
  }
 
1354
 
 
1355
  Tooltip.prototype.tip = function () {
 
1356
    return this.$tip = this.$tip || $(this.options.template)
 
1357
  }
 
1358
 
 
1359
  Tooltip.prototype.arrow = function () {
 
1360
    return this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow')
 
1361
  }
 
1362
 
 
1363
  Tooltip.prototype.validate = function () {
 
1364
    if (!this.$element[0].parentNode) {
 
1365
      this.hide()
 
1366
      this.$element = null
 
1367
      this.options  = null
 
1368
    }
 
1369
  }
 
1370
 
 
1371
  Tooltip.prototype.enable = function () {
 
1372
    this.enabled = true
 
1373
  }
 
1374
 
 
1375
  Tooltip.prototype.disable = function () {
 
1376
    this.enabled = false
 
1377
  }
 
1378
 
 
1379
  Tooltip.prototype.toggleEnabled = function () {
 
1380
    this.enabled = !this.enabled
 
1381
  }
 
1382
 
 
1383
  Tooltip.prototype.toggle = function (e) {
 
1384
    var self = e ? $(e.currentTarget)[this.type](this.getDelegateOptions()).data('bs.' + this.type) : this
 
1385
    self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
 
1386
  }
 
1387
 
 
1388
  Tooltip.prototype.destroy = function () {
 
1389
    clearTimeout(this.timeout)
 
1390
    this.hide().$element.off('.' + this.type).removeData('bs.' + this.type)
 
1391
  }
 
1392
 
 
1393
 
 
1394
  // TOOLTIP PLUGIN DEFINITION
 
1395
  // =========================
 
1396
 
 
1397
  var old = $.fn.tooltip
 
1398
 
 
1399
  $.fn.tooltip = function (option) {
 
1400
    return this.each(function () {
 
1401
      var $this   = $(this)
 
1402
      var data    = $this.data('bs.tooltip')
 
1403
      var options = typeof option == 'object' && option
 
1404
 
 
1405
      if (!data && option == 'destroy') return
 
1406
      if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
 
1407
      if (typeof option == 'string') data[option]()
 
1408
    })
 
1409
  }
 
1410
 
 
1411
  $.fn.tooltip.Constructor = Tooltip
 
1412
 
 
1413
 
 
1414
  // TOOLTIP NO CONFLICT
 
1415
  // ===================
 
1416
 
 
1417
  $.fn.tooltip.noConflict = function () {
 
1418
    $.fn.tooltip = old
 
1419
    return this
 
1420
  }
 
1421
 
 
1422
}(window.$jqTheme||window.jQuery);
 
1423
 
 
1424
/* ========================================================================
 
1425
 * Bootstrap: popover.js v3.1.0
 
1426
 * http://getbootstrap.com/javascript/#popovers
 
1427
 * ========================================================================
 
1428
 * Copyright 2011-2014 Twitter, Inc.
 
1429
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
1430
 * ======================================================================== */
 
1431
 
 
1432
 
 
1433
+function ($) {
 
1434
  'use strict';
 
1435
 
 
1436
  // POPOVER PUBLIC CLASS DEFINITION
 
1437
  // ===============================
 
1438
 
 
1439
  var Popover = function (element, options) {
 
1440
    this.init('popover', element, options)
 
1441
  }
 
1442
 
 
1443
  if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
 
1444
 
 
1445
  Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
 
1446
    placement: 'right',
 
1447
    trigger: 'click',
 
1448
    content: '',
 
1449
    template: '<div class="popover"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
 
1450
  })
 
1451
 
 
1452
 
 
1453
  // NOTE: POPOVER EXTENDS tooltip.js
 
1454
  // ================================
 
1455
 
 
1456
  Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
 
1457
 
 
1458
  Popover.prototype.constructor = Popover
 
1459
 
 
1460
  Popover.prototype.getDefaults = function () {
 
1461
    return Popover.DEFAULTS
 
1462
  }
 
1463
 
 
1464
  Popover.prototype.setContent = function () {
 
1465
    var $tip    = this.tip()
 
1466
    var title   = this.getTitle()
 
1467
    var content = this.getContent()
 
1468
 
 
1469
    $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
 
1470
    $tip.find('.popover-content')[ // we use append for html objects to maintain js events
 
1471
      this.options.html ? (typeof content == 'string' ? 'html' : 'append') : 'text'
 
1472
    ](content)
 
1473
 
 
1474
    $tip.removeClass('fade top bottom left right in')
 
1475
 
 
1476
    // IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
 
1477
    // this manually by checking the contents.
 
1478
    if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
 
1479
  }
 
1480
 
 
1481
  Popover.prototype.hasContent = function () {
 
1482
    return this.getTitle() || this.getContent()
 
1483
  }
 
1484
 
 
1485
  Popover.prototype.getContent = function () {
 
1486
    var $e = this.$element
 
1487
    var o  = this.options
 
1488
 
 
1489
    return $e.attr('data-content')
 
1490
      || (typeof o.content == 'function' ?
 
1491
            o.content.call($e[0]) :
 
1492
            o.content)
 
1493
  }
 
1494
 
 
1495
  Popover.prototype.arrow = function () {
 
1496
    return this.$arrow = this.$arrow || this.tip().find('.arrow')
 
1497
  }
 
1498
 
 
1499
  Popover.prototype.tip = function () {
 
1500
    if (!this.$tip) this.$tip = $(this.options.template)
 
1501
    return this.$tip
 
1502
  }
 
1503
 
 
1504
 
 
1505
  // POPOVER PLUGIN DEFINITION
 
1506
  // =========================
 
1507
 
 
1508
  var old = $.fn.popover
 
1509
 
 
1510
  $.fn.popover = function (option) {
 
1511
    return this.each(function () {
 
1512
      var $this   = $(this)
 
1513
      var data    = $this.data('bs.popover')
 
1514
      var options = typeof option == 'object' && option
 
1515
 
 
1516
      if (!data && option == 'destroy') return
 
1517
      if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
 
1518
      if (typeof option == 'string') data[option]()
 
1519
    })
 
1520
  }
 
1521
 
 
1522
  $.fn.popover.Constructor = Popover
 
1523
 
 
1524
 
 
1525
  // POPOVER NO CONFLICT
 
1526
  // ===================
 
1527
 
 
1528
  $.fn.popover.noConflict = function () {
 
1529
    $.fn.popover = old
 
1530
    return this
 
1531
  }
 
1532
 
 
1533
}(window.$jqTheme||window.jQuery);
 
1534
 
 
1535
/* ========================================================================
 
1536
 * Bootstrap: scrollspy.js v3.1.0
 
1537
 * http://getbootstrap.com/javascript/#scrollspy
 
1538
 * ========================================================================
 
1539
 * Copyright 2011-2014 Twitter, Inc.
 
1540
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
1541
 * ======================================================================== */
 
1542
 
 
1543
 
 
1544
+function ($) {
 
1545
  'use strict';
 
1546
 
 
1547
  // SCROLLSPY CLASS DEFINITION
 
1548
  // ==========================
 
1549
 
 
1550
  function ScrollSpy(element, options) {
 
1551
    var href
 
1552
    var process  = $.proxy(this.process, this)
 
1553
 
 
1554
    this.$element       = $(element).is('body') ? $(window) : $(element)
 
1555
    this.$body          = $('body')
 
1556
    this.$scrollElement = this.$element.on('scroll.bs.scroll-spy.data-api', process)
 
1557
    this.options        = $.extend({}, ScrollSpy.DEFAULTS, options)
 
1558
    this.selector       = (this.options.target
 
1559
      || ((href = $(element).attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) //strip for ie7
 
1560
      || '') + ' .nav li > a'
 
1561
    this.offsets        = $([])
 
1562
    this.targets        = $([])
 
1563
    this.activeTarget   = null
 
1564
 
 
1565
    this.refresh()
 
1566
    this.process()
 
1567
  }
 
1568
 
 
1569
  ScrollSpy.DEFAULTS = {
 
1570
    offset: 10
 
1571
  }
 
1572
 
 
1573
  ScrollSpy.prototype.refresh = function () {
 
1574
    var offsetMethod = this.$element[0] == window ? 'offset' : 'position'
 
1575
 
 
1576
    this.offsets = $([])
 
1577
    this.targets = $([])
 
1578
 
 
1579
    var self     = this
 
1580
    var $targets = this.$body
 
1581
      .find(this.selector)
 
1582
      .map(function () {
 
1583
        var $el   = $(this)
 
1584
        var href  = $el.data('target') || $el.attr('href')
 
1585
        var $href = /^#./.test(href) && $(href)
 
1586
 
 
1587
        return ($href
 
1588
          && $href.length
 
1589
          && $href.is(':visible')
 
1590
          && [[ $href[offsetMethod]().top + (!$.isWindow(self.$scrollElement.get(0)) && self.$scrollElement.scrollTop()), href ]]) || null
 
1591
      })
 
1592
      .sort(function (a, b) { return a[0] - b[0] })
 
1593
      .each(function () {
 
1594
        self.offsets.push(this[0])
 
1595
        self.targets.push(this[1])
 
1596
      })
 
1597
  }
 
1598
 
 
1599
  ScrollSpy.prototype.process = function () {
 
1600
    var scrollTop    = this.$scrollElement.scrollTop() + this.options.offset
 
1601
    var scrollHeight = this.$scrollElement[0].scrollHeight || this.$body[0].scrollHeight
 
1602
    var maxScroll    = scrollHeight - this.$scrollElement.height()
 
1603
    var offsets      = this.offsets
 
1604
    var targets      = this.targets
 
1605
    var activeTarget = this.activeTarget
 
1606
    var i
 
1607
 
 
1608
    if (scrollTop >= maxScroll) {
 
1609
      return activeTarget != (i = targets.last()[0]) && this.activate(i)
 
1610
    }
 
1611
 
 
1612
    if (activeTarget && scrollTop <= offsets[0]) {
 
1613
      return activeTarget != (i = targets[0]) && this.activate(i)
 
1614
    }
 
1615
 
 
1616
    for (i = offsets.length; i--;) {
 
1617
      activeTarget != targets[i]
 
1618
        && scrollTop >= offsets[i]
 
1619
        && (!offsets[i + 1] || scrollTop <= offsets[i + 1])
 
1620
        && this.activate( targets[i] )
 
1621
    }
 
1622
  }
 
1623
 
 
1624
  ScrollSpy.prototype.activate = function (target) {
 
1625
    this.activeTarget = target
 
1626
 
 
1627
    $(this.selector)
 
1628
      .parentsUntil(this.options.target, '.active')
 
1629
      .removeClass('active')
 
1630
 
 
1631
    var selector = this.selector +
 
1632
        '[data-target="' + target + '"],' +
 
1633
        this.selector + '[href="' + target + '"]'
 
1634
 
 
1635
    var active = $(selector)
 
1636
      .parents('li')
 
1637
      .addClass('active')
 
1638
 
 
1639
    if (active.parent('.dropdown-menu').length) {
 
1640
      active = active
 
1641
        .closest('li.dropdown')
 
1642
        .addClass('active')
 
1643
    }
 
1644
 
 
1645
    active.trigger('activate.bs.scrollspy')
 
1646
  }
 
1647
 
 
1648
 
 
1649
  // SCROLLSPY PLUGIN DEFINITION
 
1650
  // ===========================
 
1651
 
 
1652
  var old = $.fn.scrollspy
 
1653
 
 
1654
  $.fn.scrollspy = function (option) {
 
1655
    return this.each(function () {
 
1656
      var $this   = $(this)
 
1657
      var data    = $this.data('bs.scrollspy')
 
1658
      var options = typeof option == 'object' && option
 
1659
 
 
1660
      if (!data) $this.data('bs.scrollspy', (data = new ScrollSpy(this, options)))
 
1661
      if (typeof option == 'string') data[option]()
 
1662
    })
 
1663
  }
 
1664
 
 
1665
  $.fn.scrollspy.Constructor = ScrollSpy
 
1666
 
 
1667
 
 
1668
  // SCROLLSPY NO CONFLICT
 
1669
  // =====================
 
1670
 
 
1671
  $.fn.scrollspy.noConflict = function () {
 
1672
    $.fn.scrollspy = old
 
1673
    return this
 
1674
  }
 
1675
 
 
1676
 
 
1677
  // SCROLLSPY DATA-API
 
1678
  // ==================
 
1679
 
 
1680
  $(window).on('load', function () {
 
1681
    $('[data-spy="scroll"]').each(function () {
 
1682
      var $spy = $(this)
 
1683
      $spy.scrollspy($spy.data())
 
1684
    })
 
1685
  })
 
1686
 
 
1687
}(window.$jqTheme||window.jQuery);
 
1688
 
 
1689
/* ========================================================================
 
1690
 * Bootstrap: tab.js v3.1.0
 
1691
 * http://getbootstrap.com/javascript/#tabs
 
1692
 * ========================================================================
 
1693
 * Copyright 2011-2014 Twitter, Inc.
 
1694
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
1695
 * ======================================================================== */
 
1696
 
 
1697
 
 
1698
+function ($) {
 
1699
  'use strict';
 
1700
 
 
1701
  // TAB CLASS DEFINITION
 
1702
  // ====================
 
1703
 
 
1704
  var Tab = function (element) {
 
1705
    this.element = $(element)
 
1706
  }
 
1707
 
 
1708
  Tab.prototype.show = function () {
 
1709
    var $this    = this.element
 
1710
    var $ul      = $this.closest('ul:not(.dropdown-menu)')
 
1711
    var selector = $this.data('target')
 
1712
 
 
1713
    if (!selector) {
 
1714
      selector = $this.attr('href')
 
1715
      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
 
1716
    }
 
1717
 
 
1718
    if ($this.parent('li').hasClass('active')) return
 
1719
 
 
1720
    var previous = $ul.find('.active:last a')[0]
 
1721
    var e        = $.Event('show.bs.tab', {
 
1722
      relatedTarget: previous
 
1723
    })
 
1724
 
 
1725
    $this.trigger(e)
 
1726
 
 
1727
    if (e.isDefaultPrevented()) return
 
1728
 
 
1729
    var $target = $(selector)
 
1730
 
 
1731
    this.activate($this.parent('li'), $ul)
 
1732
    this.activate($target, $target.parent(), function () {
 
1733
      $this.trigger({
 
1734
        type: 'shown.bs.tab',
 
1735
        relatedTarget: previous
 
1736
      })
 
1737
    })
 
1738
  }
 
1739
 
 
1740
  Tab.prototype.activate = function (element, container, callback) {
 
1741
    var $active    = container.find('> .active')
 
1742
    var transition = callback
 
1743
      && $.support.transition
 
1744
      && $active.hasClass('fade')
 
1745
 
 
1746
    function next() {
 
1747
      $active
 
1748
        .removeClass('active')
 
1749
        .find('> .dropdown-menu > .active')
 
1750
        .removeClass('active')
 
1751
 
 
1752
      element.addClass('active')
 
1753
 
 
1754
      if (transition) {
 
1755
        element[0].offsetWidth // reflow for transition
 
1756
        element.addClass('in')
 
1757
      } else {
 
1758
        element.removeClass('fade')
 
1759
      }
 
1760
 
 
1761
      if (element.parent('.dropdown-menu')) {
 
1762
        element.closest('li.dropdown').addClass('active')
 
1763
      }
 
1764
 
 
1765
      callback && callback()
 
1766
    }
 
1767
 
 
1768
    transition ?
 
1769
      $active
 
1770
        .one($.support.transition.end, next)
 
1771
        .emulateTransitionEnd(150) :
 
1772
      next()
 
1773
 
 
1774
    $active.removeClass('in')
 
1775
  }
 
1776
 
 
1777
 
 
1778
  // TAB PLUGIN DEFINITION
 
1779
  // =====================
 
1780
 
 
1781
  var old = $.fn.tab
 
1782
 
 
1783
  $.fn.tab = function ( option ) {
 
1784
    return this.each(function () {
 
1785
      var $this = $(this)
 
1786
      var data  = $this.data('bs.tab')
 
1787
 
 
1788
      if (!data) $this.data('bs.tab', (data = new Tab(this)))
 
1789
      if (typeof option == 'string') data[option]()
 
1790
    })
 
1791
  }
 
1792
 
 
1793
  $.fn.tab.Constructor = Tab
 
1794
 
 
1795
 
 
1796
  // TAB NO CONFLICT
 
1797
  // ===============
 
1798
 
 
1799
  $.fn.tab.noConflict = function () {
 
1800
    $.fn.tab = old
 
1801
    return this
 
1802
  }
 
1803
 
 
1804
 
 
1805
  // TAB DATA-API
 
1806
  // ============
 
1807
 
 
1808
  $(document).on('click.bs.tab.data-api', '[data-toggle="tab"], [data-toggle="pill"]', function (e) {
 
1809
    e.preventDefault()
 
1810
    $(this).tab('show')
 
1811
  })
 
1812
 
 
1813
}(window.$jqTheme||window.jQuery);
 
1814
 
 
1815
/* ========================================================================
 
1816
 * Bootstrap: affix.js v3.1.0
 
1817
 * http://getbootstrap.com/javascript/#affix
 
1818
 * ========================================================================
 
1819
 * Copyright 2011-2014 Twitter, Inc.
 
1820
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 
1821
 * ======================================================================== */
 
1822
 
 
1823
 
 
1824
+function ($) {
 
1825
  'use strict';
 
1826
 
 
1827
  // AFFIX CLASS DEFINITION
 
1828
  // ======================
 
1829
 
 
1830
  var Affix = function (element, options) {
 
1831
    this.options = $.extend({}, Affix.DEFAULTS, options)
 
1832
    this.$window = $(window)
 
1833
      .on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))
 
1834
      .on('click.bs.affix.data-api',  $.proxy(this.checkPositionWithEventLoop, this))
 
1835
 
 
1836
    this.$element     = $(element)
 
1837
    this.affixed      =
 
1838
    this.unpin        =
 
1839
    this.pinnedOffset = null
 
1840
 
 
1841
    this.checkPosition()
 
1842
  }
 
1843
 
 
1844
  Affix.RESET = 'affix affix-top affix-bottom'
 
1845
 
 
1846
  Affix.DEFAULTS = {
 
1847
    offset: 0
 
1848
  }
 
1849
 
 
1850
  Affix.prototype.getPinnedOffset = function () {
 
1851
    if (this.pinnedOffset) return this.pinnedOffset
 
1852
    this.$element.removeClass(Affix.RESET).addClass('affix')
 
1853
    var scrollTop = this.$window.scrollTop()
 
1854
    var position  = this.$element.offset()
 
1855
    return (this.pinnedOffset = position.top - scrollTop)
 
1856
  }
 
1857
 
 
1858
  Affix.prototype.checkPositionWithEventLoop = function () {
 
1859
    setTimeout($.proxy(this.checkPosition, this), 1)
 
1860
  }
 
1861
 
 
1862
  Affix.prototype.checkPosition = function () {
 
1863
    if (!this.$element.is(':visible')) return
 
1864
 
 
1865
    var scrollHeight = $(document).height()
 
1866
    var scrollTop    = this.$window.scrollTop()
 
1867
    var position     = this.$element.offset()
 
1868
    var offset       = this.options.offset
 
1869
    var offsetTop    = offset.top
 
1870
    var offsetBottom = offset.bottom
 
1871
 
 
1872
    if (this.affixed == 'top') position.top += scrollTop
 
1873
 
 
1874
    if (typeof offset != 'object')         offsetBottom = offsetTop = offset
 
1875
    if (typeof offsetTop == 'function')    offsetTop    = offset.top(this.$element)
 
1876
    if (typeof offsetBottom == 'function') offsetBottom = offset.bottom(this.$element)
 
1877
 
 
1878
    var affix = this.unpin   != null && (scrollTop + this.unpin <= position.top) ? false :
 
1879
                offsetBottom != null && (position.top + this.$element.height() >= scrollHeight - offsetBottom) ? 'bottom' :
 
1880
                offsetTop    != null && (scrollTop <= offsetTop) ? 'top' : false
 
1881
 
 
1882
    if (this.affixed === affix) return
 
1883
    if (this.unpin) this.$element.css('top', '')
 
1884
 
 
1885
    var affixType = 'affix' + (affix ? '-' + affix : '')
 
1886
    var e         = $.Event(affixType + '.bs.affix')
 
1887
 
 
1888
    this.$element.trigger(e)
 
1889
 
 
1890
    if (e.isDefaultPrevented()) return
 
1891
 
 
1892
    this.affixed = affix
 
1893
    this.unpin = affix == 'bottom' ? this.getPinnedOffset() : null
 
1894
 
 
1895
    this.$element
 
1896
      .removeClass(Affix.RESET)
 
1897
      .addClass(affixType)
 
1898
      .trigger($.Event(affixType.replace('affix', 'affixed')))
 
1899
 
 
1900
    if (affix == 'bottom') {
 
1901
      this.$element.offset({ top: scrollHeight - offsetBottom - this.$element.height() })
 
1902
    }
 
1903
  }
 
1904
 
 
1905
 
 
1906
  // AFFIX PLUGIN DEFINITION
 
1907
  // =======================
 
1908
 
 
1909
  var old = $.fn.affix
 
1910
 
 
1911
  $.fn.affix = function (option) {
 
1912
    return this.each(function () {
 
1913
      var $this   = $(this)
 
1914
      var data    = $this.data('bs.affix')
 
1915
      var options = typeof option == 'object' && option
 
1916
 
 
1917
      if (!data) $this.data('bs.affix', (data = new Affix(this, options)))
 
1918
      if (typeof option == 'string') data[option]()
 
1919
    })
 
1920
  }
 
1921
 
 
1922
  $.fn.affix.Constructor = Affix
 
1923
 
 
1924
 
 
1925
  // AFFIX NO CONFLICT
 
1926
  // =================
 
1927
 
 
1928
  $.fn.affix.noConflict = function () {
 
1929
    $.fn.affix = old
 
1930
    return this
 
1931
  }
 
1932
 
 
1933
 
 
1934
  // AFFIX DATA-API
 
1935
  // ==============
 
1936
 
 
1937
  $(window).on('load', function () {
 
1938
    $('[data-spy="affix"]').each(function () {
 
1939
      var $spy = $(this)
 
1940
      var data = $spy.data()
 
1941
 
 
1942
      data.offset = data.offset || {}
 
1943
 
 
1944
      if (data.offsetBottom) data.offset.bottom = data.offsetBottom
 
1945
      if (data.offsetTop)    data.offset.top    = data.offsetTop
 
1946
 
 
1947
      $spy.affix(data)
 
1948
    })
 
1949
  })
 
1950
 
 
1951
}(window.$jqTheme||window.jQuery);