| Index: chrome/browser/resources/ntp_android/ntp_android.js
|
| diff --git a/chrome/browser/resources/ntp_android/ntp_android.js b/chrome/browser/resources/ntp_android/ntp_android.js
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..f5411fe9cd36836a0741512828b46e4d7dfa188f
|
| --- /dev/null
|
| +++ b/chrome/browser/resources/ntp_android/ntp_android.js
|
| @@ -0,0 +1,2488 @@
|
| +// Copyright (c) 2011 The Chromium Authors. All rights reserved.
|
| +// Use of this source code is governed by a BSD-style license that can be
|
| +// found in the LICENSE file.
|
| +
|
| +// File Description:
|
| +// Contains all the necessary functions for rendering the NTP on mobile
|
| +// devices.
|
| +
|
| +/**
|
| + * The event type used to determine when a touch starts.
|
| + * @type {string}
|
| + */
|
| +var PRESS_START_EVT = 'touchstart';
|
| +
|
| +/**
|
| + * The event type used to determine when a touch finishes.
|
| + * @type {string}
|
| + */
|
| +var PRESS_STOP_EVT = 'touchend';
|
| +
|
| +/**
|
| + * The event type used to determine when a touch moves.
|
| + * @type {string}
|
| + */
|
| +var PRESS_MOVE_EVT = 'touchmove';
|
| +
|
| +cr.define('ntp', function() {
|
| + /**
|
| + * Constant for the localStorage key used to specify the default bookmark
|
| + * folder to be selected when navigating to the bookmark tab for the first
|
| + * time of a new NTP instance.
|
| + * @type {string}
|
| + */
|
| + var DEFAULT_BOOKMARK_FOLDER_KEY = 'defaultBookmarkFolder';
|
| +
|
| + /**
|
| + * Constant for the localStorage key used to store whether or not sync was
|
| + * enabled on the last call to syncEnabled().
|
| + * @type {string}
|
| + */
|
| + var SYNC_ENABLED_KEY = 'syncEnabled';
|
| +
|
| + /**
|
| + * The time before and item gets marked as active (in milliseconds). This
|
| + * prevents an item from being marked as active when the user is scrolling
|
| + * the page.
|
| + * @type {number}
|
| + */
|
| + var ACTIVE_ITEM_DELAY_MS = 100;
|
| +
|
| + /**
|
| + * The CSS class identifier for grid layouts.
|
| + * @type {string}
|
| + */
|
| + var GRID_CSS_CLASS = 'icon-grid';
|
| +
|
| + /**
|
| + * The element to center when centering a GRID_CSS_CLASS.
|
| + */
|
| + var GRID_CENTER_CSS_CLASS = 'center-icon-grid';
|
| +
|
| + /**
|
| + * Attribute used to specify the number of columns to use in a grid. If
|
| + * left unspecified, the grid will fill the container.
|
| + */
|
| + var GRID_COLUMNS = 'grid-columns';
|
| +
|
| + /**
|
| + * Attribute used to specify whether the top margin should be set to match
|
| + * the left margin of the grid.
|
| + */
|
| + var GRID_SET_TOP_MARGIN_CLASS = 'grid-set-top-margin';
|
| +
|
| + /**
|
| + * Attribute used to specify whether the margins of individual items within
|
| + * the grid should be adjusted to better fill the space.
|
| + */
|
| + var GRID_SET_ITEM_MARGINS = 'grid-set-item-margins';
|
| +
|
| + /**
|
| + * The CSS class identifier for centered empty section containers.
|
| + */
|
| + var CENTER_EMPTY_CONTAINER_CSS_CLASS = 'center-empty-container';
|
| +
|
| + /**
|
| + * The CSS class identifier for marking list items as active.
|
| + * @type {string}
|
| + */
|
| + var ACTIVE_LIST_ITEM_CSS_CLASS = 'list-item-active';
|
| +
|
| + /**
|
| + * Attributes set on elements representing data in a section, specifying
|
| + * which section that element belongs to. Used for context menus.
|
| + * @type {string}
|
| + */
|
| + var SECTION_KEY = 'sectionType';
|
| +
|
| + /**
|
| + * Attribute set on an element that has a context menu. Specifies the URL for
|
| + * which the context menu action should apply.
|
| + * @type {string}
|
| + */
|
| + var CONTEXT_MENU_URL_KEY = 'url';
|
| +
|
| + /**
|
| + * The list of main section panes added.
|
| + * @type {Array.<Element>}
|
| + */
|
| + var panes = [];
|
| +
|
| + /**
|
| + * The list of section prefixes, which are used to append to the hash of the
|
| + * page to allow the native toolbar to see url changes when the pane is
|
| + * switched.
|
| + */
|
| + var sectionPrefixes = [];
|
| +
|
| + /**
|
| + * The next available index for new favicons. Users must increment this
|
| + * value once assigning this index to a favicon.
|
| + * @type {number}
|
| + */
|
| + var faviconIndex = 0;
|
| +
|
| + /**
|
| + * The currently selected pane DOM element.
|
| + * @type {Element}
|
| + */
|
| + var currentPane = null;
|
| +
|
| + /**
|
| + * The index of the currently selected top level pane. The index corresponds
|
| + * to the elements defined in {@see #panes}.
|
| + * @type {number}
|
| + */
|
| + var currentPaneIndex;
|
| +
|
| + /**
|
| + * The ID of the bookmark folder currently selected.
|
| + * @type {string|number}
|
| + */
|
| + var bookmarkFolderId = null;
|
| +
|
| + /**
|
| + * The current element active item.
|
| + * @type {?Element}
|
| + */
|
| + var activeItem;
|
| +
|
| + /**
|
| + * The element to be marked as active if no actions cancel it.
|
| + * @type {?Element}
|
| + */
|
| + var pendingActiveItem;
|
| +
|
| + /**
|
| + * The timer ID to mark an element as active.
|
| + * @type {number}
|
| + */
|
| + var activeItemDelayTimerId;
|
| +
|
| + /**
|
| + * Enum for the different send notification types based on whether NTP has
|
| + * loaded sent notification.
|
| + * @enum {number}
|
| + */
|
| + var SendNotificationType = {
|
| + LOAD_NOT_DONE: 0,
|
| + LOAD_DONE_NOTIFICATION_NOT_SENT: 1,
|
| + LOAD_DONE_NOTIFICATION_SENT: 2
|
| + };
|
| +
|
| + /**
|
| + * Whether to send notification when page is done loading
|
| + * @type {boolean}
|
| + */
|
| + var finishedLoadingSendNotification = SendNotificationType.LOAD_NOT_DONE;
|
| +
|
| + /**
|
| + * Time the page load finished notification was last sent out
|
| + * @type {boolean}
|
| + */
|
| + var timeLastSendNotification = 0;
|
| +
|
| + /**
|
| + * Whether the NTP is in incognito mode or not.
|
| + * @type {boolean}
|
| + */
|
| + var isIncognito = false;
|
| +
|
| + /**
|
| + * Whether the initial history state has been replaced. The state will be
|
| + * replaced once the bookmark data has loaded to ensure the proper folder
|
| + * id is persisted.
|
| + * @type {boolean}
|
| + */
|
| + var replacedInitialState = false;
|
| +
|
| + /**
|
| + * Stores number of most visited pages.
|
| + * @type {number}
|
| + */
|
| + var numberOfMostVisitedPages = 0;
|
| +
|
| + /**
|
| + * Whether there are any recently closed tabs.
|
| + * @type {boolean}
|
| + */
|
| + var hasRecentlyClosedTabs = false;
|
| +
|
| + /**
|
| + * Whether promo is not allowed or not (external to NTP).
|
| + * @type {boolean}
|
| + */
|
| + var promoIsAllowed = false;
|
| +
|
| + function setIncognitoMode(incognito) {
|
| + isIncognito = incognito;
|
| + }
|
| +
|
| + /**
|
| + * The different sections that are displayed.
|
| + * @enum {number}
|
| + */
|
| + var SectionType = {
|
| + BOOKMARKS: 0,
|
| + INCOGNITO: 1,
|
| + MOST_VISITED: 2,
|
| + RECENTLY_CLOSED: 3,
|
| + SYNCED_DEVICES: 4,
|
| + FOREIGN_SESSION: 5,
|
| + FOREIGN_SESSION_HEADER: 6,
|
| + SNAPSHOTS: 7,
|
| + UNKNOWN: 100,
|
| + };
|
| +
|
| + /**
|
| + * The different ids used of our custom context menu. Sent to the ChromeView
|
| + * and sent back when a menu is selected.
|
| + * @enum {number}
|
| + */
|
| + var ContextMenuItemIds = {
|
| + BOOKMARK_EDIT: 0,
|
| + BOOKMARK_DELETE: 1,
|
| + BOOKMARK_OPEN_IN_NEW_TAB: 2,
|
| + BOOKMARK_OPEN_IN_INCOGNITO_TAB: 3,
|
| + BOOKMARK_SHORTCUT: 4,
|
| +
|
| + MOST_VISITED_OPEN_IN_NEW_TAB: 10,
|
| + MOST_VISITED_OPEN_IN_INCOGNITO_TAB: 11,
|
| + MOST_VISITED_REMOVE: 12,
|
| +
|
| + RECENTLY_CLOSED_OPEN_IN_NEW_TAB: 20,
|
| + RECENTLY_CLOSED_OPEN_IN_INCOGNITO_TAB: 21,
|
| + RECENTLY_CLOSED_REMOVE: 22,
|
| +
|
| + FOREIGN_SESSIONS_REMOVE: 30,
|
| + };
|
| +
|
| + /**
|
| + * The URL of the element for the context menu.
|
| + * @type {string}
|
| + */
|
| + var contextMenuUrl = null;
|
| +
|
| + var contextMenuItem = null;
|
| +
|
| + var currentSnapshots = null;
|
| +
|
| + var currentSessions = null;
|
| +
|
| + /**
|
| + * The possible states of the sync section
|
| + * @enum {number}
|
| + */
|
| + var SyncState = {
|
| + INITIAL: 0,
|
| + WAITING_FOR_DATA: 1,
|
| + DISPLAYING_LOADING: 2,
|
| + DISPLAYED_LOADING: 3,
|
| + LOADED: 3,
|
| + };
|
| +
|
| + /**
|
| + * The current state of the sync section.
|
| + */
|
| + var syncState = SyncState.INITIAL;
|
| +
|
| + /**
|
| + * Whether or not sync is enabled. It will be undefined until
|
| + * setSyncEnabled() is called.
|
| + * @type {?boolean}
|
| + */
|
| + var syncEnabled = undefined;
|
| +
|
| + /**
|
| + * The current bookmark data being displayed. Keep a reference to this data
|
| + * in case the sync enabled state changes. In this case, the bookmark data
|
| + * will need to be refiltered.
|
| + * @type {?Object}
|
| + */
|
| + var bookmarkData;
|
| +
|
| + /**
|
| + * Keep track of any outstanding timers related to updating the sync section.
|
| + */
|
| + var syncTimerId = -1;
|
| +
|
| + /**
|
| + * The minimum amount of time that 'Loading...' can be displayed. This is to
|
| + * prevent flashing.
|
| + */
|
| + var SYNC_LOADING_TIMEOUT = 1000;
|
| +
|
| + /**
|
| + * How long to wait for sync data to load before displaying the 'Loading...'
|
| + * text to the user.
|
| + */
|
| + var SYNC_INITIAL_LOAD_TIMEOUT = 1000;
|
| +
|
| + /**
|
| + * An array of images that are currently in loading state. Once an image
|
| + * loads it is removed from this array.
|
| + */
|
| + var imagesBeingLoaded = new Array();
|
| +
|
| + /**
|
| + * Flag indicating if we are on bookmark shortcut mode.
|
| + * In this mode, only the bookmark section is available and selecting
|
| + * a non-folder bookmark adds it to the home screen.
|
| + * Context menu is disabled.
|
| + */
|
| + var bookmarkShortcutMode = false;
|
| +
|
| + /**
|
| + * Flag set to true when the page is loading its initial set of images. This
|
| + * is set to false after all the initial images have loaded.
|
| + */
|
| + function onInitialImageLoaded(event) {
|
| + var url = event.target.src;
|
| + for (var i = 0; i < imagesBeingLoaded.length; ++i) {
|
| + if (imagesBeingLoaded[i].src == url) {
|
| + imagesBeingLoaded.splice(i, 1);
|
| + if (imagesBeingLoaded.length == 0) {
|
| + // To send out the NTP loading complete notification.
|
| + finishedLoadingSendNotification =
|
| + SendNotificationType.LOAD_DONE_NOTIFICATION_NOT_SENT;
|
| + sendNTPNotification();
|
| + }
|
| + }
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Marks the given image as currently being loaded. Once all such images load
|
| + * we inform the browser via a hash change.
|
| + */
|
| + function trackImageLoad(url) {
|
| + if (finishedLoadingSendNotification != SendNotificationType.LOAD_NOT_DONE)
|
| + return;
|
| + for (var i = 0; i < imagesBeingLoaded.length; ++i) {
|
| + if (imagesBeingLoaded[i].src == url)
|
| + return;
|
| + }
|
| + var image = new Image();
|
| + image.onload = onInitialImageLoaded;
|
| + image.onerror = onInitialImageLoaded;
|
| + image.src = url;
|
| + imagesBeingLoaded.push(image);
|
| + }
|
| +
|
| + /**
|
| + * Initializes all the UI once the page has loaded.
|
| + */
|
| + function init() {
|
| + // Special case to handle NTP caching.
|
| + if (window.location.hash == '#cached_ntp')
|
| + document.location.hash = '#most_visited';
|
| + // Special case to show a specific bookmarks folder.
|
| + // Used to show the mobile bookmarks folder after importing.
|
| + var bookmarkIdMatch = window.location.hash.match(/#bookmarks:(\d+)/);
|
| + if (bookmarkIdMatch && bookmarkIdMatch.length == 2) {
|
| + localStorage.setItem(DEFAULT_BOOKMARK_FOLDER_KEY, bookmarkIdMatch[1]);
|
| + document.location.hash = '#bookmarks';
|
| + }
|
| + // Special case to choose a bookmark for adding a shortcut.
|
| + // See the doc of bookmarkShortcutMode for details.
|
| + if (window.location.hash == '#bookmark_shortcut')
|
| + bookmarkShortcutMode = true;
|
| + // Make sure a valid section is always displayed. Both normal and
|
| + // incognito NTPs have a bookmarks section.
|
| + if (getPaneIndexFromHash() < 0)
|
| + document.location.hash = '#bookmarks';
|
| +
|
| + // Initialize common widgets.
|
| + var titleScrollers =
|
| + document.getElementsByClassName('section-title-wrapper');
|
| + for (var i = 0, len = titleScrollers.length; i < len; i++)
|
| + initializeTitleScroller(titleScrollers[i]);
|
| +
|
| + chrome.send('getMostVisited');
|
| + chrome.send('getRecentlyClosedTabs');
|
| + chrome.send('getForeignSessions');
|
| + chrome.send('getPromotions');
|
| +
|
| + setCurrentBookmarkFolderData(
|
| + localStorage.getItem(DEFAULT_BOOKMARK_FOLDER_KEY));
|
| +
|
| + addMainSection('incognito');
|
| + addMainSection('most_visited');
|
| + addMainSection('bookmarks');
|
| + addMainSection('open_tabs');
|
| +
|
| + computeDynamicLayout();
|
| +
|
| + scrollToPane(getPaneIndexFromHash());
|
| + updateSyncEmptyState();
|
| +
|
| + window.onpopstate = onPopStateHandler;
|
| + window.addEventListener('hashchange', updatePaneOnHash);
|
| + window.addEventListener('resize', windowResizeHandler);
|
| +
|
| + if (!bookmarkShortcutMode)
|
| + window.addEventListener('contextmenu', contextMenuHandler);
|
| + }
|
| +
|
| + /**
|
| + * Notifies the chrome process of the status of the NTP.
|
| + */
|
| + function sendNTPNotification() {
|
| + var now = new Date();
|
| + if (finishedLoadingSendNotification ==
|
| + SendNotificationType.LOAD_DONE_NOTIFICATION_NOT_SENT) {
|
| + finishedLoadingSendNotification ==
|
| + SendNotificationType.LOAD_DONE_NOTIFICATION_SENT;
|
| + timeLastSendNotification = now.getTime();
|
| + chrome.send('notifyNTPReady');
|
| + } else if (finishedLoadingSendNotification ==
|
| + SendNotificationType.LOAD_DONE_NOTIFICATION_SENT ||
|
| + ((now.getTime() - timeLastSendNotification) > 100)) {
|
| + // Navigating after the loading complete notification has been sent
|
| + // might break tests.
|
| + chrome.send('NTPUnexpectedNavigation');
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Triggers the edit bookmark prompt for a given bookmark.
|
| + *
|
| + * @param {Object} item Object containing information for the selected
|
| + * bookmark node.
|
| + */
|
| + function editBookmark(item) {
|
| + if (item['editable'] !== true)
|
| + return;
|
| + var editBookmarkUrl = 'chrome://editbookmark/' +
|
| + '?id=' + item.id;
|
| + if (item['folder'])
|
| + editBookmarkUrl += '&isfolder=true';
|
| + window.location = editBookmarkUrl;
|
| + }
|
| +
|
| + /**
|
| + * The default click handler for created item shortcuts.
|
| + *
|
| + * @param {Object} item The item specification.
|
| + * @param {function} evt The browser click event triggered.
|
| + */
|
| + function itemShortcutClickHandler(item, evt) {
|
| + // Handle the touch callback
|
| + if (item['folder']) {
|
| + browseToBookmarkFolder(item.id);
|
| + } else {
|
| + if (bookmarkShortcutMode) {
|
| + chrome.send('shortcutToBookmark', [item.id]);
|
| + } else if (!!item.url) {
|
| + window.location = item.url;
|
| + }
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Opens a recently closed tab.
|
| + *
|
| + * @param {Object} item An object containing the necessary information to
|
| + * reopen a tab.
|
| + */
|
| + function openRecentlyClosedTab(item, evt) {
|
| + chrome.send('reopenTab', [item.sessionId]);
|
| + }
|
| +
|
| + /**
|
| + * Creates a 'div' DOM element.
|
| + *
|
| + * @param {string} className The CSS class name for the DIV.
|
| + * @param {string=} opt_backgroundUrl The background URL to be applied to the
|
| + * DIV if required.
|
| + * @return {Element} The newly created DIV element.
|
| + */
|
| + function createDiv(className, opt_backgroundUrl) {
|
| + var div = document.createElement('div');
|
| + div.className = className;
|
| + if (opt_backgroundUrl)
|
| + div.style.backgroundImage = 'url(' + opt_backgroundUrl + ')';
|
| + return div;
|
| + }
|
| +
|
| + /**
|
| + * Helper for creating new DOM elements.
|
| + *
|
| + * @param {string} type The type of Element to be created (i.e. 'div',
|
| + * 'span').
|
| + * @param {Object} params A mapping of element attribute key and values that
|
| + * should be applied to the new element.
|
| + * @return {Element} The newly created DOM element.
|
| + */
|
| + function createElement(type, params) {
|
| + var el = document.createElement(type);
|
| + if (typeof params === 'string') {
|
| + el.className = params;
|
| + } else {
|
| + for (attr in params) {
|
| + el[attr] = params[attr];
|
| + }
|
| + }
|
| + return el;
|
| + }
|
| +
|
| + /**
|
| + * Adds a click listener to a specified element with the ability to override
|
| + * the default value of itemShortcutClickHandler.
|
| + *
|
| + * @param {Element} el The element the click listener should be added to.
|
| + * @param {Object} item The item data represented by the element.
|
| + * @param {function(Object, string, BrowserEvent)=} opt_clickCallback The
|
| + * click callback to be triggered upon selection.
|
| + */
|
| + function wrapClickHandler(el, item, opt_clickCallback) {
|
| + el.addEventListener('click', function(evt) {
|
| + var clickCallback =
|
| + opt_clickCallback ? opt_clickCallback : itemShortcutClickHandler;
|
| + clickCallback(item, evt);
|
| + });
|
| + }
|
| +
|
| + /**
|
| + * Create a DOM element to contain a recently closed item for a tablet
|
| + * device.
|
| + *
|
| + * @param {Object} item The data of the item used to generate the shortcut.
|
| + * @param {function(Object, string, BrowserEvent)=} opt_clickCallback The
|
| + * click callback to be triggered upon selection (if not provided it will
|
| + * use the default -- itemShortcutClickHandler).
|
| + * @return {Element} The shortcut element created.
|
| + */
|
| + function makeRecentlyClosedTabletItem(item, opt_clickCallback) {
|
| + var cell = createDiv('cell');
|
| +
|
| + cell.setAttribute(CONTEXT_MENU_URL_KEY, item.url);
|
| +
|
| + var iconUrl = MOCK ?
|
| + touchIconURI : 'chrome://touch-icon/size/64/' + item.url;
|
| + var icon = createDiv('icon', iconUrl);
|
| + trackImageLoad(iconUrl);
|
| + cell.appendChild(icon);
|
| +
|
| + var title = createDiv('title');
|
| + title.textContent = item.title;
|
| + cell.appendChild(title);
|
| +
|
| + wrapClickHandler(cell, item, opt_clickCallback);
|
| +
|
| + return cell;
|
| + }
|
| +
|
| + /**
|
| + * Creates a shortcut DOM element based on the item specified item
|
| + * configuration using the thumbnail layout used for most visited. Other
|
| + * data types should not use this as they won't have a thumbnail.
|
| + *
|
| + * @param {Object} item The data of the item used to generate the shortcut.
|
| + * @param {function(Object, string, BrowserEvent)=} opt_clickCallback The
|
| + * click callback to be triggered upon selection (if not provided it will
|
| + * use the default -- itemShortcutClickHandler).
|
| + * @return {Element} The shortcut element created.
|
| + */
|
| + function makeMostVisitedItem(item, opt_clickCallback) {
|
| + // thumbnail-cell -- main outer container
|
| + // thumbnail-container -- container for the thumbnail
|
| + // thumbnail -- the actual thumbnail image; outer border
|
| + // inner-border -- inner border
|
| + // title -- container for the title
|
| + // img -- hack align title text baseline with bottom
|
| + // title text -- the actual text of the title
|
| + var thumbnailCell = createDiv('thumbnail-cell');
|
| + var thumbnailContainer = createDiv('thumbnail-container');
|
| + var backgroundUrl = item.thumbnailUrl || 'chrome://thumb/' + item.url;
|
| + if (MOCK)
|
| + backgroundUrl = thumbnailURI;
|
| + if (backgroundUrl == 'chrome://thumb/chrome://welcome/') {
|
| + // Ideally, it would be nice to use the URL as is. However, as of now
|
| + // theme support has been removed from Chrome. Instead, load the image
|
| + // URL from a style and use it. Don't just use the style because
|
| + // trackImageLoad(...) must be called with the background URL.
|
| + var welcomeStyle = findCssRule('.welcome-to-chrome').style;
|
| + var backgroundImage = welcomeStyle.backgroundImage;
|
| + // trim the "url(" prefix and ")" suffix
|
| + backgroundUrl = backgroundImage.substring(4, backgroundImage.length - 1);
|
| + }
|
| + trackImageLoad(backgroundUrl);
|
| + var thumbnail = createDiv('thumbnail');
|
| + // Use an Image object to ensure the thumbnail image actually exists. If
|
| + // not, this will allow the default to show instead.
|
| + var thumbnailImg = new Image();
|
| + thumbnailImg.onload = function() {
|
| + thumbnail.style.backgroundImage = 'url(' + backgroundUrl + ')';
|
| + };
|
| + thumbnailImg.src = backgroundUrl;
|
| +
|
| + thumbnailContainer.appendChild(thumbnail);
|
| + var innerBorder = createDiv('inner-border');
|
| + thumbnailContainer.appendChild(innerBorder);
|
| + thumbnailCell.appendChild(thumbnailContainer);
|
| + var title = createDiv('title');
|
| + title.textContent = item.title;
|
| + var spacerImg = createElement('img', 'title-spacer');
|
| + title.insertBefore(spacerImg, title.firstChild);
|
| + thumbnailCell.appendChild(title);
|
| +
|
| + wrapClickHandler(thumbnailContainer, item, opt_clickCallback);
|
| +
|
| + thumbnailCell.setAttribute(CONTEXT_MENU_URL_KEY, item.url);
|
| + thumbnailCell.contextMenuItem = item;
|
| + return thumbnailCell;
|
| + }
|
| +
|
| + /**
|
| + * Creates a shortcut DOM element based on the item specified item
|
| + * configuration using the favicon layout used for bookmarks.
|
| + *
|
| + * @param {Object} item The data of the item used to generate the shortcut.
|
| + * @param {function(Object, string, BrowserEvent)=} opt_clickCallback The
|
| + * click callback to be triggered upon selection (if not provided it will
|
| + * use the default -- itemShortcutClickHandler).
|
| + * @return {Element} The shortcut element created.
|
| + */
|
| + function makeBookmarkItem(item, opt_clickCallback) {
|
| + var holder = createDiv('favicon-cell');
|
| + addActiveTouchListener(holder, 'favicon-cell-active');
|
| +
|
| + holder.setAttribute(CONTEXT_MENU_URL_KEY, item.url);
|
| + holder.contextMenuItem = item;
|
| + var faviconBox = createDiv('favicon-box');
|
| + if (item.folder) {
|
| + faviconBox.classList.add('folder');
|
| + } else {
|
| + var iconUrl = MOCK ? item.icon : 'chrome://touch-icon/' + item.url;
|
| + var faviconIcon = createDiv('favicon-icon');
|
| + faviconIcon.style.backgroundImage = 'url(' + iconUrl + ')';
|
| + trackImageLoad(iconUrl);
|
| +
|
| + var image = new Image();
|
| + image.src = iconUrl;
|
| + image.onload = function() {
|
| + var w = image.width;
|
| + var h = image.height;
|
| + if (w <= 16 || h <= 16) {
|
| + // it's a standard favicon (or at least it's small)
|
| + faviconBox.classList.add('document');
|
| +
|
| + faviconBox.appendChild(
|
| + createDiv('color-strip colorstrip-' + faviconIndex));
|
| + faviconBox.appendChild(createDiv('bookmark-border'));
|
| + var foldDiv = createDiv('fold');
|
| + foldDiv.id = 'fold_' + faviconIndex;
|
| + foldDiv.style['background'] =
|
| + '-webkit-canvas(fold_' + faviconIndex + ')';
|
| +
|
| + // Use a container so that the fold it self can be zoomed without
|
| + // changing the positioning of the fold.
|
| + var foldContainer = createDiv('fold-container');
|
| + foldContainer.appendChild(foldDiv);
|
| + faviconBox.appendChild(foldContainer);
|
| +
|
| + chrome.send('getFaviconDominantColor',
|
| + [('chrome://favicon/size/16/' + item.url), '' + faviconIndex]);
|
| + faviconIndex++;
|
| + } else if ((w == 57 && h == 57) || (w == 114 && h == 114)) {
|
| + // it's a touch icon
|
| + faviconIcon.classList.add('touch-icon');
|
| + } else {
|
| + // it's an html5 icon (or at least it's larger)
|
| + var max = 64;
|
| + if (w > max || h > max) {
|
| + var scale = (w > h) ? (max / w) : (max / h);
|
| + w *= scale;
|
| + h *= scale;
|
| + }
|
| + faviconIcon.style.backgroundSize = w + 'px ' + h + 'px';
|
| + }
|
| + };
|
| + faviconBox.appendChild(faviconIcon);
|
| + }
|
| + holder.appendChild(faviconBox);
|
| +
|
| + var title = createDiv('title');
|
| + title.textContent = item.title;
|
| + holder.appendChild(title);
|
| +
|
| + wrapClickHandler(holder, item, opt_clickCallback);
|
| +
|
| + return holder;
|
| + }
|
| +
|
| + /**
|
| + * Adds touch listeners to the specified element to apply a class when it is
|
| + * selected (removing the class when no longer pressed).
|
| + *
|
| + * @param {Element} el The element to apply the class to when touched.
|
| + * @param {string} activeClass The CSS class name to be applied when active.
|
| + */
|
| + function addActiveTouchListener(el, activeClass) {
|
| + if (!window.touchCancelListener) {
|
| + window.touchCancelListener = function(evt) {
|
| + if (activeItemDelayTimerId) {
|
| + clearTimeout(activeItemDelayTimerId);
|
| + activeItemDelayTimerId = undefined;
|
| + }
|
| + if (!activeItem) {
|
| + return;
|
| + }
|
| + activeItem.classList.remove(activeItem.dataset.activeClass);
|
| + activeItem = null;
|
| + };
|
| + document.addEventListener('touchcancel', window.touchCancelListener);
|
| + }
|
| + el.dataset.activeClass = activeClass;
|
| + el.addEventListener(PRESS_START_EVT, function(evt) {
|
| + if (activeItemDelayTimerId) {
|
| + clearTimeout(activeItemDelayTimerId);
|
| + activeItemDelayTimerId = undefined;
|
| + }
|
| + activeItemDelayTimerId = setTimeout(function() {
|
| + el.classList.add(activeClass);
|
| + activeItem = el;
|
| + }, ACTIVE_ITEM_DELAY_MS);
|
| + });
|
| + el.addEventListener(PRESS_STOP_EVT, function(evt) {
|
| + if (activeItemDelayTimerId) {
|
| + clearTimeout(activeItemDelayTimerId);
|
| + activeItemDelayTimerId = undefined;
|
| + }
|
| + // Add the active class to ensure the pressed state is visible when
|
| + // quickly tapping, which can happen if the start and stop events are
|
| + // received before the active item delay timer has been executed.
|
| + el.classList.add(activeClass);
|
| + el.classList.add('no-active-delay');
|
| + setTimeout(function() {
|
| + el.classList.remove(activeClass);
|
| + el.classList.remove('no-active-delay');
|
| + }, 0);
|
| + activeItem = null;
|
| + });
|
| + }
|
| +
|
| + /**
|
| + * Creates a shortcut DOM element based on the item specified in the list
|
| + * format.
|
| + *
|
| + * @param {Object} item The data of the item used to generate the shortcut.
|
| + * @param {function(Object, string, BrowserEvent)=} opt_clickCallback The
|
| + * click callback to be triggered upon selection (if not provided it will
|
| + * use the default -- itemShortcutClickHandler).
|
| + * @return {Element} The shortcut element created.
|
| + */
|
| + function makeListEntryItem(item, opt_clickCallback) {
|
| + var listItem = createDiv('list-item');
|
| + addActiveTouchListener(listItem, ACTIVE_LIST_ITEM_CSS_CLASS);
|
| + listItem.setAttribute(CONTEXT_MENU_URL_KEY, item.url);
|
| + var iconUrl = MOCK ? item.icon : 'chrome://touch-icon/size/64/' + item.url;
|
| + listItem.appendChild(createDiv('icon', iconUrl));
|
| + trackImageLoad(iconUrl);
|
| + var title = createElement('span', {
|
| + textContent: item.title,
|
| + className: 'title'
|
| + });
|
| + listItem.appendChild(title);
|
| + listItem.addEventListener('click', function(evt) {
|
| + var clickCallback =
|
| + opt_clickCallback ? opt_clickCallback : itemShortcutClickHandler;
|
| + clickCallback(item, evt);
|
| + });
|
| + if (item.divider == 'section') {
|
| + // Add a child div because the section divider has a gradient and
|
| + // webkit doesn't seem to currently support borders with gradients.
|
| + listItem.appendChild(createDiv('section-divider'));
|
| + } else {
|
| + listItem.classList.add('standard-divider');
|
| + }
|
| + return listItem;
|
| + }
|
| +
|
| + /**
|
| + * Creates a DOM list entry for a remote session or tab.
|
| + *
|
| + * @param {Object} item The data of the item used to generate the shortcut.
|
| + * @param {function(Object, string, BrowserEvent)=} opt_clickCallback The
|
| + * click callback to be triggered upon selection (if not provided it will
|
| + * use the default -- itemShortcutClickHandler).
|
| + * @return {Element} The shortcut element created.
|
| + */
|
| + function makeForeignSessionListEntry(item, opt_clickCallback) {
|
| + // Session item
|
| + var sessionOuterDiv = createDiv('list-item standard-divider');
|
| + addActiveTouchListener(sessionOuterDiv, ACTIVE_LIST_ITEM_CSS_CLASS);
|
| + sessionOuterDiv.contextMenuItem = item;
|
| +
|
| + var icon = createDiv('session-icon ' + item.iconStyle);
|
| + sessionOuterDiv.appendChild(icon);
|
| +
|
| + var titleContainer = createElement('span', 'title');
|
| + sessionOuterDiv.appendChild(titleContainer);
|
| +
|
| + // Extra container to allow title & last-sync time to stack vertically.
|
| + var sessionInnerDiv = createDiv(null);
|
| + titleContainer.appendChild(sessionInnerDiv);
|
| +
|
| + var title = createDiv('session-name');
|
| + title.textContent = item.title;
|
| + sessionInnerDiv.appendChild(title);
|
| +
|
| + var lastSynced = createDiv('session-last-synced');
|
| + lastSynced.textContent =
|
| + templateData.opentabslastsynced + ': ' + item.userVisibleTimestamp;
|
| + sessionInnerDiv.appendChild(lastSynced);
|
| +
|
| + sessionOuterDiv.addEventListener('click', function(evt) {
|
| + var clickCallback =
|
| + opt_clickCallback ? opt_clickCallback : itemShortcutClickHandler;
|
| + clickCallback(item, evt);
|
| + });
|
| + return sessionOuterDiv;
|
| + }
|
| +
|
| + /**
|
| + * Saves the number of most visited pages and updates promo visibility.
|
| + * @param {number} n Number of most visited pages.
|
| + */
|
| + function setNumberOfMostVisitedPages(n) {
|
| + numberOfMostVisitedPages = n;
|
| + promoSetVisibility();
|
| + }
|
| +
|
| + /**
|
| + * Saves the recently closed tabs flag and updates promo visibility.
|
| + * @param {boolean} anyTabs Whether there are any recently closed tabs.
|
| + */
|
| + function setHasRecentlyClosedTabs(anyTabs) {
|
| + hasRecentlyClosedTabs = anyTabs;
|
| + promoSetVisibility();
|
| + }
|
| +
|
| + /**
|
| + * Updates the most visited pages.
|
| + *
|
| + * @param {Array.<Object>} List of data for displaying the list of most
|
| + * visited pages (see C++ handler for model description).
|
| + * @param {boolean} hasBlacklistedUrls Whether any blacklisted URLs are
|
| + * present.
|
| + */
|
| + function setMostVisitedPages(data, hasBlacklistedUrls) {
|
| + setNumberOfMostVisitedPages(data.length);
|
| + // limit the number of most visited items to display
|
| + if (isPhone() && data.length > 6) {
|
| + data.splice(6, data.length - 6);
|
| + } else if (isTablet() && data.length > 8) {
|
| + data.splice(8, data.length - 8);
|
| + }
|
| +
|
| + var clickFunction = function(item) {
|
| + chrome.send('metricsHandler:recordAction', ['MobileNTPMostVisited']);
|
| + window.location = item.url;
|
| + };
|
| + populateData(findList('most_visited'), SectionType.MOST_VISITED, data,
|
| + makeMostVisitedItem, clickFunction);
|
| + computeDynamicLayout();
|
| + }
|
| +
|
| + /**
|
| + * Updates the recently closed tabs.
|
| + *
|
| + * @param {Array.<Object>} List of data for displaying the list of recently
|
| + * closed tabs (see C++ handler for model description).
|
| + */
|
| + function setRecentlyClosedTabs(data) {
|
| + var container = $('recently_closed_container');
|
| + if (!data || data.length == 0) {
|
| + // hide the recently closed section if it is empty.
|
| + container.style.display = 'none';
|
| + setHasRecentlyClosedTabs(false);
|
| + } else {
|
| + container.style.display = 'block';
|
| + setHasRecentlyClosedTabs(true);
|
| + var decoratorFunc = isPhone() ? makeListEntryItem :
|
| + makeRecentlyClosedTabletItem;
|
| + populateData(findList('recently_closed'), SectionType.RECENTLY_CLOSED,
|
| + data, decoratorFunc, openRecentlyClosedTab);
|
| + }
|
| + computeDynamicLayout();
|
| + }
|
| +
|
| + /**
|
| + * Updates the bookmarks.
|
| + *
|
| + * @param {Array.<Object>} List of data for displaying the bookmarks (see
|
| + * C++ handler for model description).
|
| + */
|
| + function bookmarks(data) {
|
| + bookmarkFolderId = data.id;
|
| + if (!replacedInitialState) {
|
| + history.replaceState(
|
| + {folderId: bookmarkFolderId, selectedPaneIndex: currentPaneIndex},
|
| + null, null);
|
| + replacedInitialState = true;
|
| + }
|
| + if (syncEnabled == undefined) {
|
| + // Wait till we know whether or not sync is enabled before displaying any
|
| + // bookmarks (since they may need to be filtered below)
|
| + bookmarkData = data;
|
| + return;
|
| + }
|
| +
|
| + var titleWrapper = $('bookmarks_title_wrapper');
|
| + setBookmarkTitleHierarchy(
|
| + titleWrapper, data, data['hierarchy']);
|
| +
|
| + var filteredBookmarks = data.bookmarks;
|
| + if (!syncEnabled) {
|
| + filteredBookmarks = filteredBookmarks.filter(function(val) {
|
| + return (val.type != 'BOOKMARK_BAR' && val.type != 'OTHER_NODE');
|
| + });
|
| + }
|
| + if (bookmarkShortcutMode) {
|
| + populateData(findList('bookmarks'), SectionType.BOOKMARKS,
|
| + filteredBookmarks, makeBookmarkItem);
|
| + } else {
|
| + var clickFunction = function(item) {
|
| + if (item['folder']) {
|
| + browseToBookmarkFolder(item.id);
|
| + } else if (!!item.url) {
|
| + chrome.send('metricsHandler:recordAction', ['MobileNTPBookmark']);
|
| + window.location = item.url;
|
| + }
|
| + };
|
| + populateData(findList('bookmarks'), SectionType.BOOKMARKS,
|
| + filteredBookmarks, makeBookmarkItem, clickFunction);
|
| + }
|
| +
|
| + var bookmarkContainer = $('bookmarks_container');
|
| +
|
| + // update the shadows on the breadcrumb bar
|
| + computeDynamicLayout();
|
| + }
|
| +
|
| + /**
|
| + * Checks if promo is allowed and MostVisited requirements are satisfied.
|
| + * @return {boolean} Whether the promo should be shown on most_visited.
|
| + */
|
| + function shouldPromoBeShownOnMostVisited() {
|
| + return promoIsAllowed &&
|
| + (numberOfMostVisitedPages >= 2) &&
|
| + (!hasRecentlyClosedTabs);
|
| + }
|
| +
|
| + /**
|
| + * Checks if promo is allowed and OpenTabs requirements are satisfied.
|
| + * @return {boolean} Whether the promo should be shown on open_tabs.
|
| + */
|
| + function shouldPromoBeShownOnOpenTabs() {
|
| + var snapshotsCount =
|
| + currentSnapshots == null ? 0 : currentSnapshots.length;
|
| + var sessionsCount = currentSessions == null ? 0 : currentSessions.length;
|
| + return promoIsAllowed &&
|
| + (snapshotsCount + sessionsCount != 0);
|
| + }
|
| +
|
| + /**
|
| + * Checks if promo is allowed and SyncPromo requirements are satisfied.
|
| + * @return {boolean} Whether the promo should be shown on sync_promo.
|
| + */
|
| + function shouldPromoBeShownOnSyncPromo() {
|
| + var snapshotsCount =
|
| + currentSnapshots == null ? 0 : currentSnapshots.length;
|
| + var sessionsCount = currentSessions == null ? 0 : currentSessions.length;
|
| + return promoIsAllowed &&
|
| + (snapshotsCount + sessionsCount == 0);
|
| + }
|
| +
|
| + /**
|
| + * Records a promo impression on a given section if necessary.
|
| + * @param {string} section Active section name to check.
|
| + */
|
| + function promoUpdateImpressions(section) {
|
| + if (section == 'most_visited' && shouldPromoBeShownOnMostVisited()) {
|
| + chrome.send('recordImpression', ['most_visited']);
|
| + } else if (section == 'open_tabs' && shouldPromoBeShownOnOpenTabs()) {
|
| + chrome.send('recordImpression', ['open_tabs']);
|
| + } else if (section == 'open_tabs' && shouldPromoBeShownOnSyncPromo()) {
|
| + chrome.send('recordImpression', ['sync_promo']);
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Sets the visibility on all promo-related items as necessary.
|
| + */
|
| + function promoSetVisibility() {
|
| + var mostVisited = $('promo_message_on_most_visited');
|
| + var openTabs = $('promo_message_on_open_tabs');
|
| + if (shouldPromoBeShownOnMostVisited()) {
|
| + mostVisited.style.display = 'block';
|
| + } else {
|
| + mostVisited.style.display = 'none';
|
| + }
|
| + if (shouldPromoBeShownOnOpenTabs()) {
|
| + openTabs.style.display = 'block';
|
| + } else {
|
| + openTabs.style.display = 'none';
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Called from native.
|
| + * Sets the text for all promo-related items, updates
|
| + * promo-send-email-target items to send email on click and
|
| + * updates the visibility of items.
|
| + * @param {Object} promotions Dictionary used to fill-in the text.
|
| + */
|
| + function setPromotions(promotions) {
|
| + var mostVisited = $('promo_message_on_most_visited');
|
| + var openTabs = $('promo_message_on_open_tabs');
|
| + var syncPromoLegacy = $('promo_message_on_sync_promo_legacy');
|
| + mostVisited.innerHTML = promotions['promoMessage'];
|
| + openTabs.innerHTML = promotions['promoMessage'];
|
| + if (promotions['promoMessageLong']) {
|
| + syncPromoLegacy.innerHTML = promotions['promoMessageLong'];
|
| + }
|
| + promoIsAllowed = promotions['promoIsAllowed'] === true;
|
| + if (promoIsAllowed) {
|
| + var promoTargets =
|
| + document.getElementsByClassName('promo-action-target');
|
| + for (var i = 0, len = promoTargets.length; i < len; i++) {
|
| + promoTargets[i].href = 'javascript:void(0)';
|
| + promoTargets[i].onclick = promoAction;
|
| + }
|
| + }
|
| + promoSetVisibility();
|
| + }
|
| +
|
| + /**
|
| + * On-click handler for promo email targets.
|
| + * Performs the promo action "send email".
|
| + * @param {Object} evt User interface event that triggered the action.
|
| + */
|
| + function promoAction(evt) {
|
| + if (evt.preventDefault)
|
| + evt.preventDefault();
|
| + evt.returnValue = false;
|
| + chrome.send('promoActionTriggered');
|
| + }
|
| +
|
| + /**
|
| + * Called by the browser when a context menu has been selected.
|
| + *
|
| + * @param {number} itemId The id of the item that was selected, as specified
|
| + * when chrome.send('showContextMenu') was called.
|
| + */
|
| + function onCustomMenuSelected(itemId) {
|
| + switch (itemId) {
|
| + case ContextMenuItemIds.BOOKMARK_OPEN_IN_NEW_TAB:
|
| + case ContextMenuItemIds.MOST_VISITED_OPEN_IN_NEW_TAB:
|
| + case ContextMenuItemIds.RECENTLY_CLOSED_OPEN_IN_NEW_TAB:
|
| + if (contextMenuUrl != null)
|
| + chrome.send('openInNewTab', [contextMenuUrl]);
|
| + break;
|
| +
|
| + case ContextMenuItemIds.BOOKMARK_OPEN_IN_INCOGNITO_TAB:
|
| + case ContextMenuItemIds.MOST_VISITED_OPEN_IN_INCOGNITO_TAB:
|
| + case ContextMenuItemIds.RECENTLY_CLOSED_OPEN_IN_INCOGNITO_TAB:
|
| + if (contextMenuUrl != null)
|
| + chrome.send('openInIncognitoTab', [contextMenuUrl]);
|
| + break;
|
| +
|
| + case ContextMenuItemIds.BOOKMARK_EDIT:
|
| + if (contextMenuItem != null)
|
| + editBookmark(contextMenuItem);
|
| + break;
|
| +
|
| + case ContextMenuItemIds.BOOKMARK_DELETE:
|
| + if (contextMenuUrl != null)
|
| + chrome.send('deleteBookmark', [contextMenuItem.id]);
|
| + break;
|
| +
|
| + case ContextMenuItemIds.MOST_VISITED_REMOVE:
|
| + if (contextMenuUrl != null)
|
| + chrome.send('blacklistURLFromMostVisited', [contextMenuUrl]);
|
| + break;
|
| +
|
| + case ContextMenuItemIds.BOOKMARK_SHORTCUT:
|
| + if (contextMenuUrl != null)
|
| + chrome.send('shortcutToBookmark', [contextMenuItem.id]);
|
| + break;
|
| +
|
| + case ContextMenuItemIds.RECENTLY_CLOSED_REMOVE:
|
| + chrome.send('clearRecentlyClosed');
|
| + break;
|
| +
|
| + case ContextMenuItemIds.FOREIGN_SESSIONS_REMOVE:
|
| + if (contextMenuItem != null) {
|
| + chrome.send(
|
| + 'deleteForeignSession', [contextMenuItem.sessionTag]);
|
| + chrome.send('getForeignSessions');
|
| + }
|
| + break;
|
| +
|
| + default:
|
| + log.error('Unknown context menu selected id=' + itemId);
|
| + break;
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Generates the full bookmark folder hierarchy and populates the scrollable
|
| + * title element.
|
| + *
|
| + * @param {Element} wrapperEl The wrapper element containing the scrollable
|
| + * title.
|
| + * @param {string} data The current bookmark folder node.
|
| + * @param {Array.<Object>=} opt_ancestry The folder ancestry of the current
|
| + * bookmark folder. The list is ordered in order of closest descendant
|
| + * (the root will always be the last node). The definition of each
|
| + * element is:
|
| + * - id {number}: Unique ID of the folder (N/A for root node).
|
| + * - name {string}: Name of the folder (N/A for root node).
|
| + * - root {boolean}: Whether this is the root node.
|
| + */
|
| + function setBookmarkTitleHierarchy(wrapperEl, data, opt_ancestry) {
|
| + var title = wrapperEl.getElementsByClassName('section-title')[0];
|
| + title.innerHTML = '';
|
| + if (opt_ancestry) {
|
| + for (var i = opt_ancestry.length - 1; i >= 0; i--) {
|
| + var titleCrumb = createBookmarkTitleCrumb_(opt_ancestry[i]);
|
| + title.appendChild(titleCrumb);
|
| + title.appendChild(createDiv('bookmark-separator'));
|
| + }
|
| + }
|
| + var titleCrumb = createBookmarkTitleCrumb_(data);
|
| + titleCrumb.classList.add('title-crumb-active');
|
| + title.appendChild(titleCrumb);
|
| +
|
| + // Ensure the last crumb is as visible as possible.
|
| + var windowWidth =
|
| + wrapperEl.getElementsByClassName('section-title-mask')[0].offsetWidth;
|
| + var crumbWidth = titleCrumb.offsetWidth;
|
| + var leftOffset = titleCrumb.offsetLeft;
|
| +
|
| + var shiftLeft = windowWidth - crumbWidth - leftOffset;
|
| + if (shiftLeft < 0) {
|
| + if (crumbWidth > windowWidth)
|
| + shifLeft = -leftOffset;
|
| +
|
| + // Queue up the scrolling initially to allow for the mask element to
|
| + // be placed into the dom and it's size correctly calculated.
|
| + setTimeout(function() {
|
| + handleTitleScroll(wrapperEl, shiftLeft);
|
| + }, 0);
|
| + } else {
|
| + handleTitleScroll(wrapperEl, 0);
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Creates a clickable bookmark title crumb.
|
| + * @param {Object} data The crumb data (see setBookmarkTitleHierarchy for
|
| + * definition of the data object).
|
| + * @return {Element} The clickable title crumb element.
|
| + * @private
|
| + */
|
| + function createBookmarkTitleCrumb_(data) {
|
| + var titleCrumb = createDiv('title-crumb');
|
| + if (data.root) {
|
| + titleCrumb.innerText = templateData.bookmarkstitle;
|
| + } else {
|
| + titleCrumb.innerText = data.title;
|
| + }
|
| + titleCrumb.addEventListener('click', function(evt) {
|
| + browseToBookmarkFolder(data.root ? '0' : data.id);
|
| + });
|
| + return titleCrumb;
|
| + }
|
| +
|
| + /**
|
| + * Handles scrolling a title element.
|
| + * @param {Element} wrapperEl The wrapper element containing the scrollable
|
| + * title.
|
| + * @param {number} scrollPosition The position to be scrolled to.
|
| + */
|
| + function handleTitleScroll(wrapperEl, scrollPosition) {
|
| + var overflowLeftMask =
|
| + wrapperEl.getElementsByClassName('overflow-left-mask')[0];
|
| + var overflowRightMask =
|
| + wrapperEl.getElementsByClassName('overflow-right-mask')[0];
|
| + var title = wrapperEl.getElementsByClassName('section-title')[0];
|
| + var titleMask = wrapperEl.getElementsByClassName('section-title-mask')[0];
|
| + var titleWidth = title.scrollWidth;
|
| + var containerWidth = titleMask.offsetWidth;
|
| +
|
| + var maxRightScroll = containerWidth - titleWidth;
|
| + var boundedScrollPosition =
|
| + Math.max(maxRightScroll, Math.min(scrollPosition, 0));
|
| +
|
| + overflowLeftMask.style.opacity =
|
| + Math.min(
|
| + 1,
|
| + (Math.max(0, -boundedScrollPosition)) + 10 / 30);
|
| +
|
| + overflowRightMask.style.opacity =
|
| + Math.min(
|
| + 1,
|
| + (Math.max(0, boundedScrollPosition - maxRightScroll) + 10) / 30);
|
| +
|
| + // Set the position of the title.
|
| + if (titleWidth < containerWidth) {
|
| + title.style.left = '0px';
|
| + } else {
|
| + title.style.left = boundedScrollPosition + 'px';
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Initializes a scrolling title element.
|
| + * @param {Element} wrapperEl The wrapper element of the scrolling title.
|
| + */
|
| + function initializeTitleScroller(wrapperEl) {
|
| + var title = wrapperEl.getElementsByClassName('section-title')[0];
|
| +
|
| + var inTitleScroll = false;
|
| + var startingScrollPosition;
|
| + var startingOffset;
|
| + wrapperEl.addEventListener(PRESS_START_EVT, function(evt) {
|
| + inTitleScroll = true;
|
| + startingScrollPosition = getTouchEventX(evt);
|
| + startingOffset = title.offsetLeft;
|
| + });
|
| + document.body.addEventListener(PRESS_STOP_EVT, function(evt) {
|
| + if (!inTitleScroll)
|
| + return;
|
| + inTitleScroll = false;
|
| + });
|
| + document.body.addEventListener(PRESS_MOVE_EVT, function(evt) {
|
| + if (!inTitleScroll)
|
| + return;
|
| + handleTitleScroll(
|
| + wrapperEl,
|
| + startingOffset - (startingScrollPosition - getTouchEventX(evt)));
|
| + evt.stopPropagation();
|
| + });
|
| + }
|
| +
|
| + /**
|
| + * Handles updates from the underlying bookmark model (calls originate
|
| + * in the WebUI handler for bookmarks).
|
| + *
|
| + * @param {Object} status Describes the type of change that occurred. Can
|
| + * contain the following fields:
|
| + * - parent_id {string}: Unique id of the parent that was affected by
|
| + * the change. If the parent is the bookmark
|
| + * bar, then the ID will be 'root'.
|
| + * - node_id {string}: The unique ID of the node that was affected.
|
| + */
|
| + function bookmarkChanged(status) {
|
| + if (status) {
|
| + var affectedParentNode = status['parent_id'];
|
| + var affectedNodeId = status['node_id'];
|
| + var shouldUpdate = (bookmarkFolderId == affectedParentNode ||
|
| + bookmarkFolderId == affectedNodeId);
|
| + if (shouldUpdate)
|
| + setCurrentBookmarkFolderData(bookmarkFolderId);
|
| + } else {
|
| + // This typically happens when extensive changes could have happened to
|
| + // the model, such as initial load, import and sync.
|
| + setCurrentBookmarkFolderData(bookmarkFolderId);
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Loads the bookarks data for a given folder.
|
| + *
|
| + * @param {string|number} folderId The ID of the folder to load (or null if
|
| + * it should load the root folder).
|
| + */
|
| + function setCurrentBookmarkFolderData(folderId) {
|
| + if (folderId != null) {
|
| + chrome.send('getBookmarks', [folderId]);
|
| + } else {
|
| + chrome.send('getBookmarks');
|
| + }
|
| + try {
|
| + if (folderId == null) {
|
| + localStorage.removeItem(DEFAULT_BOOKMARK_FOLDER_KEY);
|
| + } else {
|
| + localStorage.setItem(DEFAULT_BOOKMARK_FOLDER_KEY, folderId);
|
| + }
|
| + } catch (e) {}
|
| + }
|
| +
|
| + /**
|
| + * Navigates to the specified folder and handles loading the required data.
|
| + * Ensures the current folder can be navigated back to using the browser
|
| + * controls.
|
| + *
|
| + * @param {string|number} folderId The ID of the folder to navigate to.
|
| + */
|
| + function browseToBookmarkFolder(folderId) {
|
| + history.pushState(
|
| + {folderId: folderId, selectedPaneIndex: currentPaneIndex},
|
| + null, null);
|
| + setCurrentBookmarkFolderData(folderId);
|
| + }
|
| +
|
| + /**
|
| + * Called to inform the page of the current sync status. If the state has
|
| + * changed from disabled to enabled, it changes the current and default
|
| + * bookmark section to the root directory. This makes desktop bookmarks are
|
| + * visible.
|
| + */
|
| + function setSyncEnabled(enabled) {
|
| + try {
|
| + if (syncEnabled != undefined && syncEnabled == enabled) {
|
| + // The value didn't change
|
| + return;
|
| + }
|
| + syncEnabled = enabled;
|
| +
|
| + if (enabled) {
|
| + if (!localStorage.getItem(SYNC_ENABLED_KEY)) {
|
| + localStorage.setItem(SYNC_ENABLED_KEY, 'true');
|
| + setCurrentBookmarkFolderData('0');
|
| + }
|
| + } else {
|
| + localStorage.removeItem(SYNC_ENABLED_KEY);
|
| + }
|
| +
|
| + if (bookmarkData) {
|
| + // Bookmark data can now be displayed (or needs to be refiltered)
|
| + bookmarks(bookmarkData);
|
| + }
|
| +
|
| + updateSyncEmptyState();
|
| + } catch (e) {}
|
| + }
|
| +
|
| + /**
|
| + * Handles adding or removing the 'nothing to see here' text from the session
|
| + * list depending on the state of snapshots and sessions.
|
| + *
|
| + * @param {boolean} Whether the call is occuring because of a schedule
|
| + * timeout.
|
| + */
|
| + function updateSyncEmptyState(timeout) {
|
| + if (syncState == SyncState.DISPLAYING_LOADING && !timeout) {
|
| + // Make sure 'Loading...' is displayed long enough
|
| + return;
|
| + }
|
| +
|
| + var openTabsList = findList('open_tabs');
|
| + var snapshotsList = findList('snapshots');
|
| + var syncPromo = $('sync_promo');
|
| + var syncLoading = $('sync_loading');
|
| + var syncEnableSync = $('sync_enable_sync');
|
| +
|
| + if (syncEnabled == undefined ||
|
| + currentSnapshots == null ||
|
| + currentSessions == null) {
|
| + if (syncState == SyncState.INITIAL) {
|
| + // Wait one second for sync data to come in before displaying loading
|
| + // text.
|
| + syncState = SyncState.WAITING_FOR_DATA;
|
| + syncTimerId = setTimeout(function() { updateSyncEmptyState(true); },
|
| + SYNC_INITIAL_LOAD_TIMEOUT);
|
| + } else if (syncState == SyncState.WAITING_FOR_DATA && timeout) {
|
| + // We've waited for the initial info timeout to pass and still don't
|
| + // have data. So, display loading text so the user knows something is
|
| + // happening.
|
| + syncState = SyncState.DISPLAYING_LOADING;
|
| + syncLoading.style.display = '-webkit-box';
|
| + centerEmptySections(syncLoading);
|
| + syncTimerId = setTimeout(function() { updateSyncEmptyState(true); },
|
| + SYNC_LOADING_TIMEOUT);
|
| + } else if (syncState == SyncState.DISPLAYING_LOADING) {
|
| + // Allow the Loading... text to go away once data comes in
|
| + syncState = SyncState.DISPLAYED_LOADING;
|
| + }
|
| + return;
|
| + }
|
| +
|
| + if (syncTimerId != -1) {
|
| + clearTimeout(syncTimerId);
|
| + syncTimerId = -1;
|
| + }
|
| + syncState = SyncState.LOADED;
|
| +
|
| + // Hide everything by default, display selectively below
|
| + syncEnableSync.style.display = 'none';
|
| + syncLoading.style.display = 'none';
|
| + syncPromo.style.display = 'none';
|
| +
|
| + var snapshotsCount =
|
| + currentSnapshots == null ? 0 : currentSnapshots.length;
|
| + var sessionsCount = currentSessions == null ? 0 : currentSessions.length;
|
| +
|
| + if (!syncEnabled) {
|
| + syncEnableSync.style.display = '-webkit-box';
|
| + centerEmptySections(syncEnableSync);
|
| + } else if (sessionsCount + snapshotsCount == 0) {
|
| + syncPromo.style.display = '-webkit-box';
|
| + centerEmptySections(syncPromo);
|
| + } else {
|
| + openTabsList.style.display = sessionsCount == 0 ? 'none' : 'block';
|
| + snapshotsList.style.display = snapshotsCount == 0 ? 'none' : 'block';
|
| + }
|
| + promoSetVisibility();
|
| + }
|
| +
|
| + /**
|
| + * Called externally when updated snapshot data is available.
|
| + *
|
| + * @param {Object} data The snapshot data
|
| + */
|
| + function snapshots(data) {
|
| + var list = findList('snapshots');
|
| + list.innerHTML = '';
|
| +
|
| + currentSnapshots = data;
|
| + updateSyncEmptyState();
|
| +
|
| + if (!data || data.length == 0)
|
| + return;
|
| +
|
| + data.sort(function(a, b) {
|
| + return b.createTime - a.createTime;
|
| + });
|
| +
|
| + // Create the main container
|
| + var snapshotsEl = createElement('div');
|
| + list.appendChild(snapshotsEl);
|
| +
|
| + // Create the header container
|
| + var headerEl = createDiv('session-header');
|
| + snapshotsEl.appendChild(headerEl);
|
| +
|
| + // Create the documents container
|
| + var docsEl = createDiv('session-children-container');
|
| + snapshotsEl.appendChild(docsEl);
|
| +
|
| + // Create the container for the title & icon
|
| + var headerInnerEl = createDiv('list-item standard-divider');
|
| + addActiveTouchListener(headerInnerEl, ACTIVE_LIST_ITEM_CSS_CLASS);
|
| + headerEl.appendChild(headerInnerEl);
|
| +
|
| + // Create the header icon
|
| + headerInnerEl.appendChild(createDiv('session-icon documents'));
|
| +
|
| + // Create the header title
|
| + var titleContainer = createElement('span', 'title');
|
| + headerInnerEl.appendChild(titleContainer);
|
| + var title = createDiv('session-name');
|
| + title.textContent = templateData.receivedDocuments;
|
| + titleContainer.appendChild(title);
|
| +
|
| + // Add support for expanding and collapsing the children
|
| + var expando = createDiv();
|
| + var expandoFunction = createExpandoFunction(expando, docsEl);
|
| + headerInnerEl.addEventListener('click', expandoFunction);
|
| + headerEl.appendChild(expando);
|
| +
|
| + // Support for actually opening the document
|
| + var snapshotClickCallback = function(item) {
|
| + if (!item)
|
| + return;
|
| + if (item.snapshotId) {
|
| + window.location = 'chrome://snapshot/' + item.snapshotId;
|
| + } else if (item.printJobId) {
|
| + window.location = 'chrome://printjob/' + item.printJobId;
|
| + } else {
|
| + window.location = item.url;
|
| + }
|
| + }
|
| +
|
| + // Finally, add the list of documents
|
| + populateData(docsEl, SectionType.SNAPSHOTS, data,
|
| + makeListEntryItem, snapshotClickCallback);
|
| + }
|
| +
|
| + /**
|
| + * Create a function to handle expanding and collapsing a section
|
| + *
|
| + * @param {Element} expando The expando div
|
| + * @param {Element} element The element to expand and collapse
|
| + * @return {function()} A callback function that should be invoked when the
|
| + * expando is clicked
|
| + */
|
| + function createExpandoFunction(expando, element) {
|
| + expando.className = 'expando open';
|
| + return function() {
|
| + if (element.style.height != '0px') {
|
| + // It seems that '-webkit-transition' only works when explicit pixel
|
| + // values are used.
|
| + setTimeout(function() {
|
| + // If this is the first time to collapse the list, store off the
|
| + // expanded height and also set the height explicitly on the style.
|
| + if (!element.expandedHeight) {
|
| + element.expandedHeight =
|
| + element.clientHeight + 'px';
|
| + element.style.height = element.expandedHeight;
|
| + }
|
| + // Now set the height to 0. Note, this is also done in a callback to
|
| + // give the layout engine a chance to run after possibly setting the
|
| + // height above.
|
| + setTimeout(function() {
|
| + element.style.height = '0px';
|
| + }, 0);
|
| + }, 0);
|
| + expando.className = 'expando closed';
|
| + } else {
|
| + element.style.height = element.expandedHeight;
|
| + expando.className = 'expando open';
|
| + }
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Called externally when updated synced sessions data is available.
|
| + *
|
| + * @param {Object} data The snapshot data
|
| + */
|
| + function setForeignSessions(data, tabSyncEnabled) {
|
| + var list = findList('open_tabs');
|
| + list.innerHTML = '';
|
| +
|
| + currentSessions = data;
|
| + updateSyncEmptyState();
|
| +
|
| + // Sort the windows within each client such that more recently
|
| + // modified windows appear first.
|
| + data.forEach(function(client) {
|
| + if (client.windows != null) {
|
| + client.windows.sort(function(a, b) {
|
| + if (b.timestamp == null) {
|
| + return -1;
|
| + } else if (a.timestamp == null) {
|
| + return 1;
|
| + } else {
|
| + return b.timestamp - a.timestamp;
|
| + }
|
| + });
|
| + }
|
| + });
|
| +
|
| + // Sort so more recently modified clients appear first.
|
| + data.sort(function(aClient, bClient) {
|
| + var aWindows = aClient.windows;
|
| + var bWindows = bClient.windows;
|
| + if (bWindows == null || bWindows.length == 0 ||
|
| + bWindows[0].timestamp == null) {
|
| + return -1;
|
| + } else if (aWindows == null || aWindows.length == 0 ||
|
| + aWindows[0].timestamp == null) {
|
| + return 1;
|
| + } else {
|
| + return bWindows[0].timestamp - aWindows[0].timestamp;
|
| + }
|
| + });
|
| +
|
| + data.forEach(function(client, clientNum) {
|
| +
|
| + var windows = client.windows;
|
| + if (windows == null || windows.length == 0)
|
| + return;
|
| +
|
| + // Set up the container for the session header
|
| + var sessionEl = createElement('div');
|
| + list.appendChild(sessionEl);
|
| + var sessionHeader = createDiv('session-header');
|
| + sessionEl.appendChild(sessionHeader);
|
| +
|
| + // Set up the container for the session children
|
| + var sessionChildren = createDiv('session-children-container');
|
| + sessionEl.appendChild(sessionChildren);
|
| +
|
| + var clientName = 'Client ' + clientNum;
|
| + if (client.name)
|
| + clientName = client.name;
|
| +
|
| + var iconStyle;
|
| + if (windows[0].deviceType == 'win' ||
|
| + windows[0].deviceType == 'macosx' ||
|
| + windows[0].deviceType == 'linux' ||
|
| + windows[0].deviceType == 'chromeos' ||
|
| + windows[0].deviceType == 'other') {
|
| + iconStyle = 'laptop';
|
| + } else if (windows[0].deviceType == 'phone') {
|
| + iconStyle = 'phone';
|
| + } else if (windows[0].deviceType == 'tablet') {
|
| + iconStyle = 'tablet';
|
| + } else {
|
| + console.error(
|
| + 'Unknown sync device type found: ', windows[0].deviceType);
|
| + iconStyle = 'laptop';
|
| + }
|
| + var headerList = [{
|
| + 'title': clientName,
|
| + 'userVisibleTimestamp': windows[0].userVisibleTimestamp,
|
| + 'iconStyle': iconStyle,
|
| + 'sessionTag': client.tag,
|
| + }];
|
| +
|
| + var expando = createDiv();
|
| + var expandoFunction = createExpandoFunction(expando, sessionChildren);
|
| + populateData(sessionHeader, SectionType.FOREIGN_SESSION_HEADER,
|
| + headerList, makeForeignSessionListEntry, expandoFunction);
|
| + sessionHeader.appendChild(expando);
|
| +
|
| + // Populate the session children container
|
| + var openTabsList = new Array();
|
| + for (var winNum = 0; winNum < windows.length; winNum++) {
|
| + win = windows[winNum];
|
| + var tabs = win.tabs;
|
| + for (var tabNum = 0; tabNum < tabs.length; tabNum++) {
|
| + var tab = tabs[tabNum];
|
| + // If this is the last tab in the window and there are more windows,
|
| + // use a section divider.
|
| + var needSectionDivider =
|
| + (tabNum + 1 == tabs.length) && (winNum + 1 < windows.length);
|
| + openTabsList.push({
|
| + timestamp: tab.timestamp,
|
| + title: tab.title,
|
| + url: tab.url,
|
| + sessionTag: client.tag,
|
| + winNum: winNum,
|
| + sessionId: tab.sessionId,
|
| + icon: tab.icon,
|
| + divider: needSectionDivider ? 'section' : 'standard',
|
| + });
|
| + }
|
| + }
|
| + var tabCallback = function(item, evt) {
|
| + var buttonIndex = 0;
|
| + var altKeyPressed = false;
|
| + var ctrlKeyPressed = false;
|
| + var metaKeyPressed = false;
|
| + var shiftKeyPressed = false;
|
| + if (evt instanceof MouseEvent) {
|
| + buttonIndex = evt.button;
|
| + altKeyPressed = evt.altKey;
|
| + ctrlKeyPressed = evt.ctrlKey;
|
| + metaKeyPressed = evt.metaKey;
|
| + shiftKeyPressed = evt.shiftKey;
|
| + }
|
| + chrome.send('metricsHandler:recordAction', ['MobileNTPForeignSession']);
|
| + chrome.send('openForeignSession', [String(item.sessionTag),
|
| + String(item.winNum), String(item.sessionId), buttonIndex,
|
| + altKeyPressed, ctrlKeyPressed, metaKeyPressed, shiftKeyPressed]);
|
| + };
|
| + populateData(sessionChildren, SectionType.FOREIGN_SESSION, openTabsList,
|
| + makeListEntryItem, tabCallback);
|
| + });
|
| + }
|
| +
|
| + /**
|
| + * Updates the dominant favicon color for a given index.
|
| + *
|
| + * @param {number} index The index of the favicon whose dominant color is
|
| + * being specified.
|
| + * @param {string} color The string encoded color.
|
| + */
|
| + function setFaviconDominantColor(index, color) {
|
| + var colorstrips = document.getElementsByClassName('colorstrip-' + index);
|
| + for (var i = 0; i < colorstrips.length; i++)
|
| + colorstrips[i].style.background = color;
|
| +
|
| + var id = 'fold_' + index;
|
| + var fold = $(id);
|
| + if (!fold)
|
| + return;
|
| + var zoom = window.getComputedStyle(fold).zoom;
|
| + var scale = 1 / window.getComputedStyle(fold).zoom;
|
| +
|
| + // Get the fold canvas and create a path for the fold shape
|
| + var ctx = document.getCSSCanvasContext(
|
| + '2d', 'fold_' + index, 12 * scale, 12 * scale);
|
| + ctx.beginPath();
|
| + ctx.moveTo(0, 0);
|
| + ctx.lineTo(0, 9 * scale);
|
| + ctx.quadraticCurveTo(
|
| + 0, 12 * scale,
|
| + 3 * scale, 12 * scale);
|
| + ctx.lineTo(12 * scale, 12 * scale);
|
| + ctx.closePath();
|
| +
|
| + // Create a gradient for the fold and fill it
|
| + var gradient = ctx.createLinearGradient(12 * scale, 0, 0, 12 * scale);
|
| + if (color.indexOf('#') == 0) {
|
| + var r = parseInt(color.substring(1, 3), 16);
|
| + var g = parseInt(color.substring(3, 5), 16);
|
| + var b = parseInt(color.substring(5, 7), 16);
|
| + gradient.addColorStop(0, 'rgba(' + r + ', ' + g + ', ' + b + ', 0.6)');
|
| + } else {
|
| + // assume the color is in the 'rgb(#, #, #)' format
|
| + var rgbBase = color.substring(4, color.length - 1);
|
| + gradient.addColorStop(0, 'rgba(' + rgbBase + ', 0.6)');
|
| + }
|
| + gradient.addColorStop(1, color);
|
| + ctx.fillStyle = gradient;
|
| + ctx.fill();
|
| +
|
| + // Stroke the fold
|
| + ctx.lineWidth = Math.floor(scale);
|
| + ctx.strokeStyle = color;
|
| + ctx.stroke();
|
| + ctx.strokeStyle = 'rgba(0, 0, 0, 0.1)';
|
| + ctx.stroke();
|
| +
|
| + }
|
| +
|
| + /**
|
| + * Finds the list element corresponding to the given name.
|
| + * @param {string} name The name prefix of the DOM element (<prefix>_list).
|
| + * @return {Element} The list element corresponding with the name.
|
| + */
|
| + function findList(name) {
|
| + return $(name + '_list');
|
| + }
|
| +
|
| + /**
|
| + * Gets the SectionType String from the enum SectionType.
|
| + */
|
| + function getSectionTypeString(section) {
|
| + switch (section) {
|
| + case SectionType.BOOKMARKS:
|
| + return 'bookmarks';
|
| + case SectionType.MOST_VISITED:
|
| + return 'most_visited';
|
| + case SectionType.RECENTLY_CLOSED:
|
| + return 'recently_closed';
|
| + case SectionType.SYNCED_DEVICES:
|
| + return 'synced_devices';
|
| + case SectionType.UNKNOWN:
|
| + default:
|
| + return 'unknown';
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Render the given data into the given list, and hide or show the entire
|
| + * container based on whether there are any elements. The decorator function
|
| + * is used to create the element to be inserted based on the given data
|
| + * object.
|
| + *
|
| + * @param {holder} The dom element that the generated list items will be put
|
| + * into.
|
| + * @param {SectionType} section The section that data is for.
|
| + * @param {Object} data The data to be populated.
|
| + * @param {function(Object, boolean)} decorator The function that will
|
| + * handle decorating each item in the data.
|
| + * @param {function(Object, Object)} opt_clickCallback The function that is
|
| + * called when the item is clicked.
|
| + */
|
| + function populateData(holder, section, data, decorator,
|
| + opt_clickCallback) {
|
| + // Empty other items in the list, if present.
|
| + holder.innerHTML = '';
|
| + var fragment = document.createDocumentFragment();
|
| + if (!data || data.length == 0) {
|
| + fragment.innerHTML = '';
|
| + } else {
|
| + data.forEach(function(item) {
|
| + var el = decorator(item, opt_clickCallback);
|
| + el.setAttribute(SECTION_KEY, section);
|
| + el.id = getSectionTypeString(section) + fragment.childNodes.length;
|
| + fragment.appendChild(el);
|
| + });
|
| + }
|
| + holder.appendChild(fragment);
|
| + if (holder.classList.contains(GRID_CSS_CLASS))
|
| + centerGrid(holder);
|
| + centerEmptySections(holder);
|
| + }
|
| +
|
| + /**
|
| + * Given an element containing a list of child nodes arranged in
|
| + * a grid, this will center the grid in the window based on the
|
| + * remaining space.
|
| + * @param {Element} el Container holding the grid cell items.
|
| + */
|
| + function centerGrid(el) {
|
| + var childEl = el.firstChild;
|
| + if (!childEl)
|
| + return;
|
| +
|
| + // Find the element to actually set the margins on.
|
| + var toCenter = el;
|
| + var curEl = toCenter;
|
| + while (curEl && curEl.classList) {
|
| + if (curEl.classList.contains(GRID_CENTER_CSS_CLASS)) {
|
| + toCenter = curEl;
|
| + break;
|
| + }
|
| + curEl = curEl.parentNode;
|
| + }
|
| + var setItemMargins = el.classList.contains(GRID_SET_ITEM_MARGINS);
|
| + var itemWidth = getItemWidth(childEl, setItemMargins);
|
| + var windowWidth = document.documentElement.offsetWidth;
|
| + if (itemWidth >= windowWidth) {
|
| + toCenter.style.paddingLeft = '0';
|
| + toCenter.style.paddingRight = '0';
|
| + } else {
|
| + var numColumns = el.getAttribute(GRID_COLUMNS);
|
| + if (numColumns) {
|
| + numColumns = parseInt(numColumns);
|
| + } else {
|
| + numColumns = Math.floor(windowWidth / itemWidth);
|
| + }
|
| +
|
| + if (setItemMargins) {
|
| + // In this case, try to size each item to fill as much space as
|
| + // possible.
|
| + var gutterSize =
|
| + (windowWidth - itemWidth * numColumns) / (numColumns + 1);
|
| + var childLeftMargin = Math.round(gutterSize / 2);
|
| + var childRightMargin = Math.floor(gutterSize - childLeftMargin);
|
| + var children = el.childNodes;
|
| + for (var i = 0; i < children.length; i++) {
|
| + children[i].style.marginLeft = childLeftMargin + 'px';
|
| + children[i].style.marginRight = childRightMargin + 'px';
|
| + }
|
| + itemWidth += childLeftMargin + childRightMargin;
|
| + }
|
| +
|
| + var remainder = windowWidth - itemWidth * numColumns;
|
| + var leftPadding = Math.round(remainder / 2);
|
| + var rightPadding = Math.floor(remainder - leftPadding);
|
| + toCenter.style.paddingLeft = leftPadding + 'px';
|
| + toCenter.style.paddingRight = rightPadding + 'px';
|
| +
|
| + if (toCenter.classList.contains(GRID_SET_TOP_MARGIN_CLASS)) {
|
| + var childStyle = window.getComputedStyle(childEl);
|
| + var childLeftPadding = parseInt(
|
| + childStyle.getPropertyValue('padding-left'));
|
| + toCenter.style.paddingTop =
|
| + (childLeftMargin + childLeftPadding + leftPadding) + 'px';
|
| + }
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Finds and centers all child grid elements for a given node (the grids
|
| + * do not need to be direct descendants and can reside anywhere in the node
|
| + * hierarchy).
|
| + * @param {Element} el The node containing the grid child nodes.
|
| + */
|
| + function centerChildGrids(el) {
|
| + var grids = el.getElementsByClassName(GRID_CSS_CLASS);
|
| + for (var i = 0; i < grids.length; i++)
|
| + centerGrid(grids[i]);
|
| + }
|
| +
|
| + /**
|
| + * Finds and vertically centers all 'empty' elements for a given node (the
|
| + * 'empty' elements do not need to be direct descendants and can reside
|
| + * anywhere in the node hierarchy).
|
| + * @param {Element} el The node containing the 'empty' child nodes.
|
| + */
|
| + function centerEmptySections(el) {
|
| + if (el.classList &&
|
| + el.classList.contains(CENTER_EMPTY_CONTAINER_CSS_CLASS)) {
|
| + centerEmptySection(el);
|
| + }
|
| + var empties = el.getElementsByClassName(CENTER_EMPTY_CONTAINER_CSS_CLASS);
|
| + for (var i = 0; i < empties.length; i++) {
|
| + centerEmptySection(empties[i]);
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Set the top of the given element to the top of the parent and set the
|
| + * height to (bottom of document - top).
|
| + *
|
| + * @param {Element} el Container holding the centered content.
|
| + */
|
| + function centerEmptySection(el) {
|
| + var parent = el.parentNode;
|
| + var top = parent.offsetTop;
|
| + var bottom = (
|
| + document.documentElement.offsetHeight - getButtonBarPadding());
|
| + el.style.height = (bottom - top) + 'px';
|
| + el.style.top = top + 'px';
|
| + }
|
| +
|
| + /**
|
| + * Finds the index of the panel specified by its prefix.
|
| + * @param {string} The string prefix for the panel.
|
| + * @return {number} The index of the panel.
|
| + */
|
| + function getPaneIndex(panePrefix) {
|
| + var pane = $(panePrefix + '_container');
|
| +
|
| + if (pane != null) {
|
| + var index = panes.indexOf(pane);
|
| +
|
| + if (index >= 0)
|
| + return index;
|
| + }
|
| + return 0;
|
| + }
|
| +
|
| + /**
|
| + * Finds the index of the panel specified by location hash.
|
| + * @return {number} The index of the panel.
|
| + */
|
| + function getPaneIndexFromHash() {
|
| + var paneIndex;
|
| + if (window.location.hash == '#bookmarks') {
|
| + paneIndex = getPaneIndex('bookmarks');
|
| + } else if (window.location.hash == '#bookmark_shortcut') {
|
| + paneIndex = getPaneIndex('bookmarks');
|
| + } else if (window.location.hash == '#most_visited') {
|
| + paneIndex = getPaneIndex('most_visited');
|
| + } else if (window.location.hash == '#open_tabs') {
|
| + paneIndex = getPaneIndex('open_tabs');
|
| + } else if (window.location.hash == '#incognito') {
|
| + paneIndex = getPaneIndex('incognito');
|
| + } else {
|
| + // Couldn't find a good section
|
| + paneIndex = -1;
|
| + }
|
| + return paneIndex;
|
| + }
|
| +
|
| + /**
|
| + * Selects a pane from the top level list (Most Visited, Bookmarks, etc...).
|
| + * @param {number} paneIndex The index of the pane to be selected.
|
| + * @return {boolean} Whether the selected pane has changed.
|
| + */
|
| + function scrollToPane(paneIndex) {
|
| + var pane = panes[paneIndex];
|
| +
|
| + if (pane == currentPane)
|
| + return false;
|
| +
|
| + var newHash = '#' + sectionPrefixes[paneIndex];
|
| + // If updated hash matches the current one in the URL, we need to call
|
| + // updatePaneOnHash directly as updating the hash to the same value will
|
| + // not trigger the 'hashchange' event.
|
| + if (bookmarkShortcutMode || newHash == document.location.hash)
|
| + updatePaneOnHash();
|
| + computeDynamicLayout();
|
| + promoUpdateImpressions(sectionPrefixes[paneIndex]);
|
| + return true;
|
| + }
|
| +
|
| + /**
|
| + * Updates the pane based on the current hash.
|
| + */
|
| + function updatePaneOnHash() {
|
| + var paneIndex = getPaneIndexFromHash();
|
| + var pane = panes[paneIndex];
|
| +
|
| + if (currentPane)
|
| + currentPane.classList.remove('selected');
|
| + pane.classList.add('selected');
|
| + currentPane = pane;
|
| + currentPaneIndex = paneIndex;
|
| +
|
| + document.body.scrollTop = 0;
|
| +
|
| + // TODO (dtrainor): Could potentially add logic to reset the bookmark state
|
| + // if they are moving to that pane. This logic was in there before, but
|
| + // was removed due to the fact that we have to go to this pane as part of
|
| + // the history navigation.
|
| + }
|
| +
|
| + /**
|
| + * Adds a top level section to the NTP.
|
| + * @param {string} panelPrefix The prefix of the element IDs corresponding
|
| + * to the container of the content.
|
| + * @param {boolean=} opt_canBeDefault Whether this section can be marked as
|
| + * the default starting point for subsequent instances of the NTP. The
|
| + * default value for this is true.
|
| + */
|
| + function addMainSection(panelPrefix) {
|
| + var paneEl = $(panelPrefix + '_container');
|
| + var paneIndex = panes.push(paneEl) - 1;
|
| + sectionPrefixes.push(panelPrefix);
|
| + }
|
| +
|
| + /**
|
| + * Handles the dynamic layout of the components on the new tab page. Only
|
| + * layouts that require calculation based on the screen size should go in
|
| + * this function as it will be called during all resize changes
|
| + * (orientation, keyword being displayed).
|
| + */
|
| + function computeDynamicLayout() {
|
| + // Update the scrolling titles to ensure they are not in a now invalid
|
| + // scroll position.
|
| + var titleScrollers =
|
| + document.getElementsByClassName('section-title-wrapper');
|
| + for (var i = 0, len = titleScrollers.length; i < len; i++) {
|
| + var titleEl =
|
| + titleScrollers[i].getElementsByClassName('section-title')[0];
|
| + handleTitleScroll(
|
| + titleScrollers[i],
|
| + titleEl.offsetLeft);
|
| + }
|
| +
|
| + updateMostVisitedStyle();
|
| + updateMostVisitedHeight();
|
| + }
|
| +
|
| + /**
|
| + * The centering of the 'recently closed' section is different depending on
|
| + * the orientation of the device. In landscape, it should be left-aligned
|
| + * with the 'most used' section. In portrait, it should be centered in the
|
| + * screen.
|
| + */
|
| + function updateMostVisitedStyle() {
|
| + if (isTablet()) {
|
| + updateMostVisitedStyleTablet();
|
| + } else {
|
| + updateMostVisitedStylePhone();
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Updates the style of the most visited pane for the phone.
|
| + */
|
| + function updateMostVisitedStylePhone() {
|
| + var mostVisitedList = $('most_visited_list');
|
| + var childEl = mostVisitedList.firstChild;
|
| + if (!childEl)
|
| + return;
|
| +
|
| + // 'natural' height and width of the thumbnail
|
| + var thumbHeight = 72;
|
| + var thumbWidth = 108;
|
| + var labelHeight = 20;
|
| + var labelWidth = thumbWidth + 20;
|
| + var labelLeft = (thumbWidth - labelWidth) / 2;
|
| + var itemHeight = thumbHeight + labelHeight;
|
| +
|
| + // default vertical margin between items
|
| + var itemMarginTop = 0;
|
| + var itemMarginBottom = 0;
|
| + var itemMarginLeft = 20;
|
| + var itemMarginRight = 20;
|
| +
|
| + var listHeight = 0;
|
| + // set it to the unscaled size so centerGrid works correctly
|
| + modifyCssRule('body[device="phone"] .thumbnail-cell',
|
| + 'width', thumbWidth + 'px');
|
| +
|
| + var screenHeight =
|
| + document.documentElement.offsetHeight -
|
| + getButtonBarPadding();
|
| +
|
| + if (isPortrait()) {
|
| + mostVisitedList.setAttribute(GRID_COLUMNS, '2');
|
| + listHeight = screenHeight * .85;
|
| + listHeight = listHeight >= 420 ? 420 : listHeight;
|
| + // Size for 3 rows (4 gutters)
|
| + itemMarginTop = (listHeight - (itemHeight * 3)) / 4;
|
| + } else {
|
| + mostVisitedList.setAttribute(GRID_COLUMNS, '3');
|
| + listHeight = screenHeight;
|
| +
|
| + // If the screen height is less than targetHeight, scale the size of the
|
| + // thumbnails such that the margin between the thumbnails remains
|
| + // constant.
|
| + var targetHeight = 220;
|
| + if (screenHeight < targetHeight) {
|
| + var targetRemainder = targetHeight - 2 * (thumbHeight + labelHeight);
|
| + var scale = (screenHeight - 2 * labelHeight -
|
| + targetRemainder) / (2 * thumbHeight);
|
| + // update values based on scale
|
| + thumbWidth *= scale;
|
| + thumbHeight *= scale;
|
| + labelWidth = thumbWidth + 20;
|
| + itemHeight = thumbHeight + labelHeight;
|
| + }
|
| +
|
| + // scale the vertical margin such that the items fit perfectly on the
|
| + // screen
|
| + var remainder = screenHeight - (2 * itemHeight);
|
| + var margin = (remainder / 2);
|
| + margin = margin > 24 ? 24 : margin;
|
| + itemMarginTop = Math.round(margin / 2);
|
| + itemMarginBottom = Math.round(margin - itemMarginTop);
|
| + }
|
| +
|
| + mostVisitedList.style.minHeight = listHeight + 'px';
|
| +
|
| + modifyCssRule('body[device="phone"] .thumbnail-cell',
|
| + 'height', itemHeight + 'px');
|
| + modifyCssRule('body[device="phone"] #most_visited_list .thumbnail',
|
| + 'height', thumbHeight + 'px');
|
| + modifyCssRule('body[device="phone"] #most_visited_list .thumbnail',
|
| + 'width', thumbWidth + 'px');
|
| + modifyCssRule(
|
| + 'body[device="phone"] #most_visited_list .thumbnail-container',
|
| + 'height', thumbHeight + 'px');
|
| + modifyCssRule(
|
| + 'body[device="phone"] #most_visited_list .thumbnail-container',
|
| + 'width', thumbWidth + 'px');
|
| + modifyCssRule('body[device="phone"] #most_visited_list .title',
|
| + 'width', labelWidth + 'px');
|
| + modifyCssRule('body[device="phone"] #most_visited_list .title',
|
| + 'left', labelLeft + 'px');
|
| + modifyCssRule('body[device="phone"] #most_visited_list .inner-border',
|
| + 'height', thumbHeight - 2 + 'px');
|
| + modifyCssRule('body[device="phone"] #most_visited_list .inner-border',
|
| + 'width', thumbWidth - 2 + 'px');
|
| +
|
| + modifyCssRule('body[device="phone"] .thumbnail-cell',
|
| + 'margin-left', itemMarginLeft + 'px');
|
| + modifyCssRule('body[device="phone"] .thumbnail-cell',
|
| + 'margin-right', itemMarginRight + 'px');
|
| + modifyCssRule('body[device="phone"] .thumbnail-cell',
|
| + 'margin-top', itemMarginTop + 'px');
|
| + modifyCssRule('body[device="phone"] .thumbnail-cell',
|
| + 'margin-bottom', itemMarginBottom + 'px');
|
| +
|
| + centerChildGrids($('most_visited_container'));
|
| + }
|
| +
|
| + /**
|
| + * Updates the style of the most visited pane for the tablet.
|
| + */
|
| + function updateMostVisitedStyleTablet() {
|
| + function setCenterIconGrid(el, set) {
|
| + if (set) {
|
| + el.classList.add(GRID_CENTER_CSS_CLASS);
|
| + } else {
|
| + el.classList.remove(GRID_CENTER_CSS_CLASS);
|
| + el.style.paddingLeft = '0px';
|
| + el.style.paddingRight = '0px';
|
| + }
|
| + }
|
| + var isPortrait = document.documentElement.offsetWidth <
|
| + document.documentElement.offsetHeight;
|
| + var mostVisitedContainer = $('most_visited_container');
|
| + var mostVisitedList = $('most_visited_list');
|
| + var recentlyClosedContainer = $('recently_closed_container');
|
| + var recentlyClosedList = $('recently_closed_list');
|
| +
|
| + setCenterIconGrid(mostVisitedContainer, !isPortrait);
|
| + setCenterIconGrid(mostVisitedList, isPortrait);
|
| + setCenterIconGrid(recentlyClosedContainer, isPortrait);
|
| + if (isPortrait) {
|
| + recentlyClosedList.classList.add(GRID_CSS_CLASS);
|
| + } else {
|
| + recentlyClosedList.classList.remove(GRID_CSS_CLASS);
|
| + }
|
| +
|
| + // Make the recently closed list visually left align with the most recently
|
| + // closed items in landscape mode. It will be reset by the grid centering
|
| + // in portrait mode.
|
| + if (!isPortrait)
|
| + recentlyClosedContainer.style.paddingLeft = '14px';
|
| + }
|
| +
|
| + /**
|
| + * This handles updating some of the spacing to make the 'recently closed'
|
| + * section appear at the bottom of the page.
|
| + */
|
| + function updateMostVisitedHeight() {
|
| + if (!isTablet())
|
| + return;
|
| + // subtract away height of button bar
|
| + var windowHeight = document.documentElement.offsetHeight;
|
| + var padding = parseInt(window.getComputedStyle(document.body)
|
| + .getPropertyValue('padding-bottom'));
|
| + $('most_visited_container').style.minHeight =
|
| + (windowHeight - padding) + 'px';
|
| + }
|
| +
|
| + /**
|
| + * Called by the native toolbar to open a different section. This handles
|
| + * updating the hash url which in turns makes a history entry.
|
| + *
|
| + * @param {string} section The section to switch to.
|
| + */
|
| + var openSection = function(section) {
|
| + if (!scrollToPane(getPaneIndex(section)))
|
| + return;
|
| + // Update the url so the native toolbar knows the pane has changed and
|
| + // to create a history entry.
|
| + document.location.hash = '#' + section;
|
| + }
|
| +
|
| + /////////////////////////////////////////////////////////////////////////////
|
| + // NTP Scoped Window Event Listeners.
|
| + /////////////////////////////////////////////////////////////////////////////
|
| +
|
| + /**
|
| + * Handles history on pop state changes.
|
| + */
|
| + function onPopStateHandler(event) {
|
| + if (event.state != null) {
|
| + var evtState = event.state;
|
| + // Navigate back to the previously selected panel and ensure the same
|
| + // bookmarks are loaded.
|
| + var selectedPaneIndex = evtState.selectedPaneIndex == undefined ?
|
| + 0 : evtState.selectedPaneIndex;
|
| +
|
| + scrollToPane(selectedPaneIndex);
|
| + setCurrentBookmarkFolderData(evtState.folderId);
|
| + } else {
|
| + // When loading the page, replace the default state with one that
|
| + // specifies the default panel loaded via localStorage as well as the
|
| + // default bookmark folder.
|
| + history.replaceState(
|
| + {folderId: bookmarkFolderId, selectedPaneIndex: currentPaneIndex},
|
| + null, null);
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Handles window resize events.
|
| + */
|
| + function windowResizeHandler() {
|
| + // Scroll to the current pane to refactor all the margins and offset.
|
| + scrollToPane(currentPaneIndex);
|
| + computeDynamicLayout();
|
| + // Center the padding for each of the grid views.
|
| + centerChildGrids(document);
|
| + centerEmptySections(document);
|
| + }
|
| +
|
| + /*
|
| + * We implement the context menu ourselves.
|
| + */
|
| + function contextMenuHandler(evt) {
|
| + var section = SectionType.UNKNOWN;
|
| + contextMenuUrl = null;
|
| + contextMenuItem = null;
|
| + // The node with a menu have been tagged with their section and url.
|
| + // Let's find these tags.
|
| + var node = evt.target;
|
| + while (node) {
|
| + if (section == SectionType.UNKNOWN &&
|
| + node.getAttribute &&
|
| + node.getAttribute(SECTION_KEY) != null) {
|
| + section = node.getAttribute(SECTION_KEY);
|
| + if (contextMenuUrl != null)
|
| + break;
|
| + }
|
| + if (contextMenuUrl == null) {
|
| + contextMenuUrl = node.getAttribute(CONTEXT_MENU_URL_KEY);
|
| + contextMenuItem = node.contextMenuItem;
|
| + if (section != SectionType.UNKNOWN)
|
| + break;
|
| + }
|
| + node = node.parentNode;
|
| + }
|
| +
|
| + if (section == SectionType.BOOKMARKS &&
|
| + !contextMenuItem.folder && !isIncognito) {
|
| + var menuOptions = [
|
| + [ContextMenuItemIds.BOOKMARK_OPEN_IN_NEW_TAB,
|
| + templateData.elementopeninnewtab],
|
| + [ContextMenuItemIds.BOOKMARK_OPEN_IN_INCOGNITO_TAB,
|
| + templateData.elementopeninincognitotab]];
|
| + if (contextMenuItem.editable) {
|
| + menuOptions.push(
|
| + [ContextMenuItemIds.BOOKMARK_EDIT, templateData.bookmarkedit],
|
| + [ContextMenuItemIds.BOOKMARK_DELETE, templateData.bookmarkdelete]);
|
| + }
|
| + if (contextMenuUrl.search('chrome://') == -1 &&
|
| + contextMenuUrl.search('about://') == -1) {
|
| + menuOptions.push(
|
| + [ContextMenuItemIds.BOOKMARK_SHORTCUT,
|
| + templateData.bookmarkshortcut]);
|
| + }
|
| + chrome.send('showContextMenu', menuOptions);
|
| + } else if (section == SectionType.BOOKMARKS &&
|
| + !contextMenuItem.folder &&
|
| + isIncognito) {
|
| + chrome.send('showContextMenu', [
|
| + [ContextMenuItemIds.BOOKMARK_OPEN_IN_INCOGNITO_TAB,
|
| + templateData.elementopeninincognitotab]
|
| + ]);
|
| + } else if (section == SectionType.BOOKMARKS &&
|
| + contextMenuItem.folder &&
|
| + contextMenuItem.editable &&
|
| + !isIncognito) {
|
| + chrome.send('showContextMenu', [
|
| + [ContextMenuItemIds.BOOKMARK_EDIT, templateData.editfolder],
|
| + [ContextMenuItemIds.BOOKMARK_DELETE, templateData.deletefolder],
|
| + ]);
|
| + } else if (section == SectionType.MOST_VISITED) {
|
| + chrome.send('showContextMenu', [
|
| + [ContextMenuItemIds.MOST_VISITED_OPEN_IN_NEW_TAB,
|
| + templateData.elementopeninnewtab],
|
| + [ContextMenuItemIds.MOST_VISITED_OPEN_IN_INCOGNITO_TAB,
|
| + templateData.elementopeninincognitotab],
|
| + [ContextMenuItemIds.MOST_VISITED_REMOVE, templateData.elementremove]
|
| + ]);
|
| + } else if (section == SectionType.RECENTLY_CLOSED) {
|
| + chrome.send('showContextMenu', [
|
| + [ContextMenuItemIds.RECENTLY_CLOSED_OPEN_IN_NEW_TAB,
|
| + templateData.elementopeninnewtab],
|
| + [ContextMenuItemIds.RECENTLY_CLOSED_OPEN_IN_INCOGNITO_TAB,
|
| + templateData.elementopeninincognitotab],
|
| + [ContextMenuItemIds.RECENTLY_CLOSED_REMOVE,
|
| + templateData.elementremove]
|
| + ]);
|
| + } else if (section == SectionType.FOREIGN_SESSION_HEADER) {
|
| + chrome.send('showContextMenu', [
|
| + [ContextMenuItemIds.FOREIGN_SESSIONS_REMOVE,
|
| + templateData.elementremove]
|
| + ]);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + // Return an object with all the exports
|
| + return {
|
| + bookmarks: bookmarks,
|
| + bookmarkChanged: bookmarkChanged,
|
| + setForeignSessions: setForeignSessions,
|
| + init: init,
|
| + onCustomMenuSelected: onCustomMenuSelected,
|
| + openSection: openSection,
|
| + setFaviconDominantColor: setFaviconDominantColor,
|
| + setIncognitoMode: setIncognitoMode,
|
| + setMostVisitedPages: setMostVisitedPages,
|
| + setPromotions: setPromotions,
|
| + setRecentlyClosedTabs: setRecentlyClosedTabs,
|
| + setSyncEnabled: setSyncEnabled,
|
| + snapshots: snapshots
|
| + };
|
| +});
|
| +
|
| +/////////////////////////////////////////////////////////////////////////////
|
| +//Utility Functions.
|
| +/////////////////////////////////////////////////////////////////////////////
|
| +
|
| +/**
|
| + * Alias for document.getElementById.
|
| + * @param {string} id The ID of the element to find.
|
| + * @return {HTMLElement} The found element or null if not found.
|
| + */
|
| +function $(id) {
|
| + return document.getElementById(id);
|
| +}
|
| +
|
| +/**
|
| + * @return {boolean} Whether the device is currently in portrait mode.
|
| + */
|
| +function isPortrait() {
|
| + return document.documentElement.offsetWidth <
|
| + document.documentElement.offsetHeight;
|
| +}
|
| +
|
| +/**
|
| + * Determine if the page should be formatted for tablets.
|
| + * @return {boolean} true if the device is a tablet, false otherwise.
|
| + */
|
| +function isTablet() {
|
| + return document.body.getAttribute('device') == 'tablet';
|
| +}
|
| +
|
| +/**
|
| + * Determine if the page should be formatted for phones.
|
| + * @return {boolean} true if the device is a phone, false otherwise.
|
| + */
|
| +function isPhone() {
|
| + return document.body.getAttribute('device') == 'phone';
|
| +}
|
| +
|
| +/**
|
| + * Get the page X coordinate of a touch event.
|
| + * @param {TouchEvent} evt The touch event triggered by the browser.
|
| + * @return {number} The page X coordinate of the touch event.
|
| + */
|
| +function getTouchEventX(evt) {
|
| + return (evt.touches[0] || e.changedTouches[0]).pageX;
|
| +}
|
| +
|
| +/**
|
| + * Get the page Y coordinate of a touch event.
|
| + * @param {TouchEvent} evt The touch event triggered by the browser.
|
| + * @return {number} The page Y coordinate of the touch event.
|
| + */
|
| +function getTouchEventY(evt) {
|
| + return (evt.touches[0] || e.changedTouches[0]).pageY;
|
| +}
|
| +
|
| +/**
|
| + * @param {Element} el The item to get the width of.
|
| + * @param {boolean} excludeMargin If true, exclude the width of the margin.
|
| + * @return {number} The total width of a given item.
|
| + */
|
| +function getItemWidth(el, excludeMargin) {
|
| + var elStyle = window.getComputedStyle(el);
|
| + var width = el.offsetWidth;
|
| + if (!width || width == 0) {
|
| + width = parseInt(elStyle.getPropertyValue('width'));
|
| + width +=
|
| + parseInt(elStyle.getPropertyValue('border-left-width')) +
|
| + parseInt(elStyle.getPropertyValue('border-right-width'));
|
| + width +=
|
| + parseInt(elStyle.getPropertyValue('padding-left')) +
|
| + parseInt(elStyle.getPropertyValue('padding-right'));
|
| + }
|
| + if (!excludeMargin) {
|
| + width += parseInt(elStyle.getPropertyValue('margin-left')) +
|
| + parseInt(elStyle.getPropertyValue('margin-right'));
|
| + }
|
| + return width;
|
| +}
|
| +
|
| +/**
|
| + * @return {number} The padding height of the body due to the button bar
|
| + */
|
| +function getButtonBarPadding() {
|
| + var body = document.getElementsByTagName('body')[0];
|
| + var style = window.getComputedStyle(body);
|
| + return parseInt(style.getPropertyValue('padding-bottom'));
|
| +}
|
| +
|
| +/**
|
| + * Modify a css rule
|
| + * @param {string} selector The selector for the rule (passed to findCssRule())
|
| + * @param {string} property The property to update
|
| + * @param {string} value The value to update the property to
|
| + * @return {boolean} true if the rule was updated, false otherwise.
|
| + */
|
| +function modifyCssRule(selector, property, value) {
|
| + var rule = findCssRule(selector);
|
| + if (!rule)
|
| + return false;
|
| + rule.style[property] = value;
|
| + return true;
|
| +}
|
| +
|
| +/**
|
| + * Find a particular CSS rule. The stylesheets attached to the document
|
| + * are traversed in reverse order. The rules in each stylesheet are also
|
| + * traversed in reverse order. The first rule found to match the selector
|
| + * is returned.
|
| + * @param {string} selector The selector for the rule.
|
| + * @return {Object} The rule if one was found, null otherwise
|
| + */
|
| +function findCssRule(selector) {
|
| + var styleSheets = document.styleSheets;
|
| + for (i = styleSheets.length - 1; i >= 0; i--) {
|
| + var styleSheet = styleSheets[i];
|
| + var rules = styleSheet.cssRules;
|
| + if (rules == null)
|
| + continue;
|
| + for (j = rules.length - 1; j >= 0; j--) {
|
| + if (rules[j].selectorText == selector)
|
| + return rules[j];
|
| + }
|
| + }
|
| +}
|
| +
|
| +/////////////////////////////////////////////////////////////////////////////
|
| +// NTP Entry point.
|
| +/////////////////////////////////////////////////////////////////////////////
|
| +
|
| +/*
|
| + * Handles initializing the UI when the page has finished loading.
|
| + */
|
| +window.addEventListener('DOMContentLoaded', function(evt) {
|
| + ntp.init();
|
| + $('content-area').style.display = 'block';
|
| +});
|
|
|
Chromium Code Reviews
Issue 10831317:
Upstream Android NTP resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src