Fix #1690 @0.75

diff --git a/js/libs/fluidbook/fluidbook.nav.js b/js/libs/fluidbook/fluidbook.nav.js
index fb7870c1396757a14f116ec78638846d54c75df4..8fa56405c4fbf15e3e6546fcf5811cee6acfcb7a 100644 (file)
--- a/js/libs/fluidbook/fluidbook.nav.js
+++ b/js/libs/fluidbook/fluidbook.nav.js
@@ -521,15 +521,18 @@ FluidbookNav.prototype = {
 
         // Full screen toggle
         $(document).on('click', '.icon-fullscreen', function () {
-
-            // Need to toggle all instances of the icon so can't use $(this)
-            $('.icon-fullscreen').toggleClass('active');
-
             $this.menuAPI.close();
             screenfull.toggle();
             return false;
         });
 
+        // Toggle icon on fullscreen change (also handles exiting via ESC key)
+        if (screenfull.enabled) {
+            screenfull.on('change', function() {
+                $('.icon-fullscreen').toggleClass('active');
+            });
+        }
+
         // Share icon
         $(document).on('click', '.icon-share', function () {
             if ($this.fluidbook.datas.phonegap != 'android') {

diff --git a/js/libs/screenfull.js b/js/libs/screenfull.js
index f3d605838eb4cf315f44a6213aad368aa0a85169..ff82f25e3910e632ee9cee80dba303f60c5b9c6c 100644 (file)
--- a/js/libs/screenfull.js
+++ b/js/libs/screenfull.js
@@ -1,119 +1,148 @@
 /*!
-* screenfull
-* v1.1.1 - 2013-11-20
-* https://github.com/sindresorhus/screenfull.js
-* (c) Sindre Sorhus; MIT License
-*/
-/*global Element */
-(function (window, document) {
+ * screenfull
+ * v3.3.1 - 2017-07-07
+ * (c) Sindre Sorhus; MIT License
+ */
+(function () {
        'use strict';
 
-       var keyboardAllowed = typeof Element !== 'undefined' && 'ALLOW_KEYBOARD_INPUT' in Element, // IE6 throws without typeof check
-
-               fn = (function () {
-                       var val, valLength;
-                       var fnMap = [
-                               [
-                                       'requestFullscreen',
-                                       'exitFullscreen',
-                                       'fullscreenElement',
-                                       'fullscreenEnabled',
-                                       'fullscreenchange',
-                                       'fullscreenerror'
-                               ],
-                               // new WebKit
-                               [
-                                       'webkitRequestFullscreen',
-                                       'webkitExitFullscreen',
-                                       'webkitFullscreenElement',
-                                       'webkitFullscreenEnabled',
-                                       'webkitfullscreenchange',
-                                       'webkitfullscreenerror'
-
-                               ],
-                               // old WebKit (Safari 5.1)
-                               [
-                                       'webkitRequestFullScreen',
-                                       'webkitCancelFullScreen',
-                                       'webkitCurrentFullScreenElement',
-                                       'webkitCancelFullScreen',
-                                       'webkitfullscreenchange',
-                                       'webkitfullscreenerror'
-
-                               ],
-                               [
-                                       'mozRequestFullScreen',
-                                       'mozCancelFullScreen',
-                                       'mozFullScreenElement',
-                                       'mozFullScreenEnabled',
-                                       'mozfullscreenchange',
-                                       'mozfullscreenerror'
-                               ],
-                               [
-                                       'msRequestFullscreen',
-                                       'msExitFullscreen',
-                                       'msFullscreenElement',
-                                       'msFullscreenEnabled',
-                                       'MSFullscreenChange',
-                                       'MSFullscreenError'
-                               ]
-                       ];
-                       var i = 0;
-                       var l = fnMap.length;
-                       var ret = {};
-
-                       for (; i < l; i++) {
-                               val = fnMap[i];
-                               if (val && val[1] in document) {
-                                       for (i = 0, valLength = val.length; i < valLength; i++) {
-                                               ret[fnMap[0][i]] = val[i];
-                                       }
-                                       return ret;
+       var document = typeof window !== 'undefined' && typeof window.document !== 'undefined' ? window.document : {};
+       var isCommonjs = typeof module !== 'undefined' && module.exports;
+       var keyboardAllowed = typeof Element !== 'undefined' && 'ALLOW_KEYBOARD_INPUT' in Element;
+
+       var fn = (function () {
+               var val;
+
+               var fnMap = [
+                       [
+                               'requestFullscreen',
+                               'exitFullscreen',
+                               'fullscreenElement',
+                               'fullscreenEnabled',
+                               'fullscreenchange',
+                               'fullscreenerror'
+                       ],
+                       // New WebKit
+                       [
+                               'webkitRequestFullscreen',
+                               'webkitExitFullscreen',
+                               'webkitFullscreenElement',
+                               'webkitFullscreenEnabled',
+                               'webkitfullscreenchange',
+                               'webkitfullscreenerror'
+
+                       ],
+                       // Old WebKit (Safari 5.1)
+                       [
+                               'webkitRequestFullScreen',
+                               'webkitCancelFullScreen',
+                               'webkitCurrentFullScreenElement',
+                               'webkitCancelFullScreen',
+                               'webkitfullscreenchange',
+                               'webkitfullscreenerror'
+
+                       ],
+                       [
+                               'mozRequestFullScreen',
+                               'mozCancelFullScreen',
+                               'mozFullScreenElement',
+                               'mozFullScreenEnabled',
+                               'mozfullscreenchange',
+                               'mozfullscreenerror'
+                       ],
+                       [
+                               'msRequestFullscreen',
+                               'msExitFullscreen',
+                               'msFullscreenElement',
+                               'msFullscreenEnabled',
+                               'MSFullscreenChange',
+                               'MSFullscreenError'
+                       ]
+               ];
+
+               var i = 0;
+               var l = fnMap.length;
+               var ret = {};
+
+               for (; i < l; i++) {
+                       val = fnMap[i];
+                       if (val && val[1] in document) {
+                               for (i = 0; i < val.length; i++) {
+                                       ret[fnMap[0][i]] = val[i];
                                }
+                               return ret;
                        }
-                       return false;
-               })(),
-
-               screenfull = {
-                       request: function (elem) {
-                               var request = fn.requestFullscreen;
-
-                               elem = elem || document.documentElement;
-
-                               // Work around Safari 5.1 bug: reports support for
-                               // keyboard in fullscreen even though it doesn't.
-                               // Browser sniffing, since the alternative with
-                               // setTimeout is even worse.
-                               if (/5\.1[\.\d]* Safari/.test(navigator.userAgent)) {
-                                       elem[request]();
-                               } else {
-                                       elem[request](keyboardAllowed && Element.ALLOW_KEYBOARD_INPUT);
-                               }
-                       },
-                       exit: function () {
-                               document[fn.exitFullscreen]();
-                       },
-                       toggle: function (elem) {
-                               if (this.isFullscreen) {
-                                       this.exit();
-                               } else {
-                                       this.request(elem);
-                               }
-                       },
-                       onchange: function () {},
-                       onerror: function () {},
-                       raw: fn
-               };
+               }
+
+               return false;
+       })();
+
+       var eventNameMap = {
+               change: fn.fullscreenchange,
+               error: fn.fullscreenerror
+       };
+
+       var screenfull = {
+               request: function (elem) {
+                       var request = fn.requestFullscreen;
+
+                       elem = elem || document.documentElement;
+
+                       // Work around Safari 5.1 bug: reports support for
+                       // keyboard in fullscreen even though it doesn't.
+                       // Browser sniffing, since the alternative with
+                       // setTimeout is even worse.
+                       if (/5\.1[.\d]* Safari/.test(navigator.userAgent)) {
+                               elem[request]();
+                       } else {
+                               elem[request](keyboardAllowed && Element.ALLOW_KEYBOARD_INPUT);
+                       }
+               },
+               exit: function () {
+                       document[fn.exitFullscreen]();
+               },
+               toggle: function (elem) {
+                       if (this.isFullscreen) {
+                               this.exit();
+                       } else {
+                               this.request(elem);
+                       }
+               },
+               onchange: function (callback) {
+                       this.on('change', callback);
+               },
+               onerror: function (callback) {
+                       this.on('error', callback);
+               },
+               on: function (event, callback) {
+                       var eventName = eventNameMap[event];
+                       if (eventName) {
+                               document.addEventListener(eventName, callback, false);
+                       }
+               },
+               off: function (event, callback) {
+                       var eventName = eventNameMap[event];
+                       if (eventName) {
+                               document.removeEventListener(eventName, callback, false);
+                       }
+               },
+               raw: fn
+       };
 
        if (!fn) {
-               window.screenfull = false;
+               if (isCommonjs) {
+                       module.exports = false;
+               } else {
+                       window.screenfull = false;
+               }
+
                return;
        }
 
        Object.defineProperties(screenfull, {
                isFullscreen: {
                        get: function () {
-                               return !!document[fn.fullscreenElement];
+                               return Boolean(document[fn.fullscreenElement]);
                        }
                },
                element: {
@@ -126,18 +155,14 @@
                        enumerable: true,
                        get: function () {
                                // Coerce to boolean in case of old WebKit
-                               return !!document[fn.fullscreenEnabled];
+                               return Boolean(document[fn.fullscreenEnabled]);
                        }
                }
        });
 
-       document.addEventListener(fn.fullscreenchange, function (e) {
-               screenfull.onchange.call(screenfull, e);
-       });
-
-       document.addEventListener(fn.fullscreenerror, function (e) {
-               screenfull.onerror.call(screenfull, e);
-       });
-
-       window.screenfull = screenfull;
-})(window, document);
+       if (isCommonjs) {
+               module.exports = screenfull;
+       } else {
+               window.screenfull = screenfull;
+       }
+})();
\ No newline at end of file