Club Drupal

/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */

'use strict';

var kDefaultURL = '';

var kDefaultScale = 'auto';

var kDefaultScaleDelta = 1.1;

var kUnknownScale = 0;

var kCacheSize = 20;

var kCssUnits = 96.0 / 72.0;

var kScrollbarPadding = 40;

var kMinScale = 0.25;

var kMaxScale = 4.0;

var kImageDirectory = './images/';

var kSettingsMemory = 20;

var RenderingStates = {

  INITIAL: 0,

  RUNNING: 1,

  PAUSED: 2,

  FINISHED: 3

};

var mozL10n = document.mozL10n || document.webL10n;

function getFileName(url) {

  var anchor = url.indexOf('#');

  var query = url.indexOf('?');

  var end = Math.min(

    anchor > 0 ? anchor : url.length,

    query > 0 ? query : url.length);

  return url.substring(url.lastIndexOf('/', end) + 1, end);

}

var Cache = function cacheCache(size) {

  var data = [];

  this.push = function cachePush(view) {

    var i = data.indexOf(view);

    if (i >= 0)

      data.splice(i);

    data.push(view);

    if (data.length > size)

      data.shift().destroy();

  };

};

var ProgressBar = (function ProgressBarClosure() {

  function clamp(v, min, max) {

    return Math.min(Math.max(v, min), max);

  }

  function ProgressBar(id, opts) {

    // Fetch the sub-elements for later

    this.div = document.querySelector(id + ' .progress');

    // Get options, with sensible defaults

    this.height = opts.height || 100;

    this.width = opts.width || 100;

    this.units = opts.units || '%';

    this.percent = opts.percent || 0;

    // Initialize heights

    this.div.style.height = this.height + this.units;

  }

  ProgressBar.prototype = {

    updateBar: function ProgressBar_updateBar() {

      var progressSize = this.width * this._percent / 100;

      if (this._percent > 95)

        this.div.classList.add('full');

      this.div.style.width = progressSize + this.units;

    },

    get percent() {

      return this._percent;

    },

    set percent(val) {

      this._percent = clamp(val, 0, 100);

      this.updateBar();

    }

  };

  return ProgressBar;

})();

// Settings Manager - This is a utility for saving settings

// First we see if localStorage is available

// If not, we use FUEL in FF

var Settings = (function SettingsClosure() {

  var isLocalStorageEnabled = (function localStorageEnabledTest() {

    // Feature test as per http://diveintohtml5.info/storage.html

    // The additional localStorage call is to get around a FF quirk, see

    // bug #495747 in bugzilla

    try {

      return 'localStorage' in window && window['localStorage'] !== null &&

          localStorage;

    } catch (e) {

      return false;

    }

  })();

  function Settings(fingerprint) {

    var database = null;

    var index;

    if (isLocalStorageEnabled)

      database = localStorage.getItem('database') || '{}';

    else

      return;

    database = JSON.parse(database);

    if (!('files' in database))

      database.files = [];

    if (database.files.length >= kSettingsMemory)

      database.files.shift();

    for (var i = 0, length = database.files.length; i < length; i++) {

      var branch = database.files[i];

      if (branch.fingerprint == fingerprint) {

        index = i;

        break;

      }

    }

    if (typeof index != 'number')

      index = database.files.push({fingerprint: fingerprint}) - 1;

    this.file = database.files[index];

    this.database = database;

  }

  Settings.prototype = {

    set: function settingsSet(name, val) {

      if (!('file' in this))

        return false;

      var file = this.file;

      file[name] = val;

      var database = JSON.stringify(this.database);

      if (isLocalStorageEnabled)

        localStorage.setItem('database', database);

    },

    get: function settingsGet(name, defaultValue) {

      if (!('file' in this))

        return defaultValue;

      return this.file[name] || defaultValue;

    }

  };

  return Settings;

})();

var cache = new Cache(kCacheSize);

var currentPageNumber = 1;

var PDFView = {

  pages: [],

  thumbnails: [],

  currentScale: kUnknownScale,

  currentScaleValue: null,

  initialBookmark: document.location.hash.substring(1),

  startedTextExtraction: false,

  pageText: [],

  container: null,

  thumbnailContainer: null,

  initialized: false,

  fellback: false,

  pdfDocument: null,

  sidebarOpen: false,

  pageViewScroll: null,

  thumbnailViewScroll: null,

  isFullscreen: false,

  previousScale: null,

  // called once when the document is loaded

  initialize: function pdfViewInitialize() {

    var container = this.container = document.getElementById('viewerContainer');

    this.pageViewScroll = {};

    this.watchScroll(container, this.pageViewScroll, updateViewarea);

    var thumbnailContainer = this.thumbnailContainer =

                             document.getElementById('thumbnailView');

    this.thumbnailViewScroll = {};

    this.watchScroll(thumbnailContainer, this.thumbnailViewScroll,

                     this.renderHighestPriority.bind(this));

    this.initialized = true;

  },

  // Helper function to keep track whether a div was scrolled up or down and

  // then call a callback.

  watchScroll: function pdfViewWatchScroll(viewAreaElement, state, callback) {

    state.down = true;

    state.lastY = viewAreaElement.scrollTop;

    viewAreaElement.addEventListener('scroll', function webViewerScroll(evt) {

      var currentY = viewAreaElement.scrollTop;

      var lastY = state.lastY;

      if (currentY > lastY)

        state.down = true;

      else if (currentY < lastY)

        state.down = false;

      // else do nothing and use previous value

      state.lastY = currentY;

      callback();

    }, true);

  },

  setScale: function pdfViewSetScale(val, resetAutoSettings, noScroll) {

    if (val == this.currentScale)

      return;

    var pages = this.pages;

    for (var i = 0; i < pages.length; i++)

      pages[i].update(val * kCssUnits);

    if (!noScroll && this.currentScale != val)

      this.pages[this.page - 1].scrollIntoView();

    this.currentScale = val;

    var event = document.createEvent('UIEvents');

    event.initUIEvent('scalechange', false, false, window, 0);

    event.scale = val;

    event.resetAutoSettings = resetAutoSettings;

    window.dispatchEvent(event);

  },

  parseScale: function pdfViewParseScale(value, resetAutoSettings, noScroll) {

    if ('custom' == value)

      return;

    var scale = parseFloat(value);

    this.currentScaleValue = value;

    if (scale) {

      this.setScale(scale, true, noScroll);

      return;

    }

    var container = this.container;

    var currentPage = this.pages[this.page - 1];

    var pageWidthScale = (container.clientWidth - kScrollbarPadding) /

                          currentPage.width * currentPage.scale / kCssUnits;

    var pageHeightScale = (container.clientHeight - kScrollbarPadding) /

                           currentPage.height * currentPage.scale / kCssUnits;

    switch (value) {

      case 'page-actual':

        scale = 1;

        break;

      case 'page-width':

        scale = pageWidthScale;

        break;

      case 'page-height':

        scale = pageHeightScale;

        break;

      case 'page-fit':

        scale = Math.min(pageWidthScale, pageHeightScale);

        break;

      case 'auto':

        scale = Math.min(1.0, pageWidthScale);

        break;

    }

    this.setScale(scale, resetAutoSettings, noScroll);

    selectScaleOption(value);

  },

  zoomIn: function pdfViewZoomIn() {

    var newScale = (this.currentScale * kDefaultScaleDelta).toFixed(2);

    newScale = Math.min(kMaxScale, newScale);

    this.parseScale(newScale, true);

  },

  zoomOut: function pdfViewZoomOut() {

    var newScale = (this.currentScale / kDefaultScaleDelta).toFixed(2);

    newScale = Math.max(kMinScale, newScale);

    this.parseScale(newScale, true);

  },

  set page(val) {

    var pages = this.pages;

    var input = document.getElementById('pageNumber');

    var event = document.createEvent('UIEvents');

    event.initUIEvent('pagechange', false, false, window, 0);

    if (!(0 < val && val <= pages.length)) {

      event.pageNumber = this.page;

      window.dispatchEvent(event);

      return;

    }

    pages[val - 1].updateStats();

    currentPageNumber = val;

    event.pageNumber = val;

    window.dispatchEvent(event);

    // checking if the this.page was called from the updateViewarea function:

    // avoiding the creation of two "set page" method (internal and public)

    if (updateViewarea.inProgress)

      return;

    // Avoid scrolling the first page during loading

    if (this.loading && val == 1)

      return;

    pages[val - 1].scrollIntoView();

  },

  get page() {

    return currentPageNumber;

  },

  get supportsPrinting() {

    var canvas = document.createElement('canvas');

    var value = 'mozPrintCallback' in canvas;

    // shadow

    Object.defineProperty(this, 'supportsPrinting', { value: value,

                                                      enumerable: true,

                                                      configurable: true,

                                                      writable: false });

    return value;

  },

  get supportsFullscreen() {

    var doc = document.documentElement;

    var support = doc.requestFullScreen || doc.mozRequestFullScreen ||

                  doc.webkitRequestFullScreen;

    Object.defineProperty(this, 'supportsFullScreen', { value: support,

                                                        enumerable: true,

                                                        configurable: true,

                                                        writable: false });

    return support;

  },

  open: function pdfViewOpen(url, scale, password) {

    var parameters = {password: password};

    if (typeof url === 'string') { // URL

      this.url = url;

      document.title = decodeURIComponent(getFileName(url)) || url;

      parameters.url = url;

    } else if (url && 'byteLength' in url) { // ArrayBuffer

      parameters.data = url;

    }

    if (!PDFView.loadingBar) {

      PDFView.loadingBar = new ProgressBar('#loadingBar', {});

    }

    this.pdfDocument = null;

    var self = this;

    self.loading = true;

    PDFJS.getDocument(parameters).then(

      function getDocumentCallback(pdfDocument) {

        self.load(pdfDocument, scale);

        self.loading = false;

      },

      function getDocumentError(message, exception) {

        if (exception && exception.name === 'PasswordException') {

          if (exception.code === 'needpassword') {

            var promptString = mozL10n.get('request_password', null,

                                      'PDF is protected by a password:');

            password = prompt(promptString);

            if (password && password.length > 0) {

              return PDFView.open(url, scale, password);

            }

          }

        }

        var loadingIndicator = document.getElementById('loading');

        loadingIndicator.textContent = mozL10n.get('loading_error_indicator',

          null, 'Error');

        var moreInfo = {

          message: message

        };

        self.error(mozL10n.get('loading_error', null,

          'An error occurred while loading the PDF.'), moreInfo);

        self.loading = false;

      },

      function getDocumentProgress(progressData) {

        self.progress(progressData.loaded / progressData.total);

      }

    );

  },

  download: function pdfViewDownload() {

    function noData() {

      FirefoxCom.request('download', { originalUrl: url });

    }

    var url = this.url.split('#')[0];

    url += '#pdfjs.action=download';

    window.open(url, '_parent');

  },

  fallback: function pdfViewFallback() {

    return;

  },

  navigateTo: function pdfViewNavigateTo(dest) {

    if (typeof dest === 'string')

      dest = this.destinations[dest];

    if (!(dest instanceof Array))

      return; // invalid destination

    // dest array looks like that: <page-ref> </XYZ|FitXXX> <args..>

    var destRef = dest[0];

    var pageNumber = destRef instanceof Object ?

      this.pagesRefMap[destRef.num + ' ' + destRef.gen + ' R'] : (destRef + 1);

    if (pageNumber > this.pages.length)

      pageNumber = this.pages.length;

    if (pageNumber) {

      this.page = pageNumber;

      var currentPage = this.pages[pageNumber - 1];

      currentPage.scrollIntoView(dest);

    }

  },

  getDestinationHash: function pdfViewGetDestinationHash(dest) {

    if (typeof dest === 'string')

      return PDFView.getAnchorUrl('#' + escape(dest));

    if (dest instanceof Array) {

      var destRef = dest[0]; // see navigateTo method for dest format

      var pageNumber = destRef instanceof Object ?

        this.pagesRefMap[destRef.num + ' ' + destRef.gen + ' R'] :

        (destRef + 1);

      if (pageNumber) {

        var pdfOpenParams = PDFView.getAnchorUrl('#page=' + pageNumber);

        var destKind = dest[1];

        if (typeof destKind === 'object' && 'name' in destKind &&

            destKind.name == 'XYZ') {

          var scale = (dest[4] || this.currentScale);

          pdfOpenParams += '&zoom=' + (scale * 100);

          if (dest[2] || dest[3]) {

            pdfOpenParams += ',' + (dest[2] || 0) + ',' + (dest[3] || 0);

          }

        }

        return pdfOpenParams;

      }

    }

    return '';

  },

  /**

   * For the firefox extension we prefix the full url on anchor links so they

   * don't come up as resource:// urls and so open in new tab/window works.

   * @param {String} anchor The anchor hash include the #.

   */

  getAnchorUrl: function getAnchorUrl(anchor) {

    return anchor;

  },

  /**

   * Show the error box.

   * @param {String} message A message that is human readable.

   * @param {Object} moreInfo (optional) Further information about the error

   *                            that is more technical.  Should have a 'message'

   *                            and optionally a 'stack' property.

   */

  error: function pdfViewError(message, moreInfo) {

    var moreInfoText = mozL10n.get('error_build', {build: PDFJS.build},

      'PDF.JS Build: {{build}}') + '\n';

    if (moreInfo) {

      moreInfoText +=

        mozL10n.get('error_message', {message: moreInfo.message},

        'Message: {{message}}');

      if (moreInfo.stack) {

        moreInfoText += '\n' +

          mozL10n.get('error_stack', {stack: moreInfo.stack},

          'Stack: {{stack}}');

      } else {

        if (moreInfo.filename) {

          moreInfoText += '\n' +

            mozL10n.get('error_file', {file: moreInfo.filename},

            'File: {{file}}');

        }

        if (moreInfo.lineNumber) {

          moreInfoText += '\n' +

            mozL10n.get('error_line', {line: moreInfo.lineNumber},

            'Line: {{line}}');

        }

      }

    }

    var errorWrapper = document.getElementById('errorWrapper');

    errorWrapper.removeAttribute('hidden');

    var errorMessage = document.getElementById('errorMessage');

    errorMessage.textContent = message;

    var closeButton = document.getElementById('errorClose');

    closeButton.onclick = function() {

      errorWrapper.setAttribute('hidden', 'true');

    };

    var errorMoreInfo = document.getElementById('errorMoreInfo');

    var moreInfoButton = document.getElementById('errorShowMore');

    var lessInfoButton = document.getElementById('errorShowLess');

    moreInfoButton.onclick = function() {

      errorMoreInfo.removeAttribute('hidden');

      moreInfoButton.setAttribute('hidden', 'true');

      lessInfoButton.removeAttribute('hidden');

    };

    lessInfoButton.onclick = function() {

      errorMoreInfo.setAttribute('hidden', 'true');

      moreInfoButton.removeAttribute('hidden');

      lessInfoButton.setAttribute('hidden', 'true');

    };

    moreInfoButton.removeAttribute('hidden');

    lessInfoButton.setAttribute('hidden', 'true');

    errorMoreInfo.value = moreInfoText;

    errorMoreInfo.rows = moreInfoText.split('\n').length - 1;

  },

  progress: function pdfViewProgress(level) {

    var percent = Math.round(level * 100);

    PDFView.loadingBar.percent = percent;

  },

  load: function pdfViewLoad(pdfDocument, scale) {

    function bindOnAfterDraw(pageView, thumbnailView) {

      // when page is painted, using the image as thumbnail base

      pageView.onAfterDraw = function pdfViewLoadOnAfterDraw() {

        thumbnailView.setImage(pageView.canvas);

      };

    }

    this.pdfDocument = pdfDocument;

    var errorWrapper = document.getElementById('errorWrapper');

    errorWrapper.setAttribute('hidden', 'true');

    var loadingBox = document.getElementById('loadingBox');

    loadingBox.setAttribute('hidden', 'true');

    var loadingIndicator = document.getElementById('loading');

    loadingIndicator.textContent = '';

    var thumbsView = document.getElementById('thumbnailView');

    thumbsView.parentNode.scrollTop = 0;

    while (thumbsView.hasChildNodes())

      thumbsView.removeChild(thumbsView.lastChild);

    if ('_loadingInterval' in thumbsView)

      clearInterval(thumbsView._loadingInterval);

    var container = document.getElementById('viewer');

    while (container.hasChildNodes())

      container.removeChild(container.lastChild);

    var pagesCount = pdfDocument.numPages;

    var id = pdfDocument.fingerprint;

    var storedHash = null;

    document.getElementById('numPages').textContent =

      mozL10n.get('page_of', {pageCount: pagesCount}, 'of {{pageCount}}');

    document.getElementById('pageNumber').max = pagesCount;

    PDFView.documentFingerprint = id;

    var store = PDFView.store = new Settings(id);

    if (store.get('exists', false)) {

      var page = store.get('page', '1');

      var zoom = store.get('zoom', PDFView.currentScale);

      var left = store.get('scrollLeft', '0');

      var top = store.get('scrollTop', '0');

      storedHash = 'page=' + page + '&zoom=' + zoom + ',' + left + ',' + top;

    }

    var pages = this.pages = [];

    this.pageText = [];

    this.startedTextExtraction = false;

    var pagesRefMap = {};

    var thumbnails = this.thumbnails = [];

    var pagePromises = [];

    for (var i = 1; i <= pagesCount; i++)

      pagePromises.push(pdfDocument.getPage(i));

    var self = this;

    var pagesPromise = PDFJS.Promise.all(pagePromises);

    pagesPromise.then(function(promisedPages) {

      for (var i = 1; i <= pagesCount; i++) {

        var page = promisedPages[i - 1];

        var pageView = new PageView(container, page, i, scale,

                                    page.stats, self.navigateTo.bind(self));

        var thumbnailView = new ThumbnailView(thumbsView, page, i);

        bindOnAfterDraw(pageView, thumbnailView);

        pages.push(pageView);

        thumbnails.push(thumbnailView);

        var pageRef = page.ref;

        pagesRefMap[pageRef.num + ' ' + pageRef.gen + ' R'] = i;

      }

      self.pagesRefMap = pagesRefMap;

    });

    var destinationsPromise = pdfDocument.getDestinations();

    destinationsPromise.then(function(destinations) {

      self.destinations = destinations;

    });

    // outline and initial view depends on destinations and pagesRefMap

    PDFJS.Promise.all([pagesPromise, destinationsPromise]).then(function() {

      pdfDocument.getOutline().then(function(outline) {

        self.outline = new DocumentOutlineView(outline);

      });

      self.setInitialView(storedHash, scale);

    });

    pdfDocument.getMetadata().then(function(data) {

      var info = data.info, metadata = data.metadata;

      self.documentInfo = info;

      self.metadata = metadata;

      var pdfTitle;

      if (metadata) {

        if (metadata.has('dc:title'))

          pdfTitle = metadata.get('dc:title');

      }

      if (!pdfTitle && info && info['Title'])

        pdfTitle = info['Title'];

      if (pdfTitle)

        document.title = pdfTitle + ' - ' + document.title;

    });

  },

  setInitialView: function pdfViewSetInitialView(storedHash, scale) {

    // Reset the current scale, as otherwise the page's scale might not get

    // updated if the zoom level stayed the same.

    this.currentScale = 0;

    this.currentScaleValue = null;

    if (this.initialBookmark) {

      this.setHash(this.initialBookmark);

      this.initialBookmark = null;

    }

    else if (storedHash)

      this.setHash(storedHash);

    else if (scale) {

      this.parseScale(scale, true);

      this.page = 1;

    }

    if (PDFView.currentScale === kUnknownScale) {

      // Scale was not initialized: invalid bookmark or scale was not specified.

      // Setting the default one.

      this.parseScale(kDefaultScale, true);

    }

  },

  renderHighestPriority: function pdfViewRenderHighestPriority() {

    // Pages have a higher priority than thumbnails, so check them first.

    var visiblePages = this.getVisiblePages();

    var pageView = this.getHighestPriority(visiblePages, this.pages,

                                           this.pageViewScroll.down);

    if (pageView) {

      this.renderView(pageView, 'page');

      return;

    }

    // No pages needed rendering so check thumbnails.

    if (this.sidebarOpen) {

      var visibleThumbs = this.getVisibleThumbs();

      var thumbView = this.getHighestPriority(visibleThumbs,

                                              this.thumbnails,

                                              this.thumbnailViewScroll.down);

      if (thumbView)

        this.renderView(thumbView, 'thumbnail');

    }

  },

  getHighestPriority: function pdfViewGetHighestPriority(visible, views,

                                                         scrolledDown) {

    // The state has changed figure out which page has the highest priority to

    // render next (if any).

    // Priority:

    // 1 visible pages

    // 2 if last scrolled down page after the visible pages

    // 2 if last scrolled up page before the visible pages

    var visibleViews = visible.views;

    var numVisible = visibleViews.length;

    if (numVisible === 0) {

      return false;

    }

    for (var i = 0; i < numVisible; ++i) {

      var view = visibleViews[i].view;

      if (!this.isViewFinished(view))

        return view;

    }

    // All the visible views have rendered, try to render next/previous pages.

    if (scrolledDown) {

      var nextPageIndex = visible.last.id;

      // ID's start at 1 so no need to add 1.

      if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex]))

        return views[nextPageIndex];

    } else {

      var previousPageIndex = visible.first.id - 2;

      if (views[previousPageIndex] &&

          !this.isViewFinished(views[previousPageIndex]))

        return views[previousPageIndex];

    }

    // Everything that needs to be rendered has been.

    return false;

  },

  isViewFinished: function pdfViewNeedsRendering(view) {

    return view.renderingState === RenderingStates.FINISHED;

  },

  // Render a page or thumbnail view. This calls the appropriate function based

  // on the views state. If the view is already rendered it will return false.

  renderView: function pdfViewRender(view, type) {

    var state = view.renderingState;

    switch (state) {

      case RenderingStates.FINISHED:

        return false;

      case RenderingStates.PAUSED:

        PDFView.highestPriorityPage = type + view.id;

        view.resume();

        break;

      case RenderingStates.RUNNING:

        PDFView.highestPriorityPage = type + view.id;

        break;

      case RenderingStates.INITIAL:

        PDFView.highestPriorityPage = type + view.id;

        view.draw(this.renderHighestPriority.bind(this));

        break;

    }

    return true;

  },

  search: function pdfViewStartSearch() {

    // Limit this function to run every <SEARCH_TIMEOUT>ms.

    var SEARCH_TIMEOUT = 250;

    var lastSearch = this.lastSearch;

    var now = Date.now();

    if (lastSearch && (now - lastSearch) < SEARCH_TIMEOUT) {

      if (!this.searchTimer) {

        this.searchTimer = setTimeout(function resumeSearch() {

            PDFView.search();

          },

          SEARCH_TIMEOUT - (now - lastSearch)

        );

      }

      return;

    }

    this.searchTimer = null;

    this.lastSearch = now;

    function bindLink(link, pageNumber) {

      link.href = '#' + pageNumber;

      link.onclick = function searchBindLink() {

        PDFView.page = pageNumber;

        return false;

      };

    }

    var searchResults = document.getElementById('searchResults');

    var searchTermsInput = document.getElementById('searchTermsInput');

    searchResults.removeAttribute('hidden');

    searchResults.textContent = '';

    var terms = searchTermsInput.value;

    if (!terms)

      return;

    // simple search: removing spaces and hyphens, then scanning every

    terms = terms.replace(/\s-/g, '').toLowerCase();

    var index = PDFView.pageText;

    var pageFound = false;

    for (var i = 0, ii = index.length; i < ii; i++) {

      var pageText = index[i].replace(/\s-/g, '').toLowerCase();

      var j = pageText.indexOf(terms);

      if (j < 0)

        continue;

      var pageNumber = i + 1;

      var textSample = index[i].substr(j, 50);

      var link = document.createElement('a');

      bindLink(link, pageNumber);

      link.textContent = 'Page ' + pageNumber + ': ' + textSample;

      searchResults.appendChild(link);

      pageFound = true;

    }

    if (!pageFound) {

      searchResults.textContent = '';

      var noResults = document.createElement('div');

      noResults.classList.add('noResults');

      noResults.textContent = mozL10n.get('search_terms_not_found', null,

                                              '(Not found)');

      searchResults.appendChild(noResults);

    }

  },

  setHash: function pdfViewSetHash(hash) {

    if (!hash)

      return;

    if (hash.indexOf('=') >= 0) {

      var params = PDFView.parseQueryString(hash);

      // borrowing syntax from "Parameters for Opening PDF Files"

      if ('nameddest' in params) {

        PDFView.navigateTo(params.nameddest);

        return;

      }

      if ('page' in params) {

        var pageNumber = (params.page | 0) || 1;

        if ('zoom' in params) {

          var zoomArgs = params.zoom.split(','); // scale,left,top

          // building destination array

          // If the zoom value, it has to get divided by 100. If it is a string,

          // it should stay as it is.

          var zoomArg = zoomArgs[0];

          var zoomArgNumber = parseFloat(zoomArg);

          if (zoomArgNumber)

            zoomArg = zoomArgNumber / 100;

          var dest = [null, {name: 'XYZ'}, (zoomArgs[1] | 0),

            (zoomArgs[2] | 0), zoomArg];

          var currentPage = this.pages[pageNumber - 1];

          currentPage.scrollIntoView(dest);

        } else {

          this.page = pageNumber; // simple page

        }

      }

    } else if (/^\d+$/.test(hash)) // page number

      this.page = hash;

    else // named destination

      PDFView.navigateTo(unescape(hash));

  },

  switchSidebarView: function pdfViewSwitchSidebarView(view) {

    var thumbsView = document.getElementById('thumbnailView');

    var outlineView = document.getElementById('outlineView');

    var searchView = document.getElementById('searchView');

    var thumbsButton = document.getElementById('viewThumbnail');

    var outlineButton = document.getElementById('viewOutline');

    var searchButton = document.getElementById('viewSearch');

    switch (view) {

      case 'thumbs':

        thumbsButton.classList.add('toggled');

        outlineButton.classList.remove('toggled');

        searchButton.classList.remove('toggled');

        thumbsView.classList.remove('hidden');

        outlineView.classList.add('hidden');

        searchView.classList.add('hidden');

        PDFView.renderHighestPriority();

        break;

      case 'outline':

        thumbsButton.classList.remove('toggled');

        outlineButton.classList.add('toggled');

        searchButton.classList.remove('toggled');

        thumbsView.classList.add('hidden');

        outlineView.classList.remove('hidden');

        searchView.classList.add('hidden');

        if (outlineButton.getAttribute('disabled'))

          return;

        break;

      case 'search':

        thumbsButton.classList.remove('toggled');

        outlineButton.classList.remove('toggled');

        searchButton.classList.add('toggled');

        thumbsView.classList.add('hidden');

        outlineView.classList.add('hidden');

        searchView.classList.remove('hidden');

        var searchTermsInput = document.getElementById('searchTermsInput');

        searchTermsInput.focus();

        // Start text extraction as soon as the search gets displayed.

        this.extractText();

        break;

    }

  },

  extractText: function() {

    if (this.startedTextExtraction)

      return;

    this.startedTextExtraction = true;

    var self = this;

    function extractPageText(pageIndex) {

      self.pages[pageIndex].pdfPage.getTextContent().then(

        function textContentResolved(textContent) {

          self.pageText[pageIndex] = textContent;

          self.search();

          if ((pageIndex + 1) < self.pages.length)

            extractPageText(pageIndex + 1);

        }

      );

    }

    extractPageText(0);

  },

  getVisiblePages: function pdfViewGetVisiblePages() {

    return this.getVisibleElements(this.container,

                                   this.pages, true);

  },

  getVisibleThumbs: function pdfViewGetVisibleThumbs() {

    return this.getVisibleElements(this.thumbnailContainer,

                                   this.thumbnails);

  },

  // Generic helper to find out what elements are visible within a scroll pane.

  getVisibleElements: function pdfViewGetVisibleElements(

      scrollEl, views, sortByVisibility) {

    var currentHeight = 0, view;

    var top = scrollEl.scrollTop;

    for (var i = 1, ii = views.length; i <= ii; ++i) {

      view = views[i - 1];

      currentHeight = view.el.offsetTop;

      if (currentHeight + view.el.clientHeight > top)

        break;

      currentHeight += view.el.clientHeight;

    }

    var visible = [];

    // Algorithm broken in fullscreen mode

    if (this.isFullscreen) {

      var currentPage = this.pages[this.page - 1];

      visible.push({

        id: currentPage.id,

        view: currentPage

      });

      return { first: currentPage, last: currentPage, views: visible};

    }

    var bottom = top + scrollEl.clientHeight;

    var nextHeight, hidden, percent, viewHeight;

    for (; i <= ii && currentHeight < bottom; ++i) {

      view = views[i - 1];

      viewHeight = view.el.clientHeight;

      currentHeight = view.el.offsetTop;

      nextHeight = currentHeight + viewHeight;

      hidden = Math.max(0, top - currentHeight) +

               Math.max(0, nextHeight - bottom);

      percent = Math.floor((viewHeight - hidden) * 100.0 / viewHeight);

      visible.push({ id: view.id, y: currentHeight,

                     view: view, percent: percent });

      currentHeight = nextHeight;

    }

    var first = visible[0];

    var last = visible[visible.length - 1];

    if (sortByVisibility) {

      visible.sort(function(a, b) {

        var pc = a.percent - b.percent;

        if (Math.abs(pc) > 0.001)

          return -pc;

        return a.id - b.id; // ensure stability

      });

    }

    return {first: first, last: last, views: visible};

  },

  // Helper function to parse query string (e.g. ?param1=value&parm2=...).

  parseQueryString: function pdfViewParseQueryString(query) {

    var parts = query.split('&');

    var params = {};

    for (var i = 0, ii = parts.length; i < parts.length; ++i) {

      var param = parts[i].split('=');

      var key = param[0];

      var value = param.length > 1 ? param[1] : null;

      params[unescape(key)] = unescape(value);

    }

    return params;

  },

  beforePrint: function pdfViewSetupBeforePrint() {

    if (!this.supportsPrinting) {

      var printMessage = mozL10n.get('printing_not_supported', null,

          'Warning: Printing is not fully supported by this browser.');

      this.error(printMessage);

      return;

    }

    var body = document.querySelector('body');

    body.setAttribute('data-mozPrintCallback', true);

    for (var i = 0, ii = this.pages.length; i < ii; ++i) {

      this.pages[i].beforePrint();

    }

  },

  afterPrint: function pdfViewSetupAfterPrint() {

    var div = document.getElementById('printContainer');

    while (div.hasChildNodes())

      div.removeChild(div.lastChild);

  },

  fullscreen: function pdfViewFullscreen() {

    var isFullscreen = document.fullscreen || document.mozFullScreen ||

        document.webkitIsFullScreen;

    if (isFullscreen) {

      return false;

    }

    var wrapper = document.getElementById('viewerContainer');

    if (document.documentElement.requestFullScreen) {

      wrapper.requestFullScreen();

    } else if (document.documentElement.mozRequestFullScreen) {

      wrapper.mozRequestFullScreen();

    } else if (document.documentElement.webkitRequestFullScreen) {

      wrapper.webkitRequestFullScreen(Element.ALLOW_KEYBOARD_INPUT);

    } else {

      return false;

    }

    this.isFullscreen = true;

    var currentPage = this.pages[this.page - 1];

    this.previousScale = this.currentScaleValue;

    this.parseScale('page-fit', true);

    // Wait for fullscreen to take effect

    setTimeout(function() {

      currentPage.scrollIntoView();

    }, 0);

    return true;

  },

  exitFullscreen: function pdfViewExitFullscreen() {

    this.isFullscreen = false;

    this.parseScale(this.previousScale);

    this.page = this.page;

  }

};

var PageView = function pageView(container, pdfPage, id, scale,

                                 stats, navigateTo) {

  this.id = id;

  this.pdfPage = pdfPage;

  this.scale = scale || 1.0;

  this.viewport = this.pdfPage.getViewport(this.scale);

  this.renderingState = RenderingStates.INITIAL;

  this.resume = null;

  var anchor = document.createElement('a');

  anchor.name = '' + this.id;

  var div = this.el = document.createElement('div');

  div.id = 'pageContainer' + this.id;

  div.className = 'page';

  container.appendChild(anchor);

  container.appendChild(div);

  this.destroy = function pageViewDestroy() {

    this.update();

    this.pdfPage.destroy();

  };

  this.update = function pageViewUpdate(scale) {

    this.renderingState = RenderingStates.INITIAL;

    this.resume = null;

    this.scale = scale || this.scale;

    var viewport = this.pdfPage.getViewport(this.scale);

    this.viewport = viewport;

    div.style.width = viewport.width + 'px';

    div.style.height = viewport.height + 'px';

    while (div.hasChildNodes())

      div.removeChild(div.lastChild);

    div.removeAttribute('data-loaded');

    delete this.canvas;

    this.loadingIconDiv = document.createElement('div');

    this.loadingIconDiv.className = 'loadingIcon';

    div.appendChild(this.loadingIconDiv);

  };

  Object.defineProperty(this, 'width', {

    get: function PageView_getWidth() {

      return this.viewport.width;

    },

    enumerable: true

  });

  Object.defineProperty(this, 'height', {

    get: function PageView_getHeight() {

      return this.viewport.height;

    },

    enumerable: true

  });

  function setupAnnotations(pdfPage, viewport) {

    function bindLink(link, dest) {

      link.href = PDFView.getDestinationHash(dest);

      link.onclick = function pageViewSetupLinksOnclick() {

        if (dest)

          PDFView.navigateTo(dest);

        return false;

      };

    }

    function createElementWithStyle(tagName, item) {

      var rect = viewport.convertToViewportRectangle(item.rect);

      rect = PDFJS.Util.normalizeRect(rect);

      var element = document.createElement(tagName);

      element.style.left = Math.floor(rect[0]) + 'px';

      element.style.top = Math.floor(rect[1]) + 'px';

      element.style.width = Math.ceil(rect[2] - rect[0]) + 'px';

      element.style.height = Math.ceil(rect[3] - rect[1]) + 'px';

      return element;

    }

    function createCommentAnnotation(type, item) {

      var container = document.createElement('section');

      container.className = 'annotComment';

      var image = createElementWithStyle('img', item);

      var type = item.type;

      var rect = viewport.convertToViewportRectangle(item.rect);

      rect = PDFJS.Util.normalizeRect(rect);

      image.src = kImageDirectory + 'annotation-' + type.toLowerCase() + '.svg';

      image.alt = mozL10n.get('text_annotation_type', {type: type},

        '[{{type}} Annotation]');

      var content = document.createElement('div');

      content.setAttribute('hidden', true);

      var title = document.createElement('h1');

      var text = document.createElement('p');

      content.style.left = Math.floor(rect[2]) + 'px';

      content.style.top = Math.floor(rect[1]) + 'px';

      title.textContent = item.title;

      if (!item.content && !item.title) {

        content.setAttribute('hidden', true);

      } else {

        var e = document.createElement('span');

        var lines = item.content.split('\n');

        for (var i = 0, ii = lines.length; i < ii; ++i) {

          var line = lines[i];

          e.appendChild(document.createTextNode(line));

          if (i < (ii - 1))

            e.appendChild(document.createElement('br'));

        }

        text.appendChild(e);

        image.addEventListener('mouseover', function annotationImageOver() {

           content.removeAttribute('hidden');

        }, false);

        image.addEventListener('mouseout', function annotationImageOut() {

           content.setAttribute('hidden', true);

        }, false);