https://steerbidder.com/_static/??-eJyVjs0OwjAMg1+ILUwaYhfEo6AsjVi…CwSAxA+cjGO1Wuq0KZPzTVduvNwGo7d0PdP1EtZig==

197          if(!slider.vars.pauseInvisible || !methods.pauseInvisible.isHidden()) {
198            (slider.vars.initDelay > 0) ? slider.startTimeout = setTimeout(slider.play, slider.vars.initDelay) : slider.play();
199          }
200        }
201
202        // ASNAV:
203        if (asNav) methods.asNav.setup();
204
205        // TOUCH
206        if (touch && slider.vars.touch) methods.touch();
207
208        // FADE&&SMOOTHHEIGHT || SLIDE:
209        if (!fade || (fade && slider.vars.smoothHeight)) $(window).bind("resize orientationchange focus", methods.resize);
210
211        slider.find("img").attr("draggable", "false");
212
213        // API: start() Callback
214        setTimeout(function(){
215          slider.vars.start(slider);
216        }, 200);
217      },
218      asNav: {
219        setup: function() {
220          slider.asNav = true;
221          slider.animatingTo = Math.floor(slider.currentSlide/slider.move);
222          slider.currentItem = slider.currentSlide;
223          slider.slides.removeClass(namespace + "active-slide").eq(slider.currentItem).addClass(namespace + "active-slide");
224          if(!msGesture){
225              slider.slides.click(function(e){
226                e.preventDefault();
227                var $slide = $(this),
228                    target = $slide.index();
229                var posFromLeft = $slide.offset().left - $(slider).scrollLeft(); // Find position of slide relative to left of slider container
230                if( posFromLeft <= 0 && $slide.hasClass( namespace + 'active-slide' ) ) {
231                  slider.flexAnimate(slider.getTarget("prev"), true);
232                } else if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass(namespace + "active-slide")) {
233                  slider.direction = (slider.currentItem < target) ? "next" : "prev";
234                  slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
235                }
236              });
237          }else{
238              el._slider = slider;
239              slider.slides.each(function (){
240                  var that = this;
241                  that._gesture = new MSGesture();
242                  that._gesture.target = that;
243                  that.addEventListener("MSPointerDown", function (e){
244                      e.preventDefault();
245                      if(e.currentTarget._gesture)
246                          e.currentTarget._gesture.addPointer(e.pointerId);
247                  }, false);
248                  that.addEventListener("MSGestureTap", function (e){
249                      e.preventDefault();
250                      var $slide = $(this),
251                          target = $slide.index();
252                      if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass('active')) {
253                          slider.direction = (slider.currentItem < target) ? "next" : "prev";
254                          slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
255                      }
256                  });
257              });
258          }
259        }
260      },
261      controlNav: {
262        setup: function() {
263          if (!slider.manualControls) {
264            methods.controlNav.setupPaging();
265          } else { // MANUALCONTROLS:
266            methods.controlNav.setupManual();
267          }
268        },
269        setupPaging: function() {
270          var type = (slider.vars.controlNav === "thumbnails") ? 'control-thumbs' : 'control-paging',
271              j = 1,
272              item,
273              slide;
274
275          slider.controlNavScaffold = $('<ol class="'+ namespace + 'control-nav ' + namespace + type + '"></ol>');
276
277          if (slider.pagingCount > 1) {
278            for (var i = 0; i < slider.pagingCount; i++) {
279              slide = slider.slides.eq(i);
280              item = (slider.vars.controlNav === "thumbnails") ? '<img src="' + slide.attr( 'data-thumb' ) + '"/>' : '<a>' + j + '</a>';
281              if ( 'thumbnails' === slider.vars.controlNav && true === slider.vars.thumbCaptions ) {
282                var captn = slide.attr( 'data-thumbcaption' );
283                if ( '' != captn && undefined != captn ) item += '<span class="' + namespace + 'caption">' + captn + '</span>';
284              }
285              slider.controlNavScaffold.append('<li>' + item + '</li>');
286              j++;
287            }
288          }
289
290          // CONTROLSCONTAINER:
291          (slider.controlsContainer) ? $(slider.controlsContainer).append(slider.controlNavScaffold) : slider.append(slider.controlNavScaffold);
292          methods.controlNav.set();
293
294          methods.controlNav.active();
295
296          slider.controlNavScaffold.delegate('a, img', eventType, function(event) {
297            event.preventDefault();
298
299            if (watchedEvent === "" || watchedEvent === event.type) {
300              var $this = $(this),
301                  target = slider.controlNav.index($this);
302
303              if (!$this.hasClass(namespace + 'active')) {
304                slider.direction = (target > slider.currentSlide) ? "next" : "prev";
305                slider.flexAnimate(target, slider.vars.pauseOnAction);
306              }
307            }
308
309            // setup flags to prevent event duplication
310            if (watchedEvent === "") {
311              watchedEvent = event.type;
312            }
313            methods.setToClearWatchedEvent();
314
315          });
316        },
317        setupManual: function() {
318          slider.controlNav = slider.manualControls;
319          methods.controlNav.active();
320
321          slider.controlNav.bind(eventType, function(event) {
322            event.preventDefault();
323
324            if (watchedEvent === "" || watchedEvent === event.type) {
325              var $this = $(this),
326                  target = slider.controlNav.index($this);
327
328              if (!$this.hasClass(namespace + 'active')) {
329                (target > slider.currentSlide) ? slider.direction = "next" : slider.direction = "prev";
330                slider.flexAnimate(target, slider.vars.pauseOnAction);
331              }
332            }
333
334            // setup flags to prevent event duplication
335            if (watchedEvent === "") {
336              watchedEvent = event.type;
337            }
338            methods.setToClearWatchedEvent();
339          });
340        },
341        set: function() {
342          var selector = (slider.vars.controlNav === "thumbnails") ? 'img' : 'a';
343          slider.controlNav = $('.' + namespace + 'control-nav li ' + selector, (slider.controlsContainer) ? slider.controlsContainer : slider);
344        },
345        active: function() {
346          slider.controlNav.removeClass(namespace + "active").eq(slider.animatingTo).addClass(namespace + "active");
347        },
348        update: function(action, pos) {
349          if (slider.pagingCount > 1 && action === "add") {
350            slider.controlNavScaffold.append($('<li><a>' + slider.count + '</a></li>'));
351          } else if (slider.pagingCount === 1) {
352            slider.controlNavScaffold.find('li').remove();
353          } else {
354            slider.controlNav.eq(pos).closest('li').remove();
355          }
356          methods.controlNav.set();
357          (slider.pagingCount > 1 && slider.pagingCount !== slider.controlNav.length) ? slider.update(pos, action) : methods.controlNav.active();
358        }
359      },
360      directionNav: {
361        setup: function() {
362          var directionNavScaffold = $('<ul class="' + namespace + 'direction-nav"><li><a class="' + namespace + 'prev" href="#">' + slider.vars.prevText + '</a></li><li><a class="' + namespace + 'next" href="#">' + slider.vars.nextText + '</a></li></ul>');
363
364          // CONTROLSCONTAINER:
365          if (slider.controlsContainer) {
366            $(slider.controlsContainer).append(directionNavScaffold);
367            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider.controlsContainer);
368          } else {
369            slider.append(directionNavScaffold);
370            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider);
371          }
372
373          methods.directionNav.update();
374
375          slider.directionNav.bind(eventType, function(event) {
376            event.preventDefault();
377            var target;
378
379            if (watchedEvent === "" || watchedEvent === event.type) {
380              target = ($(this).hasClass(namespace + 'next')) ? slider.getTarget('next') : slider.getTarget('prev');
381              slider.flexAnimate(target, slider.vars.pauseOnAction);
382            }
383
384            // setup flags to prevent event duplication
385            if (watchedEvent === "") {
386              watchedEvent = event.type;
387            }
388            methods.setToClearWatchedEvent();
389          });
390        },
391        update: function() {
392          var disabledClass = namespace + 'disabled';
393          if (slider.pagingCount === 1) {
394            slider.directionNav.addClass(disabledClass).attr('tabindex', '-1');
395          } else if (!slider.vars.animationLoop) {
396            if (slider.animatingTo === 0) {
397              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "prev").addClass(disabledClass).attr('tabindex', '-1');
398            } else if (slider.animatingTo === slider.last) {
399              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "next").addClass(disabledClass).attr('tabindex', '-1');
400            } else {
401              slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
402            }
403          } else {
404            slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
405          }
406        }
407      },
408      pausePlay: {
409        setup: function() {
410          var pausePlayScaffold = $('<div class="' + namespace + 'pauseplay"><a></a></div>');
411
412          // CONTROLSCONTAINER:
413          if (slider.controlsContainer) {
414            slider.controlsContainer.append(pausePlayScaffold);
415            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider.controlsContainer);
416          } else {
417            slider.append(pausePlayScaffold);
418            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider);
419          }
420
421          methods.pausePlay.update((slider.vars.slideshow) ? namespace + 'pause' : namespace + 'play');
422
423          slider.pausePlay.bind(eventType, function(event) {
424            event.preventDefault();
425
426            if (watchedEvent === "" || watchedEvent === event.type) {
427              if ($(this).hasClass(namespace + 'pause')) {
428                slider.manualPause = true;
429                slider.manualPlay = false;
430                slider.pause();
431              } else {
432                slider.manualPause = false;
433                slider.manualPlay = true;
434                slider.play();
435              }
436            }
437
438            // setup flags to prevent event duplication
439            if (watchedEvent === "") {
440              watchedEvent = event.type;
441            }
442            methods.setToClearWatchedEvent();
443          });
444        },
445        update: function(state) {
446          (state === "play") ? slider.pausePlay.removeClass(namespace + 'pause').addClass(namespace + 'play').html(slider.vars.playText) : slider.pausePlay.removeClass(namespace + 'play').addClass(namespace + 'pause').html(slider.vars.pauseText);
447        }
448      },
449      touch: function() {
450        var startX,
451          startY,
452          offset,
453          cwidth,
454          dx,
455          startT,
456          scrolling = false,
457          localX = 0,
458          localY = 0,
459          accDx = 0;
460
461        if(!msGesture){
462            el.addEventListener('touchstart', onTouchStart, false);
463
464            function onTouchStart(e) {
465              if (slider.animating) {
466                e.preventDefault();
467              } else if ( ( window.navigator.msPointerEnabled ) || e.touches.length === 1 ) {
468                slider.pause();
469                // CAROUSEL:
470                cwidth = (vertical) ? slider.h : slider. w;
471                startT = Number(new Date());
472                // CAROUSEL:
473
474                // Local vars for X and Y points.
475                localX = e.touches[0].pageX;
476                localY = e.touches[0].pageY;
477
478                offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
479                         (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
480                         (carousel && slider.currentSlide === slider.last) ? slider.limit :
481                         (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
482                         (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
483                startX = (vertical) ? localY : localX;
484                startY = (vertical) ? localX : localY;
485
486                el.addEventListener('touchmove', onTouchMove, false);
487                el.addEventListener('touchend', onTouchEnd, false);
488              }
489            }
490
491            function onTouchMove(e) {
492              // Local vars for X and Y points.
493
494              localX = e.touches[0].pageX;
495              localY = e.touches[0].pageY;
496
497              dx = (vertical) ? startX - localY : startX - localX;
498              scrolling = (vertical) ? (Math.abs(dx) < Math.abs(localX - startY)) : (Math.abs(dx) < Math.abs(localY - startY));
499
500              var fxms = 500;
501
502              if ( ! scrolling || Number( new Date() ) - startT > fxms ) {
503                e.preventDefault();
504                if (!fade && slider.transitions) {
505                  if (!slider.vars.animationLoop) {
506                    dx = dx/((slider.currentSlide === 0 && dx < 0 || slider.currentSlide === slider.last && dx > 0) ? (Math.abs(dx)/cwidth+2) : 1);
507                  }
508                  slider.setProps(offset + dx, "setTouch");
509                }
510              }
511            }
512
513            function onTouchEnd(e) {
514              // finish the touch by undoing the touch session
515              el.removeEventListener('touchmove', onTouchMove, false);
516
517              if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
518                var updateDx = (reverse) ? -dx : dx,
519                    target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
520
521                if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
522                  slider.flexAnimate(target, slider.vars.pauseOnAction);
523                } else {
524                  if (!fade) slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true);
525                }
526              }
527              el.removeEventListener('touchend', onTouchEnd, false);
528
529              startX = null;
530              startY = null;
531              dx = null;
532              offset = null;
533            }
534        }else{
535            el.style.msTouchAction = "none";
536            el._gesture = new MSGesture();
537            el._gesture.target = el;
538            el.addEventListener("MSPointerDown", onMSPointerDown, false);
539            el._slider = slider;
540            el.addEventListener("MSGestureChange", onMSGestureChange, false);
541            el.addEventListener("MSGestureEnd", onMSGestureEnd, false);
542
543            function onMSPointerDown(e){
544                e.stopPropagation();
545                if (slider.animating) {
546                    e.preventDefault();
547                }else{
548                    slider.pause();
549                    el._gesture.addPointer(e.pointerId);
550                    accDx = 0;
551                    cwidth = (vertical) ? slider.h : slider. w;
552                    startT = Number(new Date());
553                    // CAROUSEL:
554
555                    offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
556                        (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
557                            (carousel && slider.currentSlide === slider.last) ? slider.limit :
558                                (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
559                                    (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
560                }
561            }
562
563            function onMSGestureChange(e) {
564                e.stopPropagation();
565                var slider = e.target._slider;

704      if (!slider.animating && (slider.canAdvance(target, fromNav) || override) && slider.is(":visible")) {
705        if (asNav && withSync) {
706          var master = $(slider.vars.asNavFor).data('flexslider');
707          slider.atEnd = target === 0 || target === slider.count - 1;
708          master.flexAnimate(target, true, false, true, fromNav);
709          slider.direction = (slider.currentItem < target) ? "next" : "prev";
710          master.direction = slider.direction;
711
712          if (Math.ceil((target + 1)/slider.visible) - 1 !== slider.currentSlide && target !== 0) {
713            slider.currentItem = target;
714            slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
715            target = Math.floor(target/slider.visible);
716          } else {
717            slider.currentItem = target;
718            slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
719            return false;
720          }
721        }
722
723        slider.animating = true;
724        slider.animatingTo = target;
725
726        // SLIDESHOW:
727        if (pause) slider.pause();
728
729        // API: before() animation Callback
730        slider.vars.before(slider);
731
732        // SYNC:
733        if (slider.syncExists && !fromNav) methods.sync("animate");
734
735        // CONTROLNAV
736        if (slider.vars.controlNav) methods.controlNav.active();
737
738        // !CAROUSEL:
739        // CANDIDATE: slide active class (for add/remove slide)
740        if (!carousel) slider.slides.removeClass(namespace + 'active-slide').eq(target).addClass(namespace + 'active-slide');
741
742        // INFINITE LOOP:
743        // CANDIDATE: atEnd
744        slider.atEnd = target === 0 || target === slider.last;
745
746        // DIRECTIONNAV:
747        if (slider.vars.directionNav) methods.directionNav.update();
748
749        if (target === slider.last) {
750          // API: end() of cycle Callback
751          slider.vars.end(slider);
752          // SLIDESHOW && !INFINITE LOOP:
753          if (!slider.vars.animationLoop) slider.pause();
754        }
755
756        // SLIDE:
757        if (!fade) {
758          var dimension = (vertical) ? slider.slides.filter(':first').height() : slider.computedW,
759              margin, slideString, calcNext;
760
761          // INFINITE LOOP / REVERSE:
762          if (carousel) {
763            //margin = (slider.vars.itemWidth > slider.w) ? slider.vars.itemMargin * 2 : slider.vars.itemMargin;
764            margin = slider.vars.itemMargin;
765            calcNext = ((slider.itemW + margin) * slider.move) * slider.animatingTo;
766            slideString = (calcNext > slider.limit && slider.visible !== 1) ? slider.limit : calcNext;
767          } else if (slider.currentSlide === 0 && target === slider.count - 1 && slider.vars.animationLoop && slider.direction !== "next") {
768            slideString = (reverse) ? (slider.count + slider.cloneOffset) * dimension : 0;
769          } else if (slider.currentSlide === slider.last && target === 0 && slider.vars.animationLoop && slider.direction !== "prev") {
770            slideString = (reverse) ? 0 : (slider.count + 1) * dimension;
771          } else {
772            slideString = (reverse) ? ((slider.count - 1) - target + slider.cloneOffset) * dimension : (target + slider.cloneOffset) * dimension;
773          }
774          slider.setProps(slideString, "", slider.vars.animationSpeed);
775          if (slider.transitions) {
776            if (!slider.vars.animationLoop || !slider.atEnd) {
777              slider.animating = false;
778              slider.currentSlide = slider.animatingTo;
779            }
780            slider.container.unbind("webkitTransitionEnd transitionend");
781            slider.container.bind("webkitTransitionEnd transitionend", function() {
782              slider.wrapup(dimension);
783            });
784          } else {
785            slider.container.animate(slider.args, slider.vars.animationSpeed, slider.vars.easing, function(){
786              slider.wrapup(dimension);
787            });
788          }
789        } else { // FADE:
790          if (!touch) {
791            //slider.slides.eq(slider.currentSlide).fadeOut(slider.vars.animationSpeed, slider.vars.easing);
792            //slider.slides.eq(target).fadeIn(slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
793
794            slider.slides.eq(slider.currentSlide).css({"zIndex": 1}).animate({"opacity": 0}, slider.vars.animationSpeed, slider.vars.easing);
795            slider.slides.eq(target).css({"zIndex": 2}).animate({"opacity": 1}, slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
796
797          } else {
798            slider.slides.eq(slider.currentSlide).css({ "opacity": 0, "zIndex": 1 });
799            slider.slides.eq(target).css({ "opacity": 1, "zIndex": 2 });
800            slider.wrapup(dimension);
801          }
802        }
803        // SMOOTH HEIGHT:
804        if (slider.vars.smoothHeight) methods.smoothHeight(slider.vars.animationSpeed);
805      }
806    }
807    slider.wrapup = function(dimension) {
808      // SLIDE:
809      if (!fade && !carousel) {
810        if (slider.currentSlide === 0 && slider.animatingTo === slider.last && slider.vars.animationLoop) {
811          slider.setProps(dimension, "jumpEnd");
812        } else if (slider.currentSlide === slider.last && slider.animatingTo === 0 && slider.vars.animationLoop) {
813          slider.setProps(dimension, "jumpStart");
814        }
815      }
816      slider.animating = false;

929der.slides.last().clone().addClass('clone').attr('aria-hidden', 'true'));
930        }
931        slider.newSlides = $(slider.vars.selector, slider);
932
933        sliderOffset = (reverse) ? slider.count - 1 - slider.currentSlide + slider.cloneOffset : slider.currentSlide + slider.cloneOffset;
934        // VERTICAL:
935        if (vertical && !carousel) {
936          slider.container.height((slider.count + slider.cloneCount) * 200 + "%").css("position", "absolute").width("100%");
937          setTimeout(function(){
938            slider.newSlides.css({"display": "block"});
939            slider.doMath();
940            slider.viewport.height(slider.h);
941            slider.setProps(sliderOffset * slider.h, "init");
942          }, (type === "init") ? 100 : 0);
943        } else {
944          slider.container.width((slider.count + slider.cloneCount) * 200 + "%");
945          slider.setProps(sliderOffset * slider.computedW, "init");
946          setTimeout(function(){
947            slider.doMath();
948            slider.newSlides.css({"width": slider.computedW, "float": "left", "display": "block"});
949            // SMOOTH HEIGHT:
950            if (slider.vars.smoothHeight) methods.smoothHeight();
951          }, (type === "init") ? 100 : 0);
952        }
953      } else { // FADE:
954        slider.slides.css({"width": "100%", "float": "left", "marginRight": "-100%", "position": "relative"});
955        if (type === "init") {
956          if (!touch) {
957            //slider.slides.eq(slider.currentSlide).fadeIn(slider.vars.animationSpeed, slider.vars.easing);
958            slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).animate({"opacity": 1},slider.vars.animationSpeed,slider.vars.easing);
959          } else {
960            slider.slides.css({ "opacity": 0, "display": "block", "webkitTransition": "opacity " + slider.vars.animationSpeed / 1000 + "s ease", "zIndex": 1 }).eq(slider.currentSlide).css({ "opacity": 1, "zIndex": 2});
961          }
962        }
963        // SMOOTH HEIGHT:
964        if (slider.vars.smoothHeight) methods.smoothHeight();
965      }
966      // !CAROUSEL:
967      // CANDIDATE: active slide
968      if (!carousel) slider.slides.removeClass(namespace + "active-slide").eq(slider.currentSlide).addClass(namespace + "active-slide");
969    }
970
971
972    slider.doMath = function() {
973      var slide = slider.slides.first(),
974          slideMargin = slider.vars.itemMargin,
975          minItems = slider.vars.minItems,
976          maxItems = slider.vars.maxItems;
977
978      slider.w = (slider.viewport===undefined) ? slider.width() : slider.viewport.width();
979      slider.h = slide.height();
980      slider.boxPadding = slide.outerWidth() - slide.width();
981
982      // CAROUSEL:
983      if (carousel) {
984        slider.itemT = slider.vars.itemWidth + slideMargin;
985        slider.minW = (minItems) ? minItems * slider.itemT : slider.w;
986        slider.maxW = (maxItems) ? (maxItems * slider.itemT) - slideMargin : slider.w;
987        slider.itemW = (slider.minW > slider.w) ? (slider.w - (slideMargin * (minItems - 1)))/minItems :
988                       (slider.maxW < slider.w) ? (slider.w - (slideMargin * (maxItems - 1)))/maxItems :
989                       (slider.vars.itemWidth > slider.w) ? slider.w : slider.vars.itemWidth;
990
991        slider.visible = Math.floor(slider.w/(slider.itemW));
992        slider.move = (slider.vars.move > 0 && slider.vars.move < slider.visible ) ? slider.vars.move : slider.visible;
993        slider.pagingCount = Math.ceil(((slider.count - slider.visible)/slider.move) + 1);
994        slider.last =  slider.pagingCount - 1;
995        slider.limit = (slider.pagingCount === 1) ? 0 :
996                       (slider.vars.itemWidth > slider.w) ? (slider.itemW * (slider.count - 1)) + (slideMargin * (slider.count - 1)) : ((slider.itemW + slideMargin) * slider.count) - slider.w - slideMargin;
997      } else {
998        slider.itemW = slider.w;
999        slider.pagingCount = slider.count;
1000        slider.last = slider.count - 1;
1001      }
1002      slider.computedW = slider.itemW - slider.boxPadding;
1003    }
1004
1005
1006    slider.update = function(pos, action) {
1007      slider.doMath();
1008
1009      // update currentSlide and slider.animatingTo if necessary
1010      if (!carousel) {
1011        if (pos < slider.currentSlide) {
1012          slider.currentSlide += 1;
1013        } else if (pos <= slider.currentSlide && pos !== 0) {
1014          slider.currentSlide -= 1;
1015        }
1016        slider.animatingTo = slider.currentSlide;
1017      }
1018
1019      // update controlNav
1020      if (slider.vars.controlNav && !slider.manualControls) {
1021        if ((action === "add" && !carousel) || slider.pagingCount > slider.controlNav.length) {
1022          methods.controlNav.update("add");
1023        } else if ((action === "remove" && !carousel) || slider.pagingCount < slider.controlNav.length) {
1024          if (carousel && slider.currentSlide > slider.last) {
1025            slider.currentSlide -= 1;
1026            slider.animatingTo -= 1;
1027          }
1028          methods.controlNav.update("remove", slider.last);
1029        }
1030      }
1031      // update directionNav
1032      if (slider.vars.directionNav) methods.directionNav.update();
1033
1034    }
1035
1036    slider.addSlide = function(obj, pos) {
1037      var $obj = $(obj);
1038
1039      slider.count += 1;
1040      slider.last = slider.count - 1;
1041
1042      // append new slide
1043      if (vertical && reverse) {
1044        (pos !== undefined) ? slider.slides.eq(slider.count - pos).after($obj) : slider.container.prepend($obj);
1045      } else {
1046        (pos !== undefined) ? slider.slides.eq(pos).before($obj) : slider.container.append($obj);
1047      }
1048
1049      // update currentSlide, animatingTo, controlNav, and directionNav
1050      slider.update(pos, "add");
1051
1052      // update slider.slides
1053      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
1054      // re-setup the slider to accomdate new slide
1055      slider.setup();
1056
1057      //FlexSlider: added() Callback
1058      slider.vars.added(slider);
1059    }
1060    slider.removeSlide = function(obj) {
1061      var pos = (isNaN(obj)) ? slider.slides.index($(obj)) : obj;
1062
1063      // update count
1064      slider.count -= 1;
1065      slider.last = slider.count - 1;
1066
1067      // remove slide
1068      if (isNaN(obj)) {
1069        $(obj, slider.slides).remove();
1070      } else {
1071        (vertical && reverse) ? slider.slides.eq(slider.last).remove() : slider.slides.eq(obj).remove();
1072      }
1073
1074      // update currentSlide, animatingTo, controlNav, and directionNav
1075      slider.doMath();
1076      slider.update(pos, "remove");
1077
1078      // update slider.slides
1079      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
1080      // re-setup the slider to accomdate new slide
1081      slider.setup();
1082
1083      // FlexSlider: removed() Callback
1084      slider.vars.removed(slider);
1085    }
1086
1087    //FlexSlider: Initialize
1088    methods.init();
1089  }
1090
1091  // Ensure the slider isn't focussed if the window loses focus.
1092  $( window ).blur( function ( e ) {
1093    focused = false;
1094  }).focus( function ( e ) {
1095    focused = true;
1096  });
1097
1098  //FlexSlider: Default Settings
1099  $.flexslider.defaults = {
1100    namespace: "flex-",             //{NEW} String: Prefix string attached to the class of every element generated by the plugin
1101    selector: ".slides > li",       //{NEW} Selector: Must match a simple pattern. '{container} > {slide}' -- Ignore pattern at your own peril
1102    animation: "fade",              //String: Select your animation type, "fade" or "slide"
1103    easing: "swing",                //{NEW} String: Determines the easing method used in jQuery transitions. jQuery easing plugin is supported!
1104    direction: "horizontal",        //String: Select the sliding direction, "horizontal" or "vertical"
1105    reverse: false,                 //{NEW} Boolean: Reverse the animation direction
1106    animationLoop: true,            //Boolean: Should the animation loop? If false, directionNav will received "disable" classes at either end
1107    smoothHeight: false,            //{NEW} Boolean: Allow height of the slider to animate smoothly in horizontal mode
1108    startAt: 0,                     //Integer: The slide that the slider should start on. Array notation (0 = first slide)
1109    slideshow: true,                //Boolean: Animate slider automatically
1110    slideshowSpeed: 7000,           //Integer: Set the speed of the slideshow cycling, in milliseconds
1111    animationSpeed: 600,            //Integer: Set the speed of animations, in milliseconds
1112    initDelay: 0,                   //{NEW} Integer: Set an initialization delay, in milliseconds
1113    randomize: false,               //Boolean: Randomize slide order
1114    thumbCaptions: false,           //Boolean: Whether or not to put captions on thumbnails when using the "thumbnails" controlNav.
1115
1116    // Usability features
1117    pauseOnAction: true,            //Boolean: Pause the slideshow when interacting with control elements, highly recommended.
1118    pauseOnHover: false,            //Boolean: Pause the slideshow when hovering over slider, then resume when no longer hovering
1119    pauseInvisible: true,   		//{NEW} Boolean: Pause the slideshow when tab is invisible, resume when visible. Provides better UX, lower CPU usage.
1120    useCSS: true,                   //{NEW} Boolean: Slider will use CSS3 transitions if available
1121    touch: true,                    //{NEW} Boolean: Allow touch swipe navigation of the slider on touch-enabled devices
1122    video: false,                   //{NEW} Boolean: If using video in the slider, will prevent CSS3 3D Transforms to avoid graphical glitches
1123
1124    // Primary Controls
1125    controlNav: true,               //Boolean: Create navigation for paging control of each clide? Note: Leave true for manualControls usage
1126    directionNav: true,             //Boolean: Create navigation for previous/next navigation? (true/false)
1127    prevText: "Previous",           //String: Set the text for the "previous" directionNav item
1128    nextText: "Next",               //String: Set the text for the "next" directionNav item
1129
1130    // Secondary Navigation
1131    keyboard: true,                 //Boolean: Allow slider navigating via keyboard left/right keys
1132    multipleKeyboard: false,        //{NEW} Boolean: Allow keyboard navigation to affect multiple sliders. Default behavior cuts out keyboard navigation with more than one slider present.
1133    mousewheel: false,              //{UPDATED} Boolean: Requires jquery.mousewheel.js (https://github.com/brandonaaron/jquery-mousewheel) - Allows slider navigating via mousewheel

1258				}
1259			});
1260		} else {
1261			this.each(function() {
1262				var instance = $(this).data( name );
1263				if ( instance ) {
1264					// instance.option( options || {} )._init(); // Orig jquery.ui.widget.js code: Not recommend for jPlayer. ie., Applying new options to an existing instance (via the jPlayer constructor) and performing the _init(). The _init() is what concerns me. It would leave a lot of event handlers acting on jPlayer instance and the interface.
1265					instance.option( options || {} ); // The new constructor only changes the options. Changing options only has basic support atm.
1266				} else {
1267					$(this).data( name, new $.jPlayer( options, this ) );
1268				}
1269			});
1270		}
1271
1272		return returnValue;
1273	};
1274
1275	$.jPlayer = function( options, element ) {
1276		// allow instantiation without initializing for simple inheritance
1277		if ( arguments.length ) {
1278			this.element = $(element);
1279			this.options = $.extend(true, {},
1280				this.options,
1281				options
1282			);
1283			var self = this;
1284			this.element.bind( "remove.jPlayer", function() {
1285				self.destroy();
1286			});
1287			this._init();
1288		}
1289	};
1290	// End of: (Adapted from jquery.ui.widget.js (1.8.7))
1291
1292	// Zepto is missing one of the animation methods.
1293	if(typeof $.fn.stop !== 'function') {
1294		$.fn.stop = function() {};
1295	}
1296
1297	// Emulated HTML5 methods and properties
1298	$.jPlayer.emulateMethods = "load play pause";
1299	$.jPlayer.emulateStatus = "src readyState networkState currentTime duration paused ended playbackRate";
1300	$.jPlayer.emulateOptions = "muted volume";
1301
1302	// Reserved event names generated by jPlayer that are not part of the HTML5 Media element spec
1303	$.jPlayer.reservedEvent = "ready flashreset resize repeat error warning";
1304
1305	// Events generated by jPlayer
1306	$.jPlayer.event = {};
1307	$.each(
1308		[
1309			'ready',
1310			'setmedia', // Fires when the media is set
1311			'flashreset', // Similar to the ready event if the Flash solution is set to display:none and then shown again or if it's reloaded for another reason by the browser. For example, using CSS position:fixed on Firefox for the full screen feature.
1312			'resize', // Occurs when the size changes through a full/restore screen operation or if the size/sizeFull options are changed.
1313			'repeat', // Occurs when the repeat status changes. Usually through clicks on the repeat button of the interface.
1314			'click', // Occurs when the user clicks on one of the following: poster image, html video, flash video.
1315			'error', // Event error code in event.jPlayer.error.type. See $.jPlayer.error
1316			'warning', // Event warning code in event.jPlayer.warning.type. See $.jPlayer.warning
1317
1318			// Other events match HTML5 spec.
1319			'loadstart',
1320			'progress',
1321			'suspend',
1322			'abort',
1323			'emptied',
1324			'stalled',
1325			'play',
1326			'pause',
1327			'loadedmetadata',
1328			'loadeddata',
1329			'waiting',
1330			'playing',
1331			'canplay',
1332			'canplaythrough',
1333			'seeking',
1334			'seeked',
1335			'timeupdate',
1336			'ended',
1337			'ratechange',
1338			'durationchange',
1339			'volumechange'
1340		],
1341		function() {
1342			$.jPlayer.event[ this ] = 'jPlayer_' + this;
1343		}
1344	);
1345
1346	$.jPlayer.htmlEvent = [ // These HTML events are bubbled through to the jPlayer event, without any internal action.
1347		"loadstart",
1348		// "progress", // jPlayer uses internally before bubbling.
1349		// "suspend", // jPlayer uses internally before bubbling.
1350		"abort",
1351		// "error", // jPlayer uses internally before bubbling.
1352		"emptied",
1353		"stalled",
1354		// "play", // jPlayer uses internally before bubbling.
1355		// "pause", // jPlayer uses internally before bubbling.
1356		"loadedmetadata",
1357		"loadeddata",
1358		// "waiting", // jPlayer uses internally before bubbling.
1359		// "playing", // jPlayer uses internally before bubbling.
1360		"canplay",
1361		"canplaythrough"
1362		// "seeking", // jPlayer uses internally before bubbling.
1363		// "seeked", // jPlayer uses internally before bubbling.
1364		// "timeupdate", // jPlayer uses internally before bubbling.
1365		// "ended", // jPlayer uses internally before bubbling.
1366		// "ratechange" // jPlayer uses internally before bubbling.
1367		// "durationchange" // jPlayer uses internally before bubbling.
1368		// "volumechange" // jPlayer uses internally before bubbling.
1369	];
1370
1371	$.jPlayer.pause = function() {
1372		$.each($.jPlayer.prototype.instances, function(i, element) {
1373			if(element.data("jPlayer").status.srcSet) { // Check that media is set otherwise would cause error event.
1374				element.jPlayer("pause");
1375			}
1376		});
1377	};
1378
1379	// Default for jPlayer option.timeFormat
1380	$.jPlayer.timeFormat = {
1381		showHour: false,
1382		showMin: true,
1383		showSec: true,
1384		padHour: false,
1385		padMin: true,
1386		padSec: true,
1387		sepHour: ":",
1388		sepMin: ":",
1389		sepSec: ""
1390	};
1391	var ConvertTime = function() {
1392		this.init();
1393	};
1394	ConvertTime.prototype = {
1395		init: function() {
1396			this.options = {
1397				timeFormat: $.jPlayer.timeFormat
1398			};
1399		},
1400		time: function(s) { // function used on jPlayer.prototype._convertTime to enable per instance options.
1401			s = (s && typeof s === 'number') ? s : 0;
1402
1403			var myTime = new Date(s * 1000),
1404				hour = myTime.getUTCHours(),
1405				min = this.options.timeFormat.showHour ? myTime.getUTCMinutes() : myTime.getUTCMinutes() + hour * 60,
1406				sec = this.options.timeFormat.showMin ? myTime.getUTCSeconds() : myTime.getUTCSeconds() + min * 60,
1407				strHour = (this.options.timeFormat.padHour && hour < 10) ? "0" + hour : hour,
1408				strMin = (this.options.timeFormat.padMin && min < 10) ? "0" + min : min,
1409				strSec = (this.options.timeFormat.padSec && sec < 10) ? "0" + sec : sec,
1410				strTime = "";
1411
1412			strTime += this.options.timeFormat.showHour ? strHour + this.options.timeFormat.sepHour : "";
1413			strTime += this.options.timeFormat.showMin ? strMin + this.options.timeFormat.sepMin : "";
1414			strTime += this.options.timeFormat.showSec ? strSec + this.options.timeFormat.sepSec : "";
1415
1416			return strTime;
1417		}
1418	};
1419	var myConvertTime = new ConvertTime();
1420	$.jPlayer.convertTime = function(s) {
1421		return myConvertTime.time(s);
1422	};
1423
1424	// Adapting jQuery 1.4.4 code for jQuery.browser. Required since jQuery 1.3.2 does not detect Chrome as webkit.
1425	$.jPlayer.uaBrowser = function( userAgent ) {
1426		var ua = userAgent.toLowerCase();
1427
1428		// Useragent RegExp
1429		var rwebkit = /(webkit)[ \/]([\w.]+)/;
1430		var ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/;
1431		var rmsie = /(msie) ([\w.]+)/;
1432		var rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/;
1433
1434		var match = rwebkit.exec( ua ) ||
1435			ropera.exec( ua ) ||
1436			rmsie.exec( ua ) ||
1437			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
1438			[];
1439
1440		return { browser: match[1] || "", version: match[2] || "0" };
1441	};
1442
1443	// Platform sniffer for detecting mobile devices
1444	$.jPlayer.uaPlatform = function( userAgent ) {
1445		var ua = userAgent.toLowerCase();
1446
1447		// Useragent RegExp
1448		var rplatform = /(ipad|iphone|ipod|android|blackberry|playbook|windows ce|webos)/;
1449		var rtablet = /(ipad|playbook)/;
1450		var randroid = /(android)/;
1451		var rmobile = /(mobile)/;
1452
1453		var platform = rplatform.exec( ua ) || [];
1454		var tablet = rtablet.exec( ua ) ||
1455			!rmobile.exec( ua ) && randroid.exec( ua ) ||
1456			[];
1457
1458		if(platform[1]) {
1459			platform[1] = platform[1].replace(/\s/g, "_"); // Change whitespace to underscore. Enables dot notation.
1460		}
1461
1462		return { platform: platform[1] || "", tablet: tablet[1] || "" };
1463	};
1464
1465	$.jPlayer.browser = {
1466	};
1467	$.jPlayer.platform = {
1468	};
1469
1470	var browserMatch = $.jPlayer.uaBrowser(navigator.userAgent);
1471	if ( browserMatch.browser ) {
1472		$.jPlayer.browser[ browserMatch.browser ] = true;
1473		$.jPlayer.browser.version = browserMatch.version;
1474	}
1475	var platformMatch = $.jPlayer.uaPlatform(navigator.userAgent);
1476	if ( platformMatch.platform ) {
1477		$.jPlayer.platform[ platformMatch.platform ] = true;
1478		$.jPlayer.platform.mobile = !platformMatch.tablet;
1479		$.jPlayer.platform.tablet = !!platformMatch.tablet;
1480	}
1481
1482	// Internet Explorer (IE) Browser Document Mode Sniffer. Based on code at:
1483	// http://msdn.microsoft.com/en-us/library/cc288325%28v=vs.85%29.aspx#GetMode
1484	$.jPlayer.getDocMode = function() {
1485		var docMode;
1486		if ($.jPlayer.browser.msie) {
1487			if (document.documentMode) { // IE8 or later
1488				docMode = document.documentMode;
1489			} else { // IE 5-7
1490				docMode = 5; // Assume quirks mode unless proven otherwise
1491				if (document.compatMode) {
1492					if (document.compatMode === "CSS1Compat") {
1493						docMode = 7; // standards mode
1494					}
1495				}
1496			}
1497		}
1498		return docMode;
1499	};
1500	$.jPlayer.browser.documentMode = $.jPlayer.getDocMode();
1501
1502	$.jPlayer.nativeFeatures = {
1503		init: function() {
1504
1505			/* Fullscreen function naming influenced by W3C naming.
1506			 * No support for: Mozilla Proposal: https://wiki.mozilla.org/Gecko:FullScreenAPI
1507			 */
1508
1509			var d = document,
1510				v = d.createElement('video'),
1511				spec = {
1512					// http://www.w3.org/TR/fullscreen/
1513					w3c: [
1514						'fullscreenEnabled',
1515						'fullscreenElement',
1516						'requestFullscreen',
1517						'exitFullscreen',
1518						'fullscreenchange',
1519						'fullscreenerror'
1520					],
1521					// https://developer.mozilla.org/en-US/docs/DOM/Using_fullscreen_mode
1522					moz: [
1523						'mozFullScreenEnabled',
1524						'mozFullScreenElement',
1525						'mozRequestFullScreen',
1526						'mozCancelFullScreen',
1527						'mozfullscreenchange',
1528						'mozfullscreenerror'
1529					],
1530					// http://developer.apple.com/library/safari/#documentation/WebKit/Reference/ElementClassRef/Element/Element.html
1531					// http://developer.apple.com/library/safari/#documentation/UserExperience/Reference/DocumentAdditionsReference/DocumentAdditions/DocumentAdditions.html
1532					webkit: [
1533						'',
1534						'webkitCurrentFullScreenElement',
1535						'webkitRequestFullScreen',
1536						'webkitCancelFullScreen',
1537						'webkitfullscreenchange',
1538						''
1539					],
1540					// http://developer.apple.com/library/safari/#documentation/AudioVideo/Reference/HTMLVideoElementClassReference/HTMLVideoElement/HTMLVideoElement.html
1541					// https://developer.apple.com/library/safari/samplecode/HTML5VideoEventFlow/Listings/events_js.html#//apple_ref/doc/uid/DTS40010085-events_js-DontLinkElementID_5
1542					// Events: 'webkitbeginfullscreen' and 'webkitendfullscreen'
1543					webkitVideo: [
1544						'webkitSupportsFullscreen',
1545						'webkitDisplayingFullscreen',
1546						'webkitEnterFullscreen',
1547						'webkitExitFullscreen',
1548						'',
1549						''
1550					]
1551				},
1552				specOrder = [
1553					'w3c',
1554					'moz',
1555					'webkit',
1556					'webkitVideo'
1557				],
1558				fs, i, il;
1559
1560			this.fullscreen = fs = {
1561				support: {
1562					w3c: !!d[spec.w3c[0]],
1563					moz: !!d[spec.moz[0]],
1564					webkit: typeof d[spec.webkit[3]] === 'function',
1565					webkitVideo: typeof v[spec.webkitVideo[2]] === 'function'
1566				},
1567				used: {}
1568			};
1569
1570			// Store the name of the spec being used and as a handy boolean.
1571			for(i = 0, il = specOrder.length; i < il; i++) {
1572				var n = specOrder[i];
1573				if(fs.support[n]) {
1574					fs.spec = n;
1575					fs.used[n] = true;
1576					break;
1577				}
1578			}
1579
1580			if(fs.spec) {
1581				var s = spec[fs.spec];
1582				fs.api = {
1583					fullscreenEnabled: true,
1584					fullscreenElement: function(elem) {
1585						elem = elem ? elem : d; // Video element required for webkitVideo
1586						return elem[s[1]];
1587					},
1588					requestFullscreen: function(elem) {
1589						return elem[s[2]]();
1590					},
1591					exitFullscreen: function(elem) {
1592						elem = elem ? elem : d; // Video element required for webkitVideo
1593						return elem[s[3]]();
1594					}
1595				};
1596				fs.event = {
1597					fullscreenchange: s[4],
1598					fullscreenerror: s[5]
1599				};
1600			} else {
1601				fs.api = {
1602					fullscreenEnabled: false,
1603					fullscreenElement: function() {
1604						return null;
1605					},
1606					requestFullscreen: function() {},
1607					exitFullscreen: function() {}
1608				};
1609				fs.event = {};
1610			}
1611		}
1612	};
1613	$.jPlayer.nativeFeatures.init();
1614
1615	// The keyboard control system.
1616
1617	// The current jPlayer instance in focus.
1618	$.jPlayer.focus = null;
1619
1620	// The list of element node names to ignore with key controls.
1621	$.jPlayer.keyIgnoreElementNames = "INPUT TEXTAREA";
1622
1623	// The function that deals with key presses.
1624	var keyBindings = function(event) {
1625
1626		var f = $.jPlayer.focus,
1627			ignoreKey;
1628
1629		// A jPlayer instance must be in focus. ie., keyEnabled and the last one played.
1630		if(f) {
1631			// What generated the key press?
1632			$.each( $.jPlayer.keyIgnoreElementNames.split(/\s+/g), function(i, name) {
1633				// The strings should already be uppercase.
1634				if(event.target.nodeName.toUpperCase() === name.toUpperCase()) {
1635					ignoreKey = true;
1636					return false; // exit each.
1637				}
1638			});
1639			if(!ignoreKey) {
1640				// See if the key pressed matches any of the bindings.
1641				$.each(f.options.keyBindings, function(action, binding) {
1642					// The binding could be a null when the default has been disabled. ie., 1st clause in if()
1643					if(binding && event.which === binding.key && $.isFunction(binding.fn)) {
1644						event.preventDefault(); // Key being used by jPlayer, so prevent default operation.
1645						binding.fn(f);
1646						return false; // exit each.
1647					}
1648				});
1649			}
1650		}
1651	};
1652
1653	$.jPlayer.keys = function(en) {
1654		var event = "keydown.jPlayer";
1655		// Remove any binding, just in case enabled more than once.
1656		$(document.documentElement).unbind(event);
1657		if(en) {
1658			$(document.documentElement).bind(event, keyBindings);
1659		}
1660	};
1661
1662	// Enable the global key control handler ready for any jPlayer instance with the keyEnabled option enabled.
1663	$.jPlayer.keys(true);
1664
1665	$.jPlayer.prototype = {
1666		count: 0, // Static Variable: Change it via prototype.
1667		version: { // Static Object
1668			script: "2.6.1",
1669			needFlash: "2.6.0",
1670			flash: "unknown"
1671		},
1672		options: { // Instanced in $.jPlayer() constructor
1673			swfPath: "js", // Path to Jplayer.swf. Can be relative, absolute or server root relative.
1674			solution: "html, flash", // Valid solutions: html, flash. Order defines priority. 1st is highest,
1675			supplied: "mp3", // Defines which formats jPlayer will try and support and the priority by the order. 1st is highest,
1676			preload: 'metadata',  // HTML5 Spec values: none, metadata, auto.
1677			volume: 0.8, // The volume. Number 0 to 1.
1678			muted: false,
1679			remainingDuration: false, // When true, the remaining time is shown in the duration GUI element.
1680			toggleDuration: false, // When true, clicks on the duration toggle between the duration and remaining display.
1681			captureDuration: true, // When true, clicks on the duration are captured and no longer propagate up the DOM.
1682			playbackRate: 1,
1683			defaultPlaybackRate: 1,
1684			minPlaybackRate: 0.5,
1685			maxPlaybackRate: 4,
1686			wmode: "opaque", // Valid wmode: window, transparent, opaque, direct, gpu.
1687			backgroundColor: "#000000", // To define the jPlayer div and Flash background color.
1688			cssSelectorAncestor: "#jp_container_1",
1689			cssSelector: { // * denotes properties that should only be required when video media type required. _cssSelector() would require changes to enable splitting these into Audio and Video defaults.
1690				videoPlay: ".jp-video-play", // *
1691				play: ".jp-play",
1692				pause: ".jp-pause",
1693				stop: ".jp-stop",
1694				seekBar: ".jp-seek-bar",
1695				playBar: ".jp-play-bar",
1696				mute: ".jp-mute",
1697				unmute: ".jp-unmute",
1698				volumeBar: ".jp-volume-bar",
1699				volumeBarValue: ".jp-volume-bar-value",
1700				volumeMax: ".jp-volume-max",
1701				playbackRateBar: ".jp-playback-rate-bar",
1702				playbackRateBarValue: ".jp-playback-rate-bar-value",
1703				currentTime: ".jp-current-time",
1704				duration: ".jp-duration",
1705				title: ".jp-title",
1706				fullScreen: ".jp-full-screen", // *
1707				restoreScreen: ".jp-restore-screen", // *
1708				repeat: ".jp-repeat",
1709				repeatOff: ".jp-repeat-off",
1710				gui: ".jp-gui", // The interface used with autohide feature.
1711				noSolution: ".jp-no-solution" // For error feedback when jPlayer cannot find a solution.
1712			},
1713			smoothPlayBar: false, // Smooths the play bar transitions, which affects clicks and short media with big changes per second.
1714			fullScreen: false, // Native Full Screen
1715			fullWindow: false,
1716			autohide: {
1717				restored: false, // Controls the interface autohide feature.
1718				full: true, // Controls the interface autohide feature.
1719				fadeIn: 200, // Milliseconds. The period of the fadeIn anim.
1720				fadeOut: 600, // Milliseconds. The period of the fadeOut anim.
1721				hold: 1000 // Milliseconds. The period of the pause before autohide beings.
1722			},
1723			loop: false,
1724			repeat: function(event) { // The default jPlayer repeat event handler
1725				if(event.jPlayer.options.loop) {
1726					$(this).unbind(".jPlayerRepeat").bind($.jPlayer.event.ended + ".jPlayer.jPlayerRepeat", function() {
1727						$(this).jPlayer("play");
1728					});
1729				} else {
1730					$(this).unbind(".jPlayerRepeat");
1731				}
1732			},
1733			nativeVideoControls: {
1734				// Works well on standard browsers.
1735				// Phone and tablet browsers can have problems with the controls disappearing.
1736			},
1737			noFullWindow: {
1738				msie: /msie [0-6]\./,
1739				ipad: /ipad.*?os [0-4]\./,
1740				iphone: /iphone/,
1741				ipod: /ipod/,
1742				android_pad: /android [0-3]\.(?!.*?mobile)/,
1743				android_phone: /android.*?mobile/,
1744				blackberry: /blackberry/,
1745				windows_ce: /windows ce/,
1746				iemobile: /iemobile/,
1747				webos: /webos/
1748			},
1749			noVolume: {
1750				ipad: /ipad/,
1751				iphone: /iphone/,
1752				ipod: /ipod/,
1753				android_pad: /android(?!.*?mobile)/,
1754				android_phone: /android.*?mobile/,
1755				blackberry: /blackberry/,
1756				windows_ce: /windows ce/,
1757				iemobile: /iemobile/,
1758				webos: /webos/,
1759				playbook: /playbook/
1760			},
1761			timeFormat: {
1762				// Specific time format for this instance. The supported options are defined in $.jPlayer.timeFormat
1763				// For the undefined options we use the default from $.jPlayer.timeFormat
1764			},
1765			keyEnabled: false, // Enables keyboard controls.
1766			audioFullScreen: false, // Enables keyboard controls to enter full screen with audio media.
1767			keyBindings: { // The key control object, defining the key codes and the functions to execute.
1768				// The parameter, f = $.jPlayer.focus, will be checked truethy before attempting to call any of these functions.
1769				// Properties may be added to this object, in key/fn pairs, to enable other key controls. EG, for the playlist add-on.
1770				play: {
1771					key: 32, // space
1772					fn: function(f) {
1773						if(f.status.paused) {
1774							f.play();
1775						} else {
1776							f.pause();
1777						}
1778					}
1779				},
1780				fullScreen: {
1781					key: 13, // enter
1782					fn: function(f) {
1783						if(f.status.video || f.options.audioFullScreen) {
1784							f._setOption("fullScreen", !f.options.fullScreen);
1785						}
1786					}
1787				},
1788				muted: {
1789					key: 8, // backspace
1790					fn: function(f) {
1791						f._muted(!f.options.muted);
1792					}
1793				},
1794				volumeUp: {
1795					key: 38, // UP
1796					fn: function(f) {

1957				flashCanPlay: false,
1958				media: 'video'
1959			},
1960			webmv: { // WEBM
1961				codec: 'video/webm; codecs="vorbis, vp8"',
1962				flashCanPlay: false,
1963				media: 'video'
1964			},
1965			flv: { // FLV / F4V
1966				codec: 'video/x-flv',
1967				flashCanPlay: true,
1968				media: 'video'
1969			},
1970			rtmpv: { // RTMP VIDEO
1971				codec: 'video/rtmp; codecs="rtmp"',
1972				flashCanPlay: true,
1973				media: 'video'
1974			}
1975		},
1976		_init: function() {
1977			var self = this;
1978
1979			this.element.empty();
1980
1981			this.status = $.extend({}, this.status); // Copy static to unique instance.
1982			this.internal = $.extend({}, this.internal); // Copy static to unique instance.
1983
1984			// Initialize the time format
1985			this.options.timeFormat = $.extend({}, $.jPlayer.timeFormat, this.options.timeFormat);
1986
1987			// On iOS, assume commands will be ignored before user initiates them.
1988			this.internal.cmdsIgnored = $.jPlayer.platform.ipad || $.jPlayer.platform.iphone || $.jPlayer.platform.ipod;
1989
1990			this.internal.domNode = this.element.get(0);
1991
1992			// Add key bindings focus to 1st jPlayer instanced with key control enabled.
1993			if(this.options.keyEnabled && !$.jPlayer.focus) {
1994				$.jPlayer.focus = this;
1995			}
1996
1997			// A fix for Android where older (2.3) and even some 4.x devices fail to work when changing the *audio* SRC and then playing immediately.
1998			this.androidFix = {
1999				setMedia: false, // True when media set
2000				play: false, // True when a progress event will instruct the media to play
2001				pause: false, // True when a progress event will instruct the media to pause at a time.
2002				time: NaN // The play(time) parameter
2003			};
2004			if($.jPlayer.platform.android) {
2005				this.options.preload = this.options.preload !== 'auto' ? 'metadata' : 'auto'; // Default to metadata, but allow auto.
2006			}
2007
2008			this.formats = []; // Array based on supplied string option. Order defines priority.
2009			this.solutions = []; // Array based on solution string option. Order defines priority.
2010			this.require = {}; // Which media types are required: video, audio.
2011
2012			this.htmlElement = {}; // DOM elements created by jPlayer
2013			this.html = {}; // In _init()'s this.desired code and setmedia(): Accessed via this[solution], where solution from this.solutions array.
2014			this.html.audio = {};
2015			this.html.video = {};
2016			this.flash = {}; // In _init()'s this.desired code and setmedia(): Accessed via this[solution], where solution from this.solutions array.
2017
2018			this.css = {};
2019			this.css.cs = {}; // Holds the css selector strings
2020			this.css.jq = {}; // Holds jQuery selectors. ie., $(css.cs.method)
2021
2022			this.ancestorJq = []; // Holds jQuery selector of cssSelectorAncestor. Init would use $() instead of [], but it is only 1.4+
2023
2024			this.options.volume = this._limitValue(this.options.volume, 0, 1); // Limit volume value's bounds.
2025
2026			// Create the formats array, with prority based on the order of the supplied formats string
2027			$.each(this.options.supplied.toLowerCase().split(","), function(index1, value1) {
2028				var format = value1.replace(/^\s+|\s+$/g, ""); //trim
2029				if(self.format[format]) { // Check format is valid.
2030					var dupFound = false;
2031					$.each(self.formats, function(index2, value2) { // Check for duplicates
2032						if(format === value2) {
2033							dupFound = true;
2034							return false;
2035						}
2036					});
2037					if(!dupFound) {
2038						self.formats.push(format);
2039					}
2040				}
2041			});
2042
2043			// Create the solutions array, with prority based on the order of the solution string
2044			$.each(this.options.solution.toLowerCase().split(","), function(index1, value1) {
2045				var solution = value1.replace(/^\s+|\s+$/g, ""); //trim
2046				if(self.solution[solution]) { // Check solution is valid.
2047					var dupFound = false;
2048					$.each(self.solutions, function(index2, value2) { // Check for duplicates
2049						if(solution === value2) {
2050							dupFound = true;
2051							return false;
2052						}
2053					});
2054					if(!dupFound) {
2055						self.solutions.push(solution);
2056					}
2057				}
2058			});
2059
2060			this.internal.instance = "jp_" + this.count;
2061			this.instances[this.internal.instance] = this.element;
2062
2063			// Check the jPlayer div has an id and create one if required. Important for Flash to know the unique id for comms.
2064			if(!this.element.attr("id")) {
2065				this.element.attr("id", this.options.idPrefix + "_jplayer_" + this.count);
2066			}
2067
2068			this.internal.self = $.extend({}, {
2069				id: this.element.attr("id"),
2070				jq: this.element
2071			});
2072			this.internal.audio = $.extend({}, {
2073				id: this.options.idPrefix + "_audio_" + this.count,
2074				jq: undefined
2075			});
2076			this.internal.video = $.extend({}, {
2077				id: this.options.idPrefix + "_video_" + this.count,
2078				jq: undefined
2079			});
2080			this.internal.flash = $.extend({}, {
2081				id: this.options.idPrefix + "_flash_" + this.count,
2082				jq: undefined,
2083				swf: this.options.swfPath + (this.options.swfPath.toLowerCase().slice(-4) !== ".swf" ? (this.options.swfPath && this.options.swfPath.slice(-1) !== "/" ? "/" : "") + "Jplayer.swf" : "")
2084			});
2085			this.internal.poster = $.extend({}, {
2086				id: this.options.idPrefix + "_poster_" + this.count,
2087				jq: undefined
2088			});
2089
2090			// Register listeners defined in the constructor
2091			$.each($.jPlayer.event, function(eventName,eventType) {
2092				if(self.options[eventName] !== undefined) {
2093					self.element.bind(eventType + ".jPlayer", self.options[eventName]); // With .jPlayer namespace.
2094					self.options[eventName] = undefined; // Destroy the handler pointer copy on the options. Reason, events can be added/removed in other ways so this could be obsolete and misleading.
2095				}
2096			});
2097
2098			// Determine if we require solutions for audio, video or both media types.
2099			this.require.audio = false;
2100			this.require.video = false;
2101			$.each(this.formats, function(priority, format) {
2102				self.require[self.format[format].media] = true;
2103			});
2104
2105			// Now required types are known, finish the options default settings.
2106			if(this.require.video) {
2107				this.options = $.extend(true, {},
2108					this.optionsVideo,
2109					this.options
2110				);
2111			} else {
2112				this.options = $.extend(true, {},
2113					this.optionsAudio,
2114					this.options
2115				);
2116			}
2117			this._setSize(); // update status and jPlayer element size
2118
2119			// Determine the status for Blocklisted options.
2120			this.status.nativeVideoControls = this._uaBlocklist(this.options.nativeVideoControls);
2121			this.status.noFullWindow = this._uaBlocklist(this.options.noFullWindow);
2122			this.status.noVolume = this._uaBlocklist(this.options.noVolume);
2123
2124			// Create event handlers if native fullscreen is supported
2125			if($.jPlayer.nativeFeatures.fullscreen.api.fullscreenEnabled) {
2126				this._fullscreenAddEventListeners();
2127			}
2128
2129			// The native controls are only for video and are disabled when audio is also used.
2130			this._restrictNativeVideoControls();
2131
2132			// Create the poster image.
2133			this.htmlElement.poster = document.createElement('img');
2134			this.htmlElement.poster.id = this.internal.poster.id;
2135			this.htmlElement.poster.onload = function() { // Note that this did not work on Firefox 3.6: poster.addEventListener("onload", function() {}, false); Did not investigate x-browser.
2136				if(!self.status.video || self.status.waitForPlay) {
2137					self.internal.poster.jq.show();
2138				}
2139			};
2140			this.element.append(this.htmlElement.poster);
2141			this.internal.poster.jq = $("#" + this.internal.poster.id);
2142			this.internal.poster.jq.css({'width': this.status.width, 'height': this.status.height});
2143			this.internal.poster.jq.hide();
2144			this.internal.poster.jq.bind("click.jPlayer", function() {
2145				self._trigger($.jPlayer.event.click);
2146			});
2147
2148			// Generate the required media elements
2149			this.html.audio.available = false;
2150			if(this.require.audio) { // If a supplied format is audio
2151				this.htmlElement.audio = document.createElement('audio');
2152				this.htmlElement.audio.id = this.internal.audio.id;
2153				this.html.audio.available = !!this.htmlElement.audio.canPlayType && this._testCanPlayType(this.htmlElement.audio); // Test is for IE9 on Win Server 2008.
2154			}
2155			this.html.video.available = false;
2156			if(this.require.video) { // If a supplied format is video
2157				this.htmlElement.video = document.createElement('video');
2158				this.htmlElement.video.id = this.internal.video.id;
2159				this.html.video.available = !!this.htmlElement.video.canPlayType && this._testCanPlayType(this.htmlElement.video); // Test is for IE9 on Win Server 2008.
2160			}
2161
2162			this.flash.available = this._checkForFlash(10.1);
2163
2164			this.html.canPlay = {};
2165			this.flash.canPlay = {};
2166			$.each(this.formats, function(priority, format) {
2167				self.html.canPlay[format] = self.html[self.format[format].media].available && "" !== self.htmlElement[self.format[format].media].canPlayType(self.format[format].codec);
2168				self.flash.canPlay[format] = self.format[format].flashCanPlay && self.flash.available;
2169			});
2170			this.html.desired = false;
2171			this.flash.desired = false;
2172			$.each(this.solutions, function(solutionPriority, solution) {
2173				if(solutionPriority === 0) {
2174					self[solution].desired = true;
2175				} else {
2176					var audioCanPlay = false;
2177					var videoCanPlay = false;
2178					$.each(self.formats, function(formatPriority, format) {
2179						if(self[self.solutions[0]].canPlay[format]) { // The other solution can play
2180							if(self.format[format].media === 'video') {
2181								videoCanPlay = true;
2182							} else {
2183								audioCanPlay = true;
2184							}
2185						}
2186					});
2187					self[solution].desired = (self.require.audio && !audioCanPlay) || (self.require.video && !videoCanPlay);
2188				}
2189			});
2190			// This is what jPlayer will support, based on solution and supplied.
2191			this.html.support = {};
2192			this.flash.support = {};
2193			$.each(this.formats, function(priority, format) {
2194				self.html.support[format] = self.html.canPlay[format] && self.html.desired;
2195				self.flash.support[format] = self.flash.canPlay[format] && self.flash.desired;
2196			});
2197			// If jPlayer is supporting any format in a solution, then the solution is used.
2198			this.html.used = false;
2199			this.flash.used = false;
2200			$.each(this.solutions, function(solutionPriority, solution) {
2201				$.each(self.formats, function(formatPriority, format) {
2202					if(self[solution].support[format]) {
2203						self[solution].used = true;
2204						return false;
2205					}
2206				});
2207			});
2208
2209			// Init solution active state and the event gates to false.
2210			this._resetActive();
2211			this._resetGate();
2212
2213			// Set up the css selectors for the control and feedback entities.
2214			this._cssSelectorAncestor(this.options.cssSelectorAncestor);
2215
2216			// If neither html nor flash are being used by this browser, then media playback is not possible. Trigger an error event.
2217			if(!(this.html.used || this.flash.used)) {
2218				this._error( {
2219					type: $.jPlayer.error.NO_SOLUTION,
2220					context: "{solution:'" + this.options.solution + "', supplied:'" + this.options.supplied + "'}",
2221					message: $.jPlayer.errorMsg.NO_SOLUTION,
2222					hint: $.jPlayer.errorHint.NO_SOLUTION
2223				});
2224				if(this.css.jq.noSolution.length) {
2225					this.css.jq.noSolution.show();
2226				}
2227			} else {
2228				if(this.css.jq.noSolution.length) {
2229					this.css.jq.noSolution.hide();
2230				}
2231			}
2232
2233			// Add the flash solution if it is being used.
2234			if(this.flash.used) {
2235				var htmlObj,
2236				flashVars = 'jQuery=' + encodeURI(this.options.noConflict) + '&id=' + encodeURI(this.internal.self.id) + '&vol=' + this.options.volume + '&muted=' + this.options.muted;
2237
2238				// Code influenced by SWFObject 2.2: http://code.google.com/p/swfobject/
2239				// Non IE browsers have an initial Flash size of 1 by 1 otherwise the wmode affected the Flash ready event.
2240
2241				if($.jPlayer.browser.msie && (Number($.jPlayer.browser.version) < 9 || $.jPlayer.browser.documentMode < 9)) {
2242					var objStr = '<object id="' + this.internal.flash.id + '" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="0" height="0" tabindex="-1"></object>';
2243
2244					var paramStr = [
2245						'<param name="movie" value="' + this.internal.flash.swf + '" />',
2246						'<param name="FlashVars" value="' + flashVars + '" />',
2247						'<param name="allowScriptAccess" value="always" />',
2248						'<param name="bgcolor" value="' + this.options.backgroundColor + '" />',
2249						'<param name="wmode" value="' + this.options.wmode + '" />'
2250					];
2251
2252					htmlObj = document.createElement(objStr);
2253					for(var i=0; i < paramStr.length; i++) {
2254						htmlObj.appendChild(document.createElement(paramStr[i]));
2255					}
2256				} else {
2257					var createParam = function(el, n, v) {
2258						var p = document.createElement("param");
2259						p.setAttribute("name", n);
2260						p.setAttribute("value", v);
2261						el.appendChild(p);
2262					};
2263
2264					htmlObj = document.createElement("object");
2265					htmlObj.setAttribute("id", this.internal.flash.id);
2266					htmlObj.setAttribute("name", this.internal.flash.id);
2267					htmlObj.setAttribute("data", this.internal.flash.swf);
2268					htmlObj.setAttribute("type", "application/x-shockwave-flash");
2269					htmlObj.setAttribute("width", "1"); // Non-zero
2270					htmlObj.setAttribute("height", "1"); // Non-zero
2271					htmlObj.setAttribute("tabindex", "-1");
2272					createParam(htmlObj, "flashvars", flashVars);
2273					createParam(htmlObj, "allowscriptaccess", "always");
2274					createParam(htmlObj, "bgcolor", this.options.backgroundColor);
2275					createParam(htmlObj, "wmode", this.options.wmode);
2276				}
2277
2278				this.element.append(htmlObj);
2279				this.internal.flash.jq = $(htmlObj);
2280			}
2281
2282			// Setup playbackRate ability before using _addHtmlEventListeners()
2283			if(this.html.used && !this.flash.used) { // If only HTML
2284				// Using the audio element capabilities for playbackRate. ie., Assuming video element is the same.
2285				this.status.playbackRateEnabled = this._testPlaybackRate('audio');
2286			} else {
2287				this.status.playbackRateEnabled = false;
2288			}
2289
2290			this._updatePlaybackRate();
2291
2292			// Add the HTML solution if being used.
2293			if(this.html.used) {
2294
2295				// The HTML Audio handlers
2296				if(this.html.audio.available) {
2297					this._addHtmlEventListeners(this.htmlElement.audio, this.html.audio);
2298					this.element.append(this.htmlElement.audio);
2299					this.internal.audio.jq = $("#" + this.internal.audio.id);
2300				}
2301
2302				// The HTML Video handlers
2303				if(this.html.video.available) {
2304					this._addHtmlEventListeners(this.htmlElement.video, this.html.video);
2305					this.element.append(this.htmlElement.video);
2306					this.internal.video.jq = $("#" + this.internal.video.id);
2307					if(this.status.nativeVideoControls) {
2308						this.internal.video.jq.css({'width': this.status.width, 'height': this.status.height});
2309					} else {
2310						this.internal.video.jq.css({'width':'0px', 'height':'0px'}); // Using size 0x0 since a .hide() causes issues in iOS
2311					}
2312					this.internal.video.jq.bind("click.jPlayer", function() {
2313						self._trigger($.jPlayer.event.click);
2314					});
2315				}
2316			}
2317
2318			// Create the bridge that emulates the HTML Media element on the jPlayer DIV
2319			if( this.options.emulateHtml ) {
2320				this._emulateHtmlBridge();
2321			}
2322
2323			if(this.html.used && !this.flash.used) { // If only HTML, then emulate flash ready() call after 100ms.
2324				setTimeout( function() {
2325					self.internal.ready = true;
2326					self.version.flash = "n/a";
2327					self._trigger($.jPlayer.event.repeat); // Trigger the repeat event so its handler can initialize itself with the loop option.
2328					self._trigger($.jPlayer.event.ready);
2329				}, 100);
2330			}
2331
2332			// Initialize the interface components with the options.
2333			this._updateNativeVideoControls();
2334			// The other controls are now setup in _cssSelectorAncestor()
2335			if(this.css.jq.videoPlay.length) {
2336				this.css.jq.videoPlay.hide();
2337			}
2338
2339			$.jPlayer.prototype.count++; // Change static variable via prototype.
2340		},
2341		destroy: function() {
2342			// MJP: The background change remains. Would need to store the original to restore it correctly.
2343			// MJP: The jPlayer element's size change remains.
2344
2345			// Clear the media to reset the GUI and stop any downloads. Streams on some browsers had persited. (Chrome)
2346			this.clearMedia();
2347			// Remove the size/sizeFull cssClass from the cssSelectorAncestor
2348			this._removeUiClass();
2349			// Remove the times from the GUI
2350			if(this.css.jq.currentTime.length) {
2351				this.css.jq.currentTime.text("");
2352			}
2353			if(this.css.jq.duration.length) {
2354				this.css.jq.duration.text("");
2355			}
2356			// Remove any bindings from the interface controls.
2357			$.each(this.css.jq, function(fn, jq) {
2358				// Check selector is valid before trying to execute method.
2359				if(jq.length) {
2360					jq.unbind(".jPlayer");
2361				}
2362			});
2363			// Remove the click handlers for $.jPlayer.event.click
2364			this.internal.poster.jq.unbind(".jPlayer");
2365			if(this.internal.video.jq) {
2366				this.internal.video.jq.unbind(".jPlayer");
2367			}
2368			// Remove the fullscreen event handlers
2369			this._fullscreenRemoveEventListeners();
2370			// Remove key bindings
2371			if(this === $.jPlayer.focus) {
2372				$.jPlayer.focus = null;
2373			}
2374			// Destroy the HTML bridge.
2375			if(this.options.emulateHtml) {
2376				this._destroyHtmlBridge();
2377			}
2378			this.element.removeData("jPlayer"); // Remove jPlayer data
2379			this.element.unbind(".jPlayer"); // Remove all event handlers created by the jPlayer constructor
2380			this.element.empty(); // Remove the inserted child elements
2381
2382			delete this.instances[this.internal.instance]; // Clear the instance on the static instance object
2383		},
2384		enable: function() { // Plan to implement
2385			// options.disabled = false
2386		},
2387		disable: function () { // Plan to implement
2388			// options.disabled = true
2389		},
2390		_testCanPlayType: function(elem) {
2391			// IE9 on Win Server 2008 did not implement canPlayType(), but it has the property.
2392			try {
2393				elem.canPlayType(this.format.mp3.codec); // The type is irrelevant.
2394				return true;
2395			} catch(err) {
2396				return false;
2397			}
2398		},
2399		_testPlaybackRate: function(type) {
2400			// type: String 'audio' or 'video'
2401			var el, rate = 0.5;
2402			type = typeof type === 'string' ? type : 'audio';
2403			el = document.createElement(type);
2404			// Wrapping in a try/catch, just in case older HTML5 browsers throw and error.
2405			try {
2406				if('playbackRate' in el) {
2407					el.playbackRate = rate;
2408					return el.playbackRate === rate;
2409				} else {
2410					return false;
2411				}
2412			} catch(err) {
2413				return false;
2414			}
2415		},
2416		_uaBlocklist: function(list) {
2417			// list : object with properties that are all regular expressions. Property names are irrelevant.
2418			// Returns true if the user agent is matched in list.
2419			var	ua = navigator.userAgent.toLowerCase(),
2420				block = false;
2421
2422			$.each(list, function(p, re) {
2423				if(re && re.test(ua)) {
2424					block = true;
2425					return false; // exit $.each.
2426				}
2427			});
2428			return block;
2429		},
2430		_restrictNativeVideoControls: function() {
2431			// Fallback to noFullWindow when nativeVideoControls is true and audio media is being used. Affects when both media types are used.
2432			if(this.require.audio) {
2433				if(this.status.nativeVideoControls) {
2434					this.status.nativeVideoControls = false;
2435					this.status.noFullWindow = true;
2436				}
2437			}
2438		},
2439		_updateNativeVideoControls: function() {
2440			if(this.html.video.available && this.html.used) {
2441				// Turn the HTML Video controls on/off
2442				this.htmlElement.video.controls = this.status.nativeVideoControls;
2443				// Show/hide the jPlayer GUI.
2444				this._updateAutohide();
2445				// For when option changed. The poster image is not updated, as it is dealt with in setMedia(). Acceptable degradation since seriously doubt these options will change on the fly. Can again review later.
2446				if(this.status.nativeVideoControls && this.require.video) {
2447					this.internal.poster.jq.hide();
2448					this.internal.video.jq.css({'width': this.status.width, 'height': this.status.height});
2449				} else if(this.status.waitForPlay && this.status.video) {
2450					this.internal.poster.jq.show();
2451					this.internal.video.jq.css({'width': '0px', 'height': '0px'});
2452				}
2453			}
2454		},
2455		_addHtmlEventListeners: function(mediaElement, entity) {
2456			var self = this;
2457			mediaElement.preload = this.options.preload;
2458			mediaElement.muted = this.options.muted;
2459			mediaElement.volume = this.options.volume;
2460
2461			if(this.status.playbackRateEnabled) {
2462				mediaElement.defaultPlaybackRate = this.options.defaultPlaybackRate;
2463				mediaElement.playbackRate = this.options.playbackRate;
2464			}
2465
2466			// Create the event listeners
2467			// Only want the active entity to affect jPlayer and bubble events.
2468			// Using entity.gate so that object is referenced and gate property always current
2469
2470			mediaElement.addEventListener("progress", function() {
2471				if(entity.gate) {
2472					if(self.internal.cmdsIgnored && this.readyState > 0) { // Detect iOS executed the command
2473						self.internal.cmdsIgnored = false;
2474					}
2475					self.androidFix.setMedia = false; // Disable the fix after the first progress event.
2476					if(self.androidFix.play) { // Play Android audio - performing the fix.
2477						self.androidFix.play = false;
2478						self.play(self.androidFix.time);
2479					}
2480					if(self.androidFix.pause) { // Pause Android audio at time - performing the fix.
2481						self.androidFix.pause = false;
2482						self.pause(self.androidFix.time);
2483					}
2484					self._getHtmlStatus(mediaElement);
2485					self._updateInterface();
2486					self._trigger($.jPlayer.event.progress);
2487				}
2488			}, false);
2489			mediaElement.addEventListener("timeupdate", function() {
2490				if(entity.gate) {
2491					self._getHtmlStatus(mediaElement);
2492					self._updateInterface();
2493					self._trigger($.jPlayer.event.timeupdate);
2494				}
2495			}, false);
2496			mediaElement.addEventListener("durationchange", function() {
2497				if(entity.gate) {
2498					self._getHtmlStatus(mediaElement);
2499					self._updateInterface();
2500					self._trigger($.jPlayer.event.durationchange);
2501				}
2502			}, false);
2503			mediaElement.addEventListener("play", function() {
2504				if(entity.gate) {
2505					self._updateButtons(true);
2506					self._html_checkWaitForPlay(); // So the native controls update this variable and puts the hidden interface in the correct state. Affects toggling native controls.
2507					self._trigger($.jPlayer.event.play);
2508				}
2509			}, false);
2510			mediaElement.addEventListener("playing", function() {
2511				if(entity.gate) {
2512					self._updateButtons(true);
2513					self._seeked();
2514					self._trigger($.jPlayer.event.playing);
2515				}
2516			}, false);
2517			mediaElement.addEventListener("pause", function() {
2518				if(entity.gate) {
2519					self._updateButtons(false);
2520					self._trigger($.jPlayer.event.pause);
2521				}
2522			}, false);
2523			mediaElement.addEventListener("waiting", function() {
2524				if(entity.gate) {
2525					self._seeking();
2526					self._trigger($.jPlayer.event.waiting);
2527				}
2528			}, false);
2529			mediaElement.addEventListener("seeking", function() {
2530				if(entity.gate) {
2531					self._seeking();
2532					self._trigger($.jPlayer.event.seeking);
2533				}
2534			}, false);
2535			mediaElement.addEventListener("seeked", function() {
2536				if(entity.gate) {
2537					self._seeked();
2538					self._trigger($.jPlayer.event.seeked);
2539				}
2540			}, false);
2541			mediaElement.addEventListener("volumechange", function() {
2542				if(entity.gate) {
2543					// Read the values back from the element as the Blackberry PlayBook shares the volume with the physical buttons master volume control.
2544					// However, when tested 6th July 2011, those buttons do not generate an event. The physical play/pause button does though.
2545					self.options.volume = mediaElement.volume;
2546					self.options.muted = mediaElement.muted;
2547					self._updateMute();
2548					self._updateVolume();
2549					self._trigger($.jPlayer.event.volumechange);
2550				}
2551			}, false);
2552			mediaElement.addEventListener("ratechange", function() {
2553				if(entity.gate) {
2554					self.options.defaultPlaybackRate = mediaElement.defaultPlaybackRate;
2555					self.options.playbackRate = mediaElement.playbackRate;
2556					self._updatePlaybackRate();
2557					self._trigger($.jPlayer.event.ratechange);
2558				}
2559			}, false);
2560			mediaElement.addEventListener("suspend", function() { // Seems to be the only way of capturing that the iOS4 browser did not actually play the media from the page code. ie., It needs a user gesture.
2561				if(entity.gate) {
2562					self._seeked();
2563					self._trigger($.jPlayer.event.suspend);
2564				}
2565			}, false);
2566			mediaElement.addEventListener("ended", function() {
2567				if(entity.gate) {
2568					// Order of the next few commands are important. Change the time and then pause.
2569					// Solves a bug in Firefox, where issuing pause 1st causes the media to play from the start. ie., The pause is ignored.
2570					if(!$.jPlayer.browser.webkit) { // Chrome crashes if you do this in conjunction with a setMedia command in an ended event handler. ie., The playlist demo.
2571						self.htmlElement.media.currentTime = 0; // Safari does not care about this command. ie., It works with or without this line. (Both Safari and Chrome are Webkit.)
2572					}
2573					self.htmlElement.media.pause(); // Pause otherwise a click on the progress bar will play from that point, when it shouldn't, since it stopped playback.
2574					self._updateButtons(false);
2575					self._getHtmlStatus(mediaElement, true); // With override true. Otherwise Chrome leaves progress at full.
2576					self._updateInterface();
2577					self._trigger($.jPlayer.event.ended);
2578				}
2579			}, false);
2580			mediaElement.addEventListener("error", function() {
2581				if(entity.gate) {
2582					self._updateButtons(false);
2583					self._seeked();
2584					if(self.status.srcSet) { // Deals with case of clearMedia() causing an error event.
2585						clearTimeout(self.internal.htmlDlyCmdId); // Clears any delayed commands used in the HTML solution.
2586						self.status.waitForLoad = true; // Allows the load operation to try again.
2587						self.status.waitForPlay = true; // Reset since a play was captured.
2588						if(self.status.video && !self.status.nativeVideoControls) {
2589							self.internal.video.jq.css({'width':'0px', 'height':'0px'});
2590						}
2591						if(self._validString(self.status.media.poster) && !self.status.nativeVideoControls) {
2592							self.internal.poster.jq.show();
2593						}
2594						if(self.css.jq.videoPlay.length) {
2595							self.css.jq.videoPlay.show();
2596						}
2597						self._error( {
2598							type: $.jPlayer.error.URL,
2599							context: self.status.src, // this.src shows absolute urls. Want context to show the url given.
2600							message: $.jPlayer.errorMsg.URL,
2601							hint: $.jPlayer.errorHint.URL
2602						});
2603					}
2604				}
2605			}, false);
2606			// Create all the other event listeners that bubble up to a jPlayer event from html, without being used by jPlayer.
2607			$.each($.jPlayer.htmlEvent, function(i, eventType) {
2608				mediaElement.addEventListener(this, function() {
2609					if(entity.gate) {
2610						self._trigger($.jPlayer.event[eventType]);
2611					}
2612				}, false);
2613			});
2614		},
2615		_getHtmlStatus: function(media, override) {
2616			var ct = 0, cpa = 0, sp = 0, cpr = 0;
2617
2618			// Fixes the duration bug in iOS, where the durationchange event occurs when media.duration is not always correct.
2619			// Fixes the initial duration bug in BB OS7, where the media.duration is infinity and displays as NaN:NaN due to Date() using inifity.
2620			if(isFinite(media.duration)) {
2621				this.status.duration = media.duration;
2622			}
2623
2624			ct = media.currentTime;
2625			cpa = (this.status.duration > 0) ? 100 * ct / this.status.duration : 0;
2626			if((typeof media.seekable === "object") && (media.seekable.length > 0)) {
2627				sp = (this.status.duration > 0) ? 100 * media.seekable.end(media.seekable.length-1) / this.status.duration : 100;
2628				cpr = (this.status.duration > 0) ? 100 * media.currentTime / media.seekable.end(media.seekable.length-1) : 0; // Duration conditional for iOS duration bug. ie., seekable.end is a NaN in that case.
2629			} else {
2630				sp = 100;
2631				cpr = cpa;
2632			}
2633
2634			if(override) {
2635				ct = 0;
2636				cpr = 0;
2637				cpa = 0;
2638			}
2639
2640			this.status.seekPercent = sp;
2641			this.status.currentPercentRelative = cpr;
2642			this.status.currentPercentAbsolute = cpa;
2643			this.status.currentTime = ct;
2644
2645			this.status.remaining = this.status.duration - this.status.currentTime;
2646
2647			this.status.videoWidth = media.videoWidth;
2648			this.status.videoHeight = media.videoHeight;
2649
2650			this.status.readyState = media.readyState;
2651			this.status.networkState = media.networkState;
2652			this.status.playbackRate = media.playbackRate;
2653			this.status.ended = media.ended;
2654		},
2655		_resetStatus: function() {
2656			this.status = $.extend({}, this.status, $.jPlayer.prototype.status); // Maintains the status properties that persist through a reset.
2657		},
2658		_trigger: function(eventType, error, warning) { // eventType always valid as called using $.jPlayer.event.eventType
2659			var event = $.Event(eventType);
2660			event.jPlayer = {};
2661			event.jPlayer.version = $.extend({}, this.version);
2662			event.jPlayer.options = $.extend(true, {}, this.options); // Deep copy
2663			event.jPlayer.status = $.extend(true, {}, this.status); // Deep copy
2664			event.jPlayer.html = $.extend(true, {}, this.html); // Deep copy
2665			event.jPlayer.flash = $.extend(true, {}, this.flash); // Deep copy
2666			if(error) {
2667				event.jPlayer.error = $.extend({}, error);
2668			}
2669			if(warning) {
2670				event.jPlayer.warning = $.extend({}, warning);
2671			}
2672			this.element.trigger(event);
2673		},
2674		jPlayerFlashEvent: function(eventType, status) { // Called from Flash
2675			if(eventType === $.jPlayer.event.ready) {
2676				if(!this.internal.ready) {
2677					this.internal.ready = true;
2678					this.internal.flash.jq.css({'width':'0px', 'height':'0px'}); // Once Flash generates the ready event, minimise to zero as it is not affected by wmode anymore.
2679
2680					this.version.flash = status.version;
2681					if(this.version.needFlash !== this.version.flash) {
2682						this._error( {
2683							type: $.jPlayer.error.VERSION,
2684							context: this.version.flash,
2685							message: $.jPlayer.errorMsg.VERSION + this.version.flash,
2686							hint: $.jPlayer.errorHint.VERSION
2687						});
2688					}
2689					this._trigger($.jPlayer.event.repeat); // Trigger the repeat event so its handler can initialize itself with the loop option.
2690					this._trigger(eventType);
2691				} else {
2692					// This condition occurs if the Flash is hidden and then shown again.
2693					// Firefox also reloads the Flash if the CSS position changes. position:fixed is used for full screen.
2694
2695					// Only do this if the Flash is the solution being used at the moment. Affects Media players where both solution may be being used.
2696					if(this.flash.gate) {
2697
2698						// Send the current status to the Flash now that it is ready (available) again.
2699						if(this.status.srcSet) {
2700
2701							// Need to read original status before issuing the setMedia command.
2702							var	currentTime = this.status.currentTime,
2703								paused = this.status.paused;
2704
2705							this.setMedia(this.status.media);
2706							this.volumeWorker(this.options.volume);
2707							if(currentTime > 0) {
2708								if(paused) {
2709									this.pause(currentTime);
2710								} else {
2711									this.play(currentTime);
2712								}
2713							}
2714						}
2715						this._trigger($.jPlayer.event.flashreset);
2716					}
2717				}
2718			}
2719			if(this.flash.gate) {
2720				switch(eventType) {
2721					case $.jPlayer.event.progress:
2722						this._getFlashStatus(status);
2723						this._updateInterface();
2724						this._trigger(eventType);
2725						break;
2726					case $.jPlayer.event.timeupdate:
2727						this._getFlashStatus(status);
2728						this._updateInterface();
2729						this._trigger(eventType);
2730						break;
2731					case $.jPlayer.event.play:
2732						this._seeked();
2733						this._updateButtons(true);
2734						this._trigger(eventType);
2735						break;
2736					case $.jPlayer.event.pause:
2737						this._updateButtons(false);
2738						this._trigger(eventType);
2739						break;
2740					case $.jPlayer.event.ended:
2741						this._updateButtons(false);
2742						this._trigger(eventType);
2743						break;
2744					case $.jPlayer.event.click:
2745						this._trigger(eventType); // This could be dealt with by the default
2746						break;
2747					case $.jPlayer.event.error:
2748						this.status.waitForLoad = true; // Allows the load operation to try again.
2749						this.status.waitForPlay = true; // Reset since a play was captured.
2750						if(this.status.video) {
2751							this.internal.flash.jq.css({'width':'0px', 'height':'0px'});
2752						}
2753						if(this._validString(this.status.media.poster)) {
2754							this.internal.poster.jq.show();
2755						}
2756						if(this.css.jq.videoPlay.length && this.status.video) {
2757							this.css.jq.videoPlay.show();
2758						}
2759						if(this.status.video) { // Set up for another try. Execute before error event.
2760							this._flash_setVideo(this.status.media);
2761						} else {
2762							this._flash_setAudio(this.status.media);
2763						}
2764						this._updateButtons(false);
2765						this._error( {
2766							type: $.jPlayer.error.URL,
2767							context:status.src,
2768							message: $.jPlayer.errorMsg.URL,
2769							hint: $.jPlayer.errorHint.URL
2770						});
2771						break;
2772					case $.jPlayer.event.seeking:
2773						this._seeking();
2774						this._trigger(eventType);
2775						break;
2776					case $.jPlayer.event.seeked:
2777						this._seeked();
2778						this._trigger(eventType);
2779						break;
2780					case $.jPlayer.event.ready:
2781						// The ready event is handled outside the switch statement.
2782						// Captured here otherwise 2 ready events would be generated if the ready event handler used setMedia.
2783						break;
2784					default:
2785						this._trigger(eventType);
2786				}
2787			}
2788			return false;
2789		},
2790		_getFlashStatus: function(status) {
2791			this.status.seekPercent = status.seekPercent;
2792			this.status.currentPercentRelative = status.currentPercentRelative;
2793			this.status.currentPercentAbsolute = status.currentPercentAbsolute;
2794			this.status.currentTime = status.currentTime;
2795			this.status.duration = status.duration;
2796			this.status.remaining = status.duration - status.currentTime;
2797
2798			this.status.videoWidth = status.videoWidth;
2799			this.status.videoHeight = status.videoHeight;
2800
2801			// The Flash does not generate this information in this release
2802			this.status.readyState = 4; // status.readyState;
2803			this.status.networkState = 0; // status.networkState;
2804			this.status.playbackRate = 1; // status.playbackRate;
2805			this.status.ended = false; // status.ended;
2806		},
2807		_updateButtons: function(playing) {
2808			if(playing === undefined) {
2809				playing = !this.status.paused;
2810			} else {
2811				this.status.paused = !playing;
2812			}
2813			if(this.css.jq.play.length && this.css.jq.pause.length) {
2814				if(playing) {
2815					this.css.jq.play.hide();
2816					this.css.jq.pause.show();
2817				} else {
2818					this.css.jq.play.show();
2819					this.css.jq.pause.hide();
2820				}
2821			}
2822			if(this.css.jq.restoreScreen.length && this.css.jq.fullScreen.length) {
2823				if(this.status.noFullWindow) {
2824					this.css.jq.fullScreen.hide();
2825					this.css.jq.restoreScreen.hide();
2826				} else if(this.options.fullWindow) {
2827					this.css.jq.fullScreen.hide();
2828					this.css.jq.restoreScreen.show();
2829				} else {
2830					this.css.jq.fullScreen.show();
2831					this.css.jq.restoreScreen.hide();
2832				}
2833			}
2834			if(this.css.jq.repeat.length && this.css.jq.repeatOff.length) {
2835				if(this.options.loop) {
2836					this.css.jq.repeat.hide();
2837					this.css.jq.repeatOff.show();
2838				} else {
2839					this.css.jq.repeat.show();
2840					this.css.jq.repeatOff.hide();
2841				}
2842			}
2843		},
2844		_updateInterface: function() {
2845			if(this.css.jq.seekBar.length) {
2846				this.css.jq.seekBar.width(this.status.seekPercent+"%");
2847			}
2848			if(this.css.jq.playBar.length) {
2849				if(this.options.smoothPlayBar) {
2850					this.css.jq.playBar.stop().animate({
2851						width: this.status.currentPercentAbsolute+"%"
2852					}, 250, "linear");
2853				} else {
2854					this.css.jq.playBar.width(this.status.currentPercentRelative+"%");
2855				}
2856			}
2857			var currentTimeText = '';
2858			if(this.css.jq.currentTime.length) {
2859				currentTimeText = this._convertTime(this.status.currentTime);
2860				if(currentTimeText !== this.css.jq.currentTime.text()) {
2861					this.css.jq.currentTime.text(this._convertTime(this.status.currentTime));
2862				}
2863			}
2864			var durationText = '',
2865				duration = this.status.duration,
2866				remaining = this.status.remaining;
2867			if(this.css.jq.duration.length) {
2868				if(typeof this.status.media.duration === 'string') {
2869					durationText = this.status.media.duration;
2870				} else {
2871					if(typeof this.status.media.duration === 'number') {
2872						duration = this.status.media.duration;
2873						remaining = duration - this.status.currentTime;
2874					}
2875					if(this.options.remainingDuration) {
2876						durationText = (remaining > 0 ? '-' : '') + this._convertTime(remaining);
2877					} else {
2878						durationText = this._convertTime(duration);
2879					}
2880				}
2881				if(durationText !== this.css.jq.duration.text()) {
2882					this.css.jq.duration.text(durationText);
2883				}
2884			}
2885		},
2886		_convertTime: ConvertTime.prototype.time,
2887		_seeking: function() {
2888			if(this.css.jq.seekBar.length) {
2889				this.css.jq.seekBar.addClass("jp-seeking-bg");
2890			}
2891		},
2892		_seeked: function() {
2893			if(this.css.jq.seekBar.length) {
2894				this.css.jq.seekBar.removeClass("jp-seeking-bg");
2895			}
2896		},
2897		_resetGate: function() {
2898			this.html.audio.gate = false;
2899			this.html.video.gate = false;
2900			this.flash.gate = false;
2901		},
2902		_resetActive: function() {
2903			this.html.active = false;
2904			this.flash.active = false;
2905		},
2906		_escapeHtml: function(s) {
2907			return s.split('&').join('&amp;').split('<').join('&lt;').split('>').join('&gt;').split('"').join('&quot;');
2908		},
2909		_qualifyURL: function(url) {
2910			var el = document.createElement('div');
2911			el.innerHTML= '<a href="' + this._escapeHtml(url) + '">x</a>';
2912			return el.firstChild.href;
2913		},
2914		_absoluteMediaUrls: function(media) {
2915			var self = this;
2916			$.each(media, function(type, url) {
2917				if(url && self.format[type]) {
2918					media[type] = self._qualifyURL(url);
2919				}
2920			});
2921			return media;
2922		},
2923		setMedia: function(media) {
2924
2925			/*	media[format] = String: URL of format. Must contain all of the supplied option's video or audio formats.
2926			 *	media.poster = String: Video poster URL.
2927			 *	media.track = Array: Of objects defining the track element: kind, src, srclang, label, def.
2928			 *	media.stream = Boolean: * NOT IMPLEMENTED * Designating actual media streams. ie., "false/undefined" for files. Plan to refresh the flash every so often.
2929			 */
2930
2931			var	self = this,
2932				supported = false,
2933				posterChanged = this.status.media.poster !== media.poster; // Compare before reset. Important for OSX Safari as this.htmlElement.poster.src is absolute, even if original poster URL was relative.
2934
2935			this._resetMedia();
2936			this._resetGate();
2937			this._resetActive();
2938
2939			// Clear the Android Fix.
2940			this.androidFix.setMedia = false;
2941			this.androidFix.play = false;
2942			this.androidFix.pause = false;
2943
2944			// Convert all media URLs to absolute URLs.
2945			media = this._absoluteMediaUrls(media);
2946
2947			$.each(this.formats, function(formatPriority, format) {
2948				var isVideo = self.format[format].media === 'video';
2949				$.each(self.solutions, function(solutionPriority, solution) {
2950					if(self[solution].support[format] && self._validString(media[format])) { // Format supported in solution and url given for format.
2951						var isHtml = solution === 'html';
2952
2953						if(isVideo) {
2954							if(isHtml) {
2955								self.html.video.gate = true;
2956								self._html_setVideo(media);
2957								self.html.active = true;
2958							} else {
2959								self.flash.gate = true;
2960								self._flash_setVideo(media);
2961								self.flash.active = true;
2962							}
2963							if(self.css.jq.videoPlay.length) {
2964								self.css.jq.videoPlay.show();
2965							}
2966							self.status.video = true;
2967						} else {
2968							if(isHtml) {
2969								self.html.audio.gate = true;
2970								self._html_setAudio(media);
2971								self.html.active = true;
2972
2973								// Setup the Android Fix - Only for HTML audio.
2974								if($.jPlayer.platform.android) {
2975									self.androidFix.setMedia = true;
2976								}
2977							} else {
2978								self.flash.gate = true;
2979								self._flash_setAudio(media);
2980								self.flash.active = true;
2981							}
2982							if(self.css.jq.videoPlay.length) {
2983								self.css.jq.videoPlay.hide();
2984							}
2985							self.status.video = false;
2986						}
2987
2988						supported = true;
2989						return false; // Exit $.each
2990					}
2991				});
2992				if(supported) {
2993					return false; // Exit $.each
2994				}
2995			});
2996
2997			if(supported) {
2998				if(!(this.status.nativeVideoControls && this.html.video.gate)) {
2999					// Set poster IMG if native video controls are not being used
3000					// Note: With IE the IMG onload event occurs immediately when cached.
3001					// Note: Poster hidden by default in _resetMedia()
3002					if(this._validString(media.poster)) {
3003						if(posterChanged) { // Since some browsers do not generate img onload event.
3004							this.htmlElement.poster.src = media.poster;
3005						} else {
3006							this.internal.poster.jq.show();
3007						}
3008					}
3009				}
3010				if(this.css.jq.title.length) {
3011					if(typeof media.title === 'string') {
3012						this.css.jq.title.html(media.title);
3013						if(this.htmlElement.audio) {
3014							this.htmlElement.audio.setAttribute('title', media.title);
3015						}
3016						if(this.htmlElement.video) {
3017							this.htmlElement.video.setAttribute('title', media.title);
3018						}
3019					}
3020				}
3021				this.status.srcSet = true;
3022				this.status.media = $.extend({}, media);
3023				this._updateButtons(false);
3024				this._updateInterface();
3025				this._trigger($.jPlayer.event.setmedia);
3026			} else { // jPlayer cannot support any formats provided in this browser
3027				// Send an error event
3028				this._error( {
3029					type: $.jPlayer.error.NO_SUPPORT,
3030					context: "{supplied:'" + this.options.supplied + "'}",
3031					message: $.jPlayer.errorMsg.NO_SUPPORT,
3032					hint: $.jPlayer.errorHint.NO_SUPPORT
3033				});
3034			}
3035		},
3036		_resetMedia: function() {
3037			this._resetStatus();
3038			this._updateButtons(false);
3039			this._updateInterface();
3040			this._seeked();
3041			this.internal.poster.jq.hide();
3042
3043			clearTimeout(this.internal.htmlDlyCmdId);
3044
3045			if(this.html.active) {
3046				this._html_resetMedia();
3047			} else if(this.flash.active) {
3048				this._flash_resetMedia();
3049			}
3050		},
3051		clearMedia: function() {
3052			this._resetMedia();
3053
3054			if(this.html.active) {
3055				this._html_clearMedia();
3056			} else if(this.flash.active) {
3057				this._flash_clearMedia();
3058			}
3059
3060			this._resetGate();
3061			this._resetActive();
3062		},
3063		load: function() {
3064			if(this.status.srcSet) {
3065				if(this.html.active) {
3066					this._html_load();
3067				} else if(this.flash.active) {
3068					this._flash_load();
3069				}
3070			} else {
3071				this._urlNotSetError("load");
3072			}
3073		},
3074		focus: function() {
3075			if(this.options.keyEnabled) {
3076				$.jPlayer.focus = this;
3077			}
3078		},
3079		play: function(time) {
3080			time = (typeof time === "number") ? time : NaN; // Remove jQuery event from click handler
3081			if(this.status.srcSet) {
3082				this.focus();
3083				if(this.html.active) {
3084					this._html_play(time);
3085				} else if(this.flash.active) {
3086					this._flash_play(time);
3087				}
3088			} else {
3089				this._urlNotSetError("play");
3090			}
3091		},
3092		videoPlay: function() { // Handles clicks on the play button over the video poster
3093			this.play();
3094		},
3095		pause: function(time) {
3096			time = (typeof time === "number") ? time : NaN; // Remove jQuery event from click handler
3097			if(this.status.srcSet) {
3098				if(this.html.active) {
3099					this._html_pause(time);
3100				} else if(this.flash.active) {
3101					this._flash_pause(time);
3102				}
3103			} else {
3104				this._urlNotSetError("pause");
3105			}
3106		},
3107		tellOthers: function(command, conditions) {
3108			var self = this,
3109				hasConditions = typeof conditions === 'function',
3110				args = Array.prototype.slice.call(arguments); // Convert arguments to an Array.
3111
3112			if(typeof command !== 'string') { // Ignore, since no command.
3113				return; // Return undefined to maintain chaining.
3114			}
3115			if(hasConditions) {
3116				args.splice(1, 1); // Remove the conditions from the arguments
3117			}
3118
3119			$.each(this.instances, function() {
3120				// Remember that "this" is the instance's "element" in the $.each() loop.
3121				if(self.element !== this) { // Do not tell my instance.
3122					if(!hasConditions || conditions.call(this.data("jPlayer"), self)) {
3123						this.jPlayer.apply(this, args);
3124					}
3125				}
3126			});
3127		},
3128		pauseOthers: function(time) {
3129			this.tellOthers("pause", function() {
3130				// In the conditions function, the "this" context is the other instance's jPlayer object.
3131				return this.status.srcSet;
3132			}, time);
3133		},
3134		stop: function() {
3135			if(this.status.srcSet) {
3136				if(this.html.active) {
3137					this._html_pause(0);
3138				} else if(this.flash.active) {
3139					this._flash_pause(0);
3140				}
3141			} else {
3142				this._urlNotSetError("stop");
3143			}
3144		},
3145		playHead: function(p) {
3146			p = this._limitValue(p, 0, 100);
3147			if(this.status.srcSet) {
3148				if(this.html.active) {
3149					this._html_playHead(p);
3150				} else if(this.flash.active) {
3151					this._flash_playHead(p);
3152				}
3153			} else {
3154				this._urlNotSetError("playHead");
3155			}
3156		},
3157		_muted: function(muted) {
3158			this.mutedWorker(muted);
3159			if(this.options.globalVolume) {
3160				this.tellOthers("mutedWorker", function() {
3161					// Check the other instance has global volume enabled.
3162					return this.options.globalVolume;
3163				}, muted);
3164			}
3165		},
3166		mutedWorker: function(muted) {
3167			this.options.muted = muted;
3168			if(this.html.used) {
3169				this._html_setProperty('muted', muted);
3170			}
3171			if(this.flash.used) {
3172				this._flash_mute(muted);
3173			}
3174
3175			// The HTML solution generates this event from the media element itself.
3176			if(!this.html.video.gate && !this.html.audio.gate) {
3177				this._updateMute(muted);
3178				this._updateVolume(this.options.volume);
3179				this._trigger($.jPlayer.event.volumechange);
3180			}
3181		},
3182		mute: function(mute) { // mute is either: undefined (true), an event object (true) or a boolean (muted).
3183			mute = mute === undefined ? true : !!mute;
3184			this._muted(mute);
3185		},
3186		unmute: function(unmute) { // unmute is either: undefined (true), an event object (true) or a boolean (!muted).
3187			unmute = unmute === undefined ? true : !!unmute;
3188			this._muted(!unmute);
3189		},
3190		_updateMute: function(mute) {
3191			if(mute === undefined) {
3192				mute = this.options.muted;
3193			}
3194			if(this.css.jq.mute.length && this.css.jq.unmute.length) {
3195				if(this.status.noVolume) {
3196					this.css.jq.mute.hide();
3197					this.css.jq.unmute.hide();
3198				} else if(mute) {
3199					this.css.jq.mute.hide();
3200					this.css.jq.unmute.show();
3201				} else {
3202					this.css.jq.mute.show();
3203					this.css.jq.unmute.hide();
3204				}
3205			}
3206		},
3207		volume: function(v) {
3208			this.volumeWorker(v);
3209			if(this.options.globalVolume) {
3210				this.tellOthers("volumeWorker", function() {
3211					// Check the other instance has global volume enabled.
3212					return this.options.globalVolume;
3213				}, v);
3214			}
3215		},
3216		volumeWorker: function(v) {
3217			v = this._limitValue(v, 0, 1);
3218			this.options.volume = v;
3219
3220			if(this.html.used) {
3221				this._html_setProperty('volume', v);
3222			}
3223			if(this.flash.used) {
3224				this._flash_volume(v);
3225			}
3226
3227			// The HTML solution generates this event from the media element itself.
3228			if(!this.html.video.gate && !this.html.audio.gate) {
3229				this._updateVolume(v);
3230				this._trigger($.jPlayer.event.volumechange);
3231			}
3232		},
3233		volumeBar: function(e) { // Handles clicks on the volumeBar
3234			if(this.css.jq.volumeBar.length) {
3235				// Using $(e.currentTarget) to enable multiple volume bars
3236				var $bar = $(e.currentTarget),
3237					offset = $bar.offset(),
3238					x = e.pageX - offset.left,
3239					w = $bar.width(),
3240					y = $bar.height() - e.pageY + offset.top,
3241					h = $bar.height();
3242				if(this.options.verticalVolume) {
3243					this.volume(y/h);
3244				} else {
3245					this.volume(x/w);
3246				}
3247			}
3248			if(this.options.muted) {
3249				this._muted(false);
3250			}
3251		},
3252		_updateVolume: function(v) {
3253			if(v === undefined) {
3254				v = this.options.volume;
3255			}
3256			v = this.options.muted ? 0 : v;
3257
3258			if(this.status.noVolume) {
3259				if(this.css.jq.volumeBar.length) {
3260					this.css.jq.volumeBar.hide();
3261				}
3262				if(this.css.jq.volumeBarValue.length) {
3263					this.css.jq.volumeBarValue.hide();
3264				}
3265				if(this.css.jq.volumeMax.length) {
3266					this.css.jq.volumeMax.hide();
3267				}
3268			} else {
3269				if(this.css.jq.volumeBar.length) {
3270					this.css.jq.volumeBar.show();
3271				}
3272				if(this.css.jq.volumeBarValue.length) {
3273					this.css.jq.volumeBarValue.show();
3274					this.css.jq.volumeBarValue[this.options.verticalVolume ? "height" : "width"]((v*100)+"%");
3275				}
3276				if(this.css.jq.volumeMax.length) {
3277					this.css.jq.volumeMax.show();
3278				}
3279			}
3280		},
3281		volumeMax: function() { // Handles clicks on the volume max
3282			this.volume(1);
3283			if(this.options.muted) {
3284				this._muted(false);
3285			}
3286		},
3287		_cssSelectorAncestor: function(ancestor) {
3288			var self = this;
3289			this.options.cssSelectorAncestor = ancestor;
3290			this._removeUiClass();
3291			this.ancestorJq = ancestor ? $(ancestor) : []; // Would use $() instead of [], but it is only 1.4+
3292			if(ancestor && this.ancestorJq.length !== 1) { // So empty strings do not generate the warning.
3293				this._warning( {
3294					type: $.jPlayer.warning.CSS_SELECTOR_COUNT,
3295					context: ancestor,
3296					message: $.jPlayer.warningMsg.CSS_SELECTOR_COUNT + this.ancestorJq.length + " found for cssSelectorAncestor.",
3297					hint: $.jPlayer.warningHint.CSS_SELECTOR_COUNT
3298				});
3299			}
3300			this._addUiClass();
3301			$.each(this.options.cssSelector, function(fn, cssSel) {
3302				self._cssSelector(fn, cssSel);
3303			});
3304
3305			// Set the GUI to the current state.
3306			this._updateInterface();
3307			this._updateButtons();
3308			this._updateAutohide();
3309			this._updateVolume();
3310			this._updateMute();
3311		},
3312		_cssSelector: function(fn, cssSel) {
3313			var self = this;
3314			if(typeof cssSel === 'string') {
3315				if($.jPlayer.prototype.options.cssSelector[fn]) {
3316					if(this.css.jq[fn] && this.css.jq[fn].length) {
3317						this.css.jq[fn].unbind(".jPlayer");
3318					}
3319					this.options.cssSelector[fn] = cssSel;
3320					this.css.cs[fn] = this.options.cssSelectorAncestor + " " + cssSel;
3321
3322					if(cssSel) { // Checks for empty string
3323						this.css.jq[fn] = $(this.css.cs[fn]);
3324					} else {
3325						this.css.jq[fn] = []; // To comply with the css.jq[fn].length check before its use. As of jQuery 1.4 could have used $() for an empty set.
3326					}
3327
3328					if(this.css.jq[fn].length && this[fn]) {
3329						var handler = function(e) {
3330							e.preventDefault();
3331							self[fn](e);
3332							$(this).blur();
3333						};
3334						this.css.jq[fn].bind("click.jPlayer", handler); // Using jPlayer namespace
3335					}
3336
3337					if(cssSel && this.css.jq[fn].length !== 1) { // So empty strings do not generate the warning. ie., they just remove the old one.
3338						this._warning( {
3339							type: $.jPlayer.warning.CSS_SELECTOR_COUNT,
3340							context: this.css.cs[fn],
3341							message: $.jPlayer.warningMsg.CSS_SELECTOR_COUNT + this.css.jq[fn].length + " found for " + fn + " method.",
3342							hint: $.jPlayer.warningHint.CSS_SELECTOR_COUNT
3343						});
3344					}
3345				} else {
3346					this._warning( {
3347						type: $.jPlayer.warning.CSS_SELECTOR_METHOD,
3348						context: fn,
3349						message: $.jPlayer.warningMsg.CSS_SELECTOR_METHOD,
3350						hint: $.jPlayer.warningHint.CSS_SELECTOR_METHOD
3351					});
3352				}
3353			} else {
3354				this._warning( {
3355					type: $.jPlayer.warning.CSS_SELECTOR_STRING,
3356					context: cssSel,
3357					message: $.jPlayer.warningMsg.CSS_SELECTOR_STRING,
3358					hint: $.jPlayer.warningHint.CSS_SELECTOR_STRING
3359				});
3360			}
3361		},
3362		duration: function(e) {
3363			if(this.options.toggleDuration) {
3364				if(this.options.captureDuration) {
3365					e.stopPropagation();
3366				}
3367				this._setOption("remainingDuration", !this.options.remainingDuration);
3368			}
3369		},
3370		seekBar: function(e) { // Handles clicks on the seekBar
3371			if(this.css.jq.seekBar.length) {
3372				// Using $(e.currentTarget) to enable multiple seek bars
3373				var $bar = $(e.currentTarget),
3374					offset = $bar.offset(),
3375					x = e.pageX - offset.left,
3376					w = $bar.width(),
3377					p = 100 * x / w;
3378				this.playHead(p);
3379			}
3380		},
3381		playbackRate: function(pbr) {
3382			this._setOption("playbackRate", pbr);
3383		},
3384		playbackRateBar: function(e) { // Handles clicks on the playbackRateBar
3385			if(this.css.jq.playbackRateBar.length) {
3386				// Using $(e.currentTarget) to enable multiple playbackRate bars
3387				var $bar = $(e.currentTarget),
3388					offset = $bar.offset(),
3389					x = e.pageX - offset.left,
3390					w = $bar.width(),
3391					y = $bar.height() - e.pageY + offset.top,
3392					h = $bar.height(),
3393					ratio, pbr;
3394				if(this.options.verticalPlaybackRate) {
3395					ratio = y/h;
3396				} else {
3397					ratio = x/w;
3398				}
3399				pbr = ratio * (this.options.maxPlaybackRate - this.options.minPlaybackRate) + this.options.minPlaybackRate;
3400				this.playbackRate(pbr);
3401			}
3402		},
3403		_updatePlaybackRate: function() {
3404			var pbr = this.options.playbackRate,
3405				ratio = (pbr - this.options.minPlaybackRate) / (this.options.maxPlaybackRate - this.options.minPlaybackRate);
3406			if(this.status.playbackRateEnabled) {
3407				if(this.css.jq.playbackRateBar.length) {
3408					this.css.jq.playbackRateBar.show();
3409				}
3410				if(this.css.jq.playbackRateBarValue.length) {
3411					this.css.jq.playbackRateBarValue.show();
3412					this.css.jq.playbackRateBarValue[this.options.verticalPlaybackRate ? "height" : "width"]((ratio*100)+"%");
3413				}
3414			} else {
3415				if(this.css.jq.playbackRateBar.length) {
3416					this.css.jq.playbackRateBar.hide();
3417				}
3418				if(this.css.jq.playbackRateBarValue.length) {
3419					this.css.jq.playbackRateBarValue.hide();
3420				}
3421			}
3422		},
3423		repeat: function() { // Handle clicks on the repeat button
3424			this._loop(true);
3425		},
3426		repeatOff: function() { // Handle clicks on the repeatOff button
3427			this._loop(false);
3428		},
3429		_loop: function(loop) {
3430			if(this.options.loop !== loop) {
3431				this.options.loop = loop;
3432				this._updateButtons();
3433				this._trigger($.jPlayer.event.repeat);
3434			}
3435		},
3436
3437		// Options code adapted from ui.widget.js (1.8.7).  Made changes so the key can use dot notation. To match previous getData solution in jPlayer 1.
3438		option: function(key, value) {
3439			var options = key;
3440
3441			 // Enables use: options().  Returns a copy of options object
3442			if ( arguments.length === 0 ) {
3443				return $.extend( true, {}, this.options );
3444			}
3445
3446			if(typeof key === "string") {
3447				var keys = key.split(".");
3448
3449				 // Enables use: options("someOption")  Returns a copy of the option. Supports dot notation.
3450				if(value === undefined) {
3451
3452					var opt = $.extend(true, {}, this.options);
3453					for(var i = 0; i < keys.length; i++) {
3454						if(opt[keys[i]] !== undefined) {
3455							opt = opt[keys[i]];
3456						} else {
3457							this._warning( {
3458								type: $.jPlayer.warning.OPTION_KEY,
3459								context: key,
3460								message: $.jPlayer.warningMsg.OPTION_KEY,
3461								hint: $.jPlayer.warningHint.OPTION_KEY
3462							});
3463							return undefined;
3464						}
3465					}
3466					return opt;
3467				}
3468
3469				 // Enables use: options("someOptionObject", someObject}).  Creates: {someOptionObject:someObject}
3470				 // Enables use: options("someOption", someValue).  Creates: {someOption:someValue}
3471				 // Enables use: options("someOptionObject.someOption", someValue).  Creates: {someOptionObject:{someOption:someValue}}
3472
3473				options = {};
3474				var opts = options;
3475
3476				for(var j = 0; j < keys.length; j++) {
3477					if(j < keys.length - 1) {
3478						opts[keys[j]] = {};
3479						opts = opts[keys[j]];
3480					} else {
3481						opts[keys[j]] = value;
3482					}
3483				}
3484			}
3485
3486			 // Otherwise enables use: options(optionObject).  Uses original object (the key)
3487
3488			this._setOptions(options);
3489
3490			return this;
3491		},
3492		_setOptions: function(options) {
3493			var self = this;
3494			$.each(options, function(key, value) { // This supports the 2 level depth that the options of jPlayer has. Would review if we ever need more depth.
3495				self._setOption(key, value);
3496			});
3497
3498			return this;
3499		},
3500		_setOption: function(key, value) {
3501			var self = this;
3502
3503			// The ability to set options is limited at this time.
3504
3505			switch(key) {
3506				case "volume" :
3507					this.volume(value);
3508					break;
3509				case "muted" :
3510					this._muted(value);
3511					break;
3512				case "globalVolume" :
3513					this.options[key] = value;
3514					break;
3515				case "cssSelectorAncestor" :
3516					this._cssSelectorAncestor(value); // Set and refresh all associations for the new ancestor.
3517					break;
3518				case "cssSelector" :
3519					$.each(value, function(fn, cssSel) {
3520						self._cssSelector(fn, cssSel); // NB: The option is set inside this function, after further validity checks.
3521					});
3522					break;
3523				case "playbackRate" :
3524					this.options[key] = value = this._limitValue(value, this.options.minPlaybackRate, this.options.maxPlaybackRate);
3525					if(this.html.used) {
3526						this._html_setProperty('playbackRate', value);
3527					}
3528					this._updatePlaybackRate();
3529					break;
3530				case "defaultPlaybackRate" :
3531					this.options[key] = value = this._limitValue(value, this.options.minPlaybackRate, this.options.maxPlaybackRate);
3532					if(this.html.used) {
3533						this._html_setProperty('defaultPlaybackRate', value);
3534					}
3535					this._updatePlaybackRate();
3536					break;
3537				case "minPlaybackRate" :
3538					this.options[key] = value = this._limitValue(value, 0.1, this.options.maxPlaybackRate - 0.1);
3539					this._updatePlaybackRate();
3540					break;
3541				case "maxPlaybackRate" :
3542					this.options[key] = value = this._limitValue(value, this.options.minPlaybackRate + 0.1, 16);
3543					this._updatePlaybackRate();
3544					break;
3545				case "fullScreen" :
3546					if(this.options[key] !== value) { // if changed
3547						var wkv = $.jPlayer.nativeFeatures.fullscreen.used.webkitVideo;
3548						if(!wkv || wkv && !this.status.waitForPlay) {
3549							if(!wkv) { // No sensible way to unset option on these devices.
3550								this.options[key] = value;
3551							}
3552							if(value) {
3553								this._requestFullscreen();
3554							} else {
3555								this._exitFullscreen();
3556							}
3557							if(!wkv) {
3558								this._setOption("fullWindow", value);
3559							}
3560						}
3561					}
3562					break;
3563				case "fullWindow" :
3564					if(this.options[key] !== value) { // if changed
3565						this._removeUiClass();
3566						this.options[key] = value;
3567						this._refreshSize();
3568					}
3569					break;
3570				case "size" :
3571					if(!this.options.fullWindow && this.options[key].cssClass !== value.cssClass) {
3572						this._removeUiClass();
3573					}
3574					this.options[key] = $.extend({}, this.options[key], value); // store a merged copy of it, incase not all properties changed.
3575					this._refreshSize();
3576					break;
3577				case "sizeFull" :
3578					if(this.options.fullWindow && this.options[key].cssClass !== value.cssClass) {
3579						this._removeUiClass();
3580					}
3581					this.options[key] = $.extend({}, this.options[key], value); // store a merged copy of it, incase not all properties changed.
3582					this._refreshSize();
3583					break;
3584				case "autohide" :
3585					this.options[key] = $.extend({}, this.options[key], value); // store a merged copy of it, incase not all properties changed.
3586					this._updateAutohide();
3587					break;
3588				case "loop" :
3589					this._loop(value);
3590					break;
3591				case "remainingDuration" :
3592					this.options[key] = value;
3593					this._updateInterface();
3594					break;
3595				case "toggleDuration" :
3596					this.options[key] = value;
3597					break;
3598				case "nativeVideoControls" :
3599					this.options[key] = $.extend({}, this.options[key], value); // store a merged copy of it, incase not all properties changed.
3600					this.status.nativeVideoControls = this._uaBlocklist(this.options.nativeVideoControls);
3601					this._restrictNativeVideoControls();
3602					this._updateNativeVideoControls();
3603					break;
3604				case "noFullWindow" :
3605					this.options[key] = $.extend({}, this.options[key], value); // store a merged copy of it, incase not all properties changed.
3606					this.status.nativeVideoControls = this._uaBlocklist(this.options.nativeVideoControls); // Need to check again as noFullWindow can depend on this flag and the restrict() can override it.
3607					this.status.noFullWindow = this._uaBlocklist(this.options.noFullWindow);
3608					this._restrictNativeVideoControls();
3609					this._updateButtons();
3610					break;
3611				case "noVolume" :
3612					this.options[key] = $.extend({}, this.options[key], value); // store a merged copy of it, incase not all properties changed.
3613					this.status.noVolume = this._uaBlocklist(this.options.noVolume);
3614					this._updateVolume();
3615					this._updateMute();
3616					break;
3617				case "emulateHtml" :
3618					if(this.options[key] !== value) { // To avoid multiple event handlers being created, if true already.
3619						this.options[key] = value;
3620						if(value) {
3621							this._emulateHtmlBridge();
3622						} else {
3623							this._destroyHtmlBridge();
3624						}
3625					}
3626					break;
3627				case "timeFormat" :
3628					this.options[key] = $.extend({}, this.options[key], value); // store a merged copy of it, incase not all properties changed.
3629					break;
3630				case "keyEnabled" :
3631					this.options[key] = value;
3632					if(!value && this === $.jPlayer.focus) {
3633						$.jPlayer.focus = null;
3634					}
3635					break;
3636				case "keyBindings" :
3637					this.options[key] = $.extend(true, {}, this.options[key], value); // store a merged DEEP copy of it, incase not all properties changed.
3638					break;
3639				case "audioFullScreen" :
3640					this.options[key] = value;
3641					break;
3642			}
3643
3644			return this;
3645		},
3646		// End of: (Options code adapted from ui.widget.js)
3647
3648		_refreshSize: function() {
3649			this._setSize(); // update status and jPlayer element size
3650			this._addUiClass(); // update the ui class
3651			this._updateSize(); // update internal sizes
3652			this._updateButtons();
3653			this._updateAutohide();
3654			this._trigger($.jPlayer.event.resize);
3655		},
3656		_setSize: function() {
3657			// Determine the current size from the options
3658			if(this.options.fullWindow) {
3659				this.status.width = this.options.sizeFull.width;
3660				this.status.height = this.options.sizeFull.height;
3661				this.status.cssClass = this.options.sizeFull.cssClass;
3662			} else {
3663				this.status.width = this.options.size.width;
3664				this.status.height = this.options.size.height;
3665				this.status.cssClass = this.options.size.cssClass;
3666			}
3667
3668			// Set the size of the jPlayer area.
3669			this.element.css({'width': this.status.width, 'height': this.status.height});
3670		},
3671		_addUiClass: function() {
3672			if(this.ancestorJq.length) {
3673				this.ancestorJq.addClass(this.status.cssClass);
3674			}
3675		},
3676		_removeUiClass: function() {
3677			if(this.ancestorJq.length) {
3678				this.ancestorJq.removeClass(this.status.cssClass);
3679			}
3680		},
3681		_updateSize: function() {
3682			// The poster uses show/hide so can simply resize it.
3683			this.internal.poster.jq.css({'width': this.status.width, 'height': this.status.height});
3684
3685			// Video html or flash resized if necessary at this time, or if native video controls being used.
3686			if(!this.status.waitForPlay && this.html.active && this.status.video || this.html.video.available && this.html.used && this.status.nativeVideoControls) {
3687				this.internal.video.jq.css({'width': this.status.width, 'height': this.status.height});
3688			}
3689			else if(!this.status.waitForPlay && this.flash.active && this.status.video) {
3690				this.internal.flash.jq.css({'width': this.status.width, 'height': this.status.height});
3691			}
3692		},
3693		_updateAutohide: function() {
3694			var	self = this,
3695				event = "mousemove.jPlayer",
3696				namespace = ".jPlayerAutohide",
3697				eventType = event + namespace,
3698				handler = function() {
3699					self.css.jq.gui.fadeIn(self.options.autohide.fadeIn, function() {
3700						clearTimeout(self.internal.autohideId);
3701						self.internal.autohideId = setTimeout( function() {
3702							self.css.jq.gui.fadeOut(self.options.autohide.fadeOut);
3703						}, self.options.autohide.hold);
3704					});
3705				};
3706
3707			if(this.css.jq.gui.length) {
3708
3709				// End animations first so that its callback is executed now.
3710				// Otherwise an in progress fadeIn animation still has the callback to fadeOut again.
3711				this.css.jq.gui.stop(true, true);
3712
3713				// Removes the fadeOut operation from the fadeIn callback.
3714				clearTimeout(this.internal.autohideId);
3715
3716				this.element.unbind(namespace);
3717				this.css.jq.gui.unbind(namespace);
3718
3719				if(!this.status.nativeVideoControls) {
3720					if(this.options.fullWindow && this.options.autohide.full || !this.options.fullWindow && this.options.autohide.restored) {
3721						this.element.bind(eventType, handler);
3722						this.css.jq.gui.bind(eventType, handler);
3723						this.css.jq.gui.hide();
3724					} else {
3725						this.css.jq.gui.show();
3726					}
3727				} else {
3728					this.css.jq.gui.hide();
3729				}
3730			}
3731		},
3732		fullScreen: function() {
3733			this._setOption("fullScreen", true);