Merge pull request #8391 An error occurred from timvandermeij/es6-web

Convert the hand tool, interfaces and secondary toolbar to ES6 syntax

web/hand_tool.js

@@ -20,20 +20,17 @@ import { localized } from './ui_utils';
  * @typedef {Object} HandToolOptions
  * @property {HTMLDivElement} container - The document container.
  * @property {EventBus} eventBus - The application event bus.
+ * @property {BasePreferences} preferences - Object for reading/writing
+ *                                           persistent settings.
  */
 
-/**
+class HandTool {
- * @class
- */
-var HandTool = (function HandToolClosure() {
   /**
-   * @constructs HandTool
    * @param {HandToolOptions} options
    */
-  function HandTool(options) {
+  constructor({ container, eventBus, preferences, }) {
-    this.container = options.container;
+    this.container = container;
-    this.eventBus = options.eventBus;
+    this.eventBus = eventBus;
-    var preferences = options.preferences;
 
     this.wasActive = false;
 
@@ -46,12 +43,12 @@ var HandTool = (function HandToolClosure() {
 
     this.eventBus.on('togglehandtool', this.toggle.bind(this));
 
-    Promise.all([localized,
+    let enableOnLoad = preferences.get('enableHandToolOnLoad');
-                 preferences.get('enableHandToolOnLoad')]).then((values) => {
+    Promise.all([localized, enableOnLoad]).then((values) => {
       if (values[1] === true) {
         this.handTool.activate();
       }
-    }).catch(function rejected(reason) { });
+    }).catch(function(reason) {});
 
     this.eventBus.on('presentationmodechanged', (evt) => {
       if (evt.switchInProgress) {
@@ -65,35 +62,31 @@ var HandTool = (function HandToolClosure() {
     });
   }
 
-  HandTool.prototype = {
+  /**
-    /**
+   * @return {boolean}
-     * @return {boolean}
+   */
-     */
+  get isActive() {
-    get isActive() {
+    return !!this.handTool.active;
-      return !!this.handTool.active;
+  }
-    },
-
-    toggle: function HandTool_toggle() {
-      this.handTool.toggle();
-    },
 
-    enterPresentationMode: function HandTool_enterPresentationMode() {
+  toggle() {
-      if (this.isActive) {
+    this.handTool.toggle();
-        this.wasActive = true;
+  }
-        this.handTool.deactivate();
-      }
-    },
 
-    exitPresentationMode: function HandTool_exitPresentationMode() {
+  enterPresentationMode() {
-      if (this.wasActive) {
+    if (this.isActive) {
-        this.wasActive = false;
+      this.wasActive = true;
-        this.handTool.activate();
+      this.handTool.deactivate();
-      }
     }
-  };
+  }
 
-  return HandTool;
+  exitPresentationMode() {
-})();
+    if (this.wasActive) {
+      this.wasActive = false;
+      this.handTool.activate();
+    }
+  }
+}
 
 export {
   HandTool,

web/interfaces.js

@@ -19,82 +19,87 @@
 /**
  * @interface
  */
-function IPDFLinkService() {}
+class IPDFLinkService {
-IPDFLinkService.prototype = {
   /**
    * @returns {number}
    */
-  get page() {},
+  get page() {}
+
   /**
    * @param {number} value
    */
-  set page(value) {},
+  set page(value) {}
+
   /**
    * @param dest - The PDF destination object.
    */
-  navigateTo(dest) {},
+  navigateTo(dest) {}
+
   /**
    * @param dest - The PDF destination object.
    * @returns {string} The hyperlink to the PDF object.
    */
-  getDestinationHash(dest) {},
+  getDestinationHash(dest) {}
+
   /**
    * @param hash - The PDF parameters/hash.
    * @returns {string} The hyperlink to the PDF object.
    */
-  getAnchorUrl(hash) {},
+  getAnchorUrl(hash) {}
+
   /**
    * @param {string} hash
    */
-  setHash(hash) {},
+  setHash(hash) {}
+
   /**
    * @param {string} action
    */
-  executeNamedAction(action) {},
+  executeNamedAction(action) {}
 
   /**
    * @param {number} pageNum - page number.
    * @param {Object} pageRef - reference to the page.
    */
-  cachePageRef(pageNum, pageRef) {},
+  cachePageRef(pageNum, pageRef) {}
-};
+}
 
 /**
  * @interface
  */
-function IPDFHistory() {}
+class IPDFHistory {
-IPDFHistory.prototype = {
+  forward() {}
-  forward() {},
+  back() {}
-  back() {},
+  push(params) {}
-  push(params) {},
+  updateNextHashParam(hash) {}
-  updateNextHashParam(hash) {},
+}
-};
 
 /**
  * @interface
  */
-function IRenderableView() {}
+class IRenderableView {
-IRenderableView.prototype = {
   /**
    * @returns {string} - Unique ID for rendering queue.
    */
-  get renderingId() {},
+  get renderingId() {}
+
   /**
    * @returns {RenderingStates}
    */
-  get renderingState() {},
+  get renderingState() {}
+
   /**
    * @returns {Promise} Resolved on draw completion.
    */
-  draw() {},
+  draw() {}
-  resume() {},
+
-};
+  resume() {}
+}
 
 /**
  * @interface
  */
-function IPDFTextLayerFactory() {}
+class IPDFTextLayerFactory {
-IPDFTextLayerFactory.prototype = {
   /**
    * @param {HTMLDivElement} textLayerDiv
    * @param {number} pageIndex
@@ -104,7 +109,7 @@ IPDFTextLayerFactory.prototype = {
    */
   createTextLayerBuilder(textLayerDiv, pageIndex, viewport,
                          enhanceTextSelection = false) {}
-};
+}
 
 /**
  * @interface

web/secondary_toolbar.js

@@ -45,17 +45,13 @@ import { mozL10n, SCROLLBAR_PADDING } from './ui_utils';
  *   the document properties dialog.
  */
 
-/**
+class SecondaryToolbar {
- * @class
- */
-var SecondaryToolbar = (function SecondaryToolbarClosure() {
   /**
-   * @constructs SecondaryToolbar
    * @param {SecondaryToolbarOptions} options
    * @param {HTMLDivElement} mainContainer
    * @param {EventBus} eventBus
    */
-  function SecondaryToolbar(options, mainContainer, eventBus) {
+  constructor(options, mainContainer, eventBus) {
     this.toolbar = options.toolbar;
     this.toggleButton = options.toggleButton;
     this.toolbarButtonContainer = options.toolbarButtonContainer;
@@ -101,129 +97,124 @@ var SecondaryToolbar = (function SecondaryToolbarClosure() {
     this.eventBus.on('resize', this._setMaxHeight.bind(this));
   }
 
-  SecondaryToolbar.prototype = {
+  /**
-    /**
+   * @return {boolean}
-     * @return {boolean}
+   */
-     */
+  get isOpen() {
-    get isOpen() {
+    return this.opened;
-      return this.opened;
+  }
-    },
+
-
+  setPageNumber(pageNumber) {
-    setPageNumber: function SecondaryToolbar_setPageNumber(pageNumber) {
+    this.pageNumber = pageNumber;
-      this.pageNumber = pageNumber;
+    this._updateUIState();
-      this._updateUIState();
+  }
-    },
+
-
+  setPagesCount(pagesCount) {
-    setPagesCount: function SecondaryToolbar_setPagesCount(pagesCount) {
+    this.pagesCount = pagesCount;
-      this.pagesCount = pagesCount;
+    this._updateUIState();
-      this._updateUIState();
+  }
-    },
+
-
+  reset() {
-    reset: function SecondaryToolbar_reset() {
+    this.pageNumber = 0;
-      this.pageNumber = 0;
+    this.pagesCount = 0;
-      this.pagesCount = 0;
+    this._updateUIState();
-      this._updateUIState();
+  }
-    },
+
-
+  _updateUIState() {
-    _updateUIState: function SecondaryToolbar_updateUIState() {
+    this.items.firstPage.disabled = (this.pageNumber <= 1);
-      var items = this.items;
+    this.items.lastPage.disabled = (this.pageNumber >= this.pagesCount);
-
+    this.items.pageRotateCw.disabled = this.pagesCount === 0;
-      items.firstPage.disabled = (this.pageNumber <= 1);
+    this.items.pageRotateCcw.disabled = this.pagesCount === 0;
-      items.lastPage.disabled = (this.pageNumber >= this.pagesCount);
+  }
-      items.pageRotateCw.disabled = this.pagesCount === 0;
+
-      items.pageRotateCcw.disabled = this.pagesCount === 0;
+  _bindClickListeners() {
-    },
+    // Button to toggle the visibility of the secondary toolbar.
-
+    this.toggleButton.addEventListener('click', this.toggle.bind(this));
-    _bindClickListeners: function SecondaryToolbar_bindClickListeners() {
+
-      // Button to toggle the visibility of the secondary toolbar.
+    // All items within the secondary toolbar.
-      this.toggleButton.addEventListener('click', this.toggle.bind(this));
+    for (let button in this.buttons) {
-
+      let { element, eventName, close, } = this.buttons[button];
-      // All items within the secondary toolbar.
+
-      for (let button in this.buttons) {
+      element.addEventListener('click', (evt) => {
-        let { element, eventName, close, } = this.buttons[button];
+        if (eventName !== null) {
-
+          this.eventBus.dispatch(eventName, { source: this, });
-        element.addEventListener('click', (evt) => {
-          if (eventName !== null) {
-            this.eventBus.dispatch(eventName, { source: this, });
-          }
-          if (close) {
-            this.close();
-          }
-        });
-      }
-    },
-
-    _bindHandToolListener:
-        function SecondaryToolbar_bindHandToolListener(toggleHandToolButton) {
-      var isHandToolActive = false;
-      this.eventBus.on('handtoolchanged', function (e) {
-        if (isHandToolActive === e.isActive) {
-          return;
         }
-        isHandToolActive = e.isActive;
+        if (close) {
-        if (isHandToolActive) {
+          this.close();
-          toggleHandToolButton.title =
-            mozL10n.get('hand_tool_disable.title', null, 'Disable hand tool');
-          toggleHandToolButton.firstElementChild.textContent =
-            mozL10n.get('hand_tool_disable_label', null, 'Disable hand tool');
-        } else {
-          toggleHandToolButton.title =
-            mozL10n.get('hand_tool_enable.title', null, 'Enable hand tool');
-          toggleHandToolButton.firstElementChild.textContent =
-            mozL10n.get('hand_tool_enable_label', null, 'Enable hand tool');
         }
       });
-    },
+    }
-
+  }
-    open: function SecondaryToolbar_open() {
-      if (this.opened) {
-        return;
-      }
-      this.opened = true;
-      this._setMaxHeight();
 
-      this.toggleButton.classList.add('toggled');
+  _bindHandToolListener(toggleHandToolButton) {
-      this.toolbar.classList.remove('hidden');
+    let isHandToolActive = false;
-    },
 
-    close: function SecondaryToolbar_close() {
+    this.eventBus.on('handtoolchanged', function(evt) {
-      if (!this.opened) {
+      if (isHandToolActive === evt.isActive) {
         return;
       }
-      this.opened = false;
+      isHandToolActive = evt.isActive;
-      this.toolbar.classList.add('hidden');
+
-      this.toggleButton.classList.remove('toggled');
+      if (isHandToolActive) {
-    },
+        toggleHandToolButton.title =
-
+          mozL10n.get('hand_tool_disable.title', null, 'Disable hand tool');
-    toggle: function SecondaryToolbar_toggle() {
+        toggleHandToolButton.firstElementChild.textContent =
-      if (this.opened) {
+          mozL10n.get('hand_tool_disable_label', null, 'Disable hand tool');
-        this.close();
       } else {
-        this.open();
+        toggleHandToolButton.title =
-      }
+          mozL10n.get('hand_tool_enable.title', null, 'Enable hand tool');
-    },
+        toggleHandToolButton.firstElementChild.textContent =
-
+          mozL10n.get('hand_tool_enable_label', null, 'Enable hand tool');
-    /**
-     * @private
-     */
-    _setMaxHeight: function SecondaryToolbar_setMaxHeight() {
-      if (!this.opened) {
-        return; // Only adjust the 'max-height' if the toolbar is visible.
       }
-      this.containerHeight = this.mainContainer.clientHeight;
+    });
+  }
 
-      if (this.containerHeight === this.previousContainerHeight) {
+  open() {
-        return;
+    if (this.opened) {
-      }
+      return;
-      this.toolbarButtonContainer.setAttribute('style',
+    }
-        'max-height: ' + (this.containerHeight - SCROLLBAR_PADDING) + 'px;');
+    this.opened = true;
+    this._setMaxHeight();
+
+    this.toggleButton.classList.add('toggled');
+    this.toolbar.classList.remove('hidden');
+  }
 
-      this.previousContainerHeight = this.containerHeight;
+  close() {
+    if (!this.opened) {
+      return;
     }
-  };
+    this.opened = false;
+    this.toolbar.classList.add('hidden');
+    this.toggleButton.classList.remove('toggled');
+  }
 
-  return SecondaryToolbar;
+  toggle() {
-})();
+    if (this.opened) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+
+  /**
+   * @private
+   */
+  _setMaxHeight() {
+    if (!this.opened) {
+      return; // Only adjust the 'max-height' if the toolbar is visible.
+    }
+    this.containerHeight = this.mainContainer.clientHeight;
+
+    if (this.containerHeight === this.previousContainerHeight) {
+      return;
+    }
+    this.toolbarButtonContainer.setAttribute('style',
+      'max-height: ' + (this.containerHeight - SCROLLBAR_PADDING) + 'px;');
+
+    this.previousContainerHeight = this.containerHeight;
+  }
+}
 
 export {
   SecondaryToolbar,