visibilityjs 1.0.0 → 1.1.0

data/lib/assets/javascripts/visibility.js

@@ -1,21 +1,3 @@
-/*
- * Copyright 2011 Andrey “A.I.” Sitnik <andrey@sitnik.ru>,
- * sponsored by Evil Martians.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
 ;(function (undefined) {
     "use strict";
 
@@ -73,10 +55,10 @@
             if ( !self.isSupported() ) {
                 return false;
             }
-            self._lastCallback += 1;
-            var number = self._lastCallback;
+            self._lastId += 1;
+            var number = self._lastId;
             self._callbacks[number] = callback;
-            self._setListener();
+            self._listen();
             return number;
         },
 
@@ -160,36 +142,36 @@
         _doc: window.document,
 
         // Vendor prefix cached by `_prefix` function.
-        _chechedPrefix: null,
+        _cached: null,
 
         // Is listener for `visibilitychange` event is already added
-        // by `_setListener` method.
-        _listening: false,
+        // by `_listen` method.
+        _enable: false,
 
         // Last timer number.
-        _lastCallback: -1,
+        _lastId: -1,
 
         // Callbacks from `change` method, that wait visibility changes.
         _callbacks: { },
 
         // Variable to check hidden-visible state changes.
-        _hiddenBefore: false,
+        _wasHidden: false,
 
         // Initialize variables on page loading.
         _init: function () {
-            self._hiddenBefore = self.hidden();
+            self._wasHidden = self.hidden();
         },
 
         // Detect vendor prefix and return it.
         _prefix: function () {
-            if ( null !== self._chechedPrefix ) {
-                return self._chechedPrefix;
+            if ( null !== self._cached ) {
+                return self._cached;
             }
             if ( defined(self._doc.visibilityState) ) {
-                return self._chechedPrefix = '';
+                return self._cached = '';
             }
             if ( defined(self._doc.webkitVisibilityState) ) {
-                return self._chechedPrefix = 'webkit';
+                return self._cached = 'webkit';
             }
         },
 
@@ -214,32 +196,32 @@
         },
 
         // Listener for `visibilitychange` event.
-        _onChange: function(event) {
+        _change: function(event) {
             var state = self.state();
 
             for ( var i in self._callbacks ) {
                 self._callbacks[i].call(self._doc, event, state);
             }
 
-            self._hiddenBefore = self.hidden();
+            self._wasHidden = self.hidden();
         },
 
         // Set listener for `visibilitychange` event.
-        _setListener: function () {
-            if ( self._listening ) {
+        _listen: function () {
+            if ( self._enable ) {
                 return;
             }
             var event = self._prefix() + 'visibilitychange';
             var listener = function () {
-                self._onChange.apply(Visibility, arguments);
+                self._change.apply(Visibility, arguments);
             };
             if ( self._doc.addEventListener ) {
                 self._doc.addEventListener(event, listener, false);
             } else {
                 self._doc.attachEvent(event, listener);
             }
-            self._listening = true;
-            self._hiddenBefore = self.hidden();
+            self._enable    = true;
+            self._wasHidden = self.hidden();
         }
 
     };
@@ -249,138 +231,155 @@
 
     var timers = {
 
-      // Run callback every `interval` milliseconds if page is visible and
-      // every `hiddenInterval` milliseconds if page is hidden.
-      //
-      //   Visibility.every(60 * 1000, 5 * 60 * 1000, function () {
-      //       checkNewMails();
-      //   });
-      //
-      // You can skip `hiddenInterval` and callback will be called only if
-      // page is visible.
-      //
-      //   Visibility.every(1000, function () {
-      //       updateCountdown();
-      //   });
-      //
-      // It is analog of `setInterval(callback, interval)` but use visibility
-      // state.
-      //
-      // It return timer ID, that you can use in `Visibility.stop(id)` to stop
-      // timer (`clearInterval` analog).
-      // Warning: timer ID is different from interval ID from `setInterval`,
-      // so don’t use it in `clearInterval`.
-      //
-      // On change state from hidden to visible timers will be execute.
-      every: function (interval, hiddenInterval, callback) {
-          self._initTimers();
-
-          if ( !defined(callback) ) {
-              callback = hiddenInterval;
-              hiddenInterval = null;
-          }
-          self._lastTimer += 1;
-          var number = self._lastTimer;
-          self._timers[number] = ({
-              interval:       interval,
-              hiddenInterval: hiddenInterval,
-              callback:       callback
-          });
-          self._runTimer(number, false);
-
-          if ( self.isSupported() ) {
-              self._setListener();
-          }
-          return number;
-      },
-
-      // Stop timer from `every` method by it ID (`every` method return it).
-      //
-      //   slideshow = Visibility.every(5 * 1000, function () {
-      //       changeSlide();
-      //   });
-      //   $('.stopSlideshow').click(function () {
-      //       Visibility.stop(slideshow);
-      //   });
-      stop: function(id) {
-          var timer = self._timers[id]
-          if ( !defined(timer) ) {
-              return false;
-          }
-          self._stopTimer(id);
-          delete self._timers[id];
-          return timer;
-      },
-
-      // Last timer number.
-      _lastTimer: -1,
-
-      // Callbacks and intervals added by `every` method.
-      _timers: { },
-
-      // Is setInterval method detected and listener is binded.
-      _timersInitialized: false,
-
-      // Initialize variables on page loading.
-      _initTimers: function () {
-          if ( self._timersInitialized ) {
-              return;
-          }
-          self._timersInitialized = true;
-
-          self.change(function () {
-              self._timersStopRun()
-          });
-      },
-
-      // Set interval by `setInterval`. Allow to change function for tests or
-      // syntax sugar in `interval` arguments.
-      _setInterval: function (callback, interval) {
-          return setInterval(callback, interval);
-      },
-
-      // Try to run timer from every method by it’s ID. It will be use
-      // `interval` or `hiddenInterval` depending on visibility state.
-      // If page is hidden and `hiddenInterval` is null,
-      // it will not run timer.
-      //
-      // Argument `now` say, that timers must be execute now too.
-      _runTimer: function (id, now) {
-          var interval,
-              timer = self._timers[id];
-          if ( self.hidden() ) {
-              if ( null === timer.hiddenInterval ) {
-                  return;
-              }
-              interval = timer.hiddenInterval;
-          } else {
-              interval = timer.interval;
-          }
-          if ( now ) {
-              timer.callback.call(window);
-          }
-          timer.id = self._setInterval(timer.callback, interval);
-      },
-
-      // Stop timer from `every` method by it’s ID.
-      _stopTimer: function (id) {
-          var timer = self._timers[id];
-          clearInterval(timer.id);
-          delete timer.id;
-      },
-
-      // Listener for `visibilitychange` event.
-      _timersStopRun: function (event) {
-          var isHidden = self.hidden(),
-              hiddenBefore = self._hiddenBefore;
-
-          if ( (isHidden && !hiddenBefore) || (!isHidden && hiddenBefore) ) {
-              for ( var i in self._timers ) {
-                  self._stopTimer(i);
-                  self._runTimer(i, !isHidden);
-              }
-          }
-      }
+        // Run callback every `interval` milliseconds if page is visible and
+        // every `hiddenInterval` milliseconds if page is hidden.
+        //
+        //   Visibility.every(60 * 1000, 5 * 60 * 1000, function () {
+        //       checkNewMails();
+        //   });
+        //
+        // You can skip `hiddenInterval` and callback will be called only if
+        // page is visible.
+        //
+        //   Visibility.every(1000, function () {
+        //       updateCountdown();
+        //   });
+        //
+        // It is analog of `setInterval(callback, interval)` but use visibility
+        // state.
+        //
+        // It return timer ID, that you can use in `Visibility.stop(id)` to stop
+        // timer (`clearInterval` analog).
+        // Warning: timer ID is different from interval ID from `setInterval`,
+        // so don’t use it in `clearInterval`.
+        //
+        // On change state from hidden to visible timers will be execute.
+        every: function (interval, hiddenInterval, callback) {
+            self._time();
+
+            if ( !defined(callback) ) {
+                callback = hiddenInterval;
+                hiddenInterval = null;
+            }
+
+            self._lastTimer += 1;
+            var number = self._lastTimer;
+
+            self._timers[number] = {
+                visible:  interval,
+                hidden:   hiddenInterval,
+                callback: callback
+            };
+            self._run(number, false);
+
+            if ( self.isSupported() ) {
+                self._listen();
+            }
+            return number;
+        },
+
+        // Stop timer from `every` method by it ID (`every` method return it).
+        //
+        //   slideshow = Visibility.every(5 * 1000, function () {
+        //       changeSlide();
+        //   });
+        //   $('.stopSlideshow').click(function () {
+        //       Visibility.stop(slideshow);
+        //   });
+        stop: function(id) {
+            var timer = self._timers[id]
+            if ( !defined(timer) ) {
+                return false;
+            }
+            self._stop(id);
+            delete self._timers[id];
+            return timer;
+        },
+
+        // Last timer number.
+        _lastTimer: -1,
+
+        // Callbacks and intervals added by `every` method.
+        _timers: { },
+
+        // Is setInterval method detected and listener is binded.
+        _timed: false,
+
+        // Initialize variables on page loading.
+        _time: function () {
+            if ( self._timed ) {
+                return;
+            }
+            self._timed = true;
+
+            self.change(function () {
+                self._stopRun()
+            });
+        },
+
+        // Try to run timer from every method by it’s ID. It will be use
+        // `interval` or `hiddenInterval` depending on visibility state.
+        // If page is hidden and `hiddenInterval` is null,
+        // it will not run timer.
+        //
+        // Argument `runNow` say, that timers must be execute now too.
+        _run: function (id, runNow) {
+            var interval,
+                timer = self._timers[id];
+            if ( self.hidden() ) {
+                if ( null === timer.hidden ) {
+                    return;
+                }
+                interval = timer.hidden;
+            } else {
+                interval = timer.visible;
+            }
+
+            var runner = function () {
+                timer.last = new Date();
+                timer.callback.call(window);
+            }
+
+            if ( runNow ) {
+                var now  = new Date();
+                var last = now - timer.last ;
+
+                if ( interval > last ) {
+                    timer.delay = setTimeout(function () {
+                        runner();
+                        timer.id = setInterval(runner, interval);
+                    }, interval - last);
+                } else {
+                    runner();
+                    timer.id = setInterval(runner, interval);
+                }
+
+            } else {
+              timer.id = setInterval(runner, interval);
+            }
+        },
+
+        // Stop timer from `every` method by it’s ID.
+        _stop: function (id) {
+            var timer = self._timers[id];
+            clearInterval(timer.id);
+            clearTimeout(timer.delay);
+            delete timer.id;
+            delete timer.delay;
+        },
+
+        // Listener for `visibilitychange` event.
+        _stopRun: function (event) {
+            var isHidden  = self.hidden(),
+                wasHidden = self._wasHidden;
+
+            if ( (isHidden && !wasHidden) || (!isHidden && wasHidden) ) {
+                for ( var i in self._timers ) {
+                    self._stop(i);
+                    self._run(i, !isHidden);
+                }
+            }
+        }
 
     };