The Tor Browser: comparison addon-sdk/source/lib/sdk/panel.js

comparison: addon-sdk/source/lib/sdk/panel.js

addon-sdk/source/lib/sdk/panel.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:ed6881b4ccc7
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+// The panel module currently supports only Firefox.
+// See: https://bugzilla.mozilla.org/show_bug.cgi?id=jetpack-panel-apps
+module.metadata = {
+"stability": "stable",
+"engines": {
+"Firefox": "*"
+}
+};
+const { Ci } = require("chrome");
+const { setTimeout } = require('./timers');
+const { isPrivateBrowsingSupported } = require('./self');
+const { isWindowPBSupported } = require('./private-browsing/utils');
+const { Class } = require("./core/heritage");
+const { merge } = require("./util/object");
+const { WorkerHost } = require("./content/utils");
+const { Worker } = require("./content/worker");
+const { Disposable } = require("./core/disposable");
+const { WeakReference } = require('./core/reference');
+const { contract: loaderContract } = require("./content/loader");
+const { contract } = require("./util/contract");
+const { on, off, emit, setListeners } = require("./event/core");
+const { EventTarget } = require("./event/target");
+const domPanel = require("./panel/utils");
+const { events } = require("./panel/events");
+const systemEvents = require("./system/events");
+const { filter, pipe, stripListeners } = require("./event/utils");
+const { getNodeView, getActiveView } = require("./view/core");
+const { isNil, isObject, isNumber } = require("./lang/type");
+const { getAttachEventType } = require("./content/utils");
+const { number, boolean, object } = require('./deprecated/api-utils');
+const { Style } = require("./stylesheet/style");
+const { attach, detach } = require("./content/mod");
+let isRect = ({top, right, bottom, left}) => [top, right, bottom, left].
+some(value => isNumber(value) && !isNaN(value));
+let isSDKObj = obj => obj instanceof Class;
+let rectContract = contract({
+top: number,
+right: number,
+bottom: number,
+left: number
+});
+let position = {
+is: object,
+map: v => (isNil(v) || isSDKObj(v) || !isObject(v)) ? v : rectContract(v),
+ok: v => isNil(v) || isSDKObj(v) || (isObject(v) && isRect(v)),
+msg: 'The option "position" must be a SDK object registered as anchor; ' +
+'or an object with one or more of the following keys set to numeric ' +
+'values: top, right, bottom, left.'
+}
+let displayContract = contract({
+width: number,
+height: number,
+focus: boolean,
+position: position
+});
+let panelContract = contract(merge({
+// contentStyle* / contentScript* are sharing the same validation constraints,
+// so they can be mostly reused, except for the messages.
+contentStyle: merge(Object.create(loaderContract.rules.contentScript), {
+msg: 'The `contentStyle` option must be a string or an array of strings.'
+}),
+contentStyleFile: merge(Object.create(loaderContract.rules.contentScriptFile), {
+msg: 'The `contentStyleFile` option must be a local URL or an array of URLs'
+})
+}, displayContract.rules, loaderContract.rules));
+function isDisposed(panel) !views.has(panel);
+let panels = new WeakMap();
+let models = new WeakMap();
+let views = new WeakMap();
+let workers = new WeakMap();
+let styles = new WeakMap();
+const viewFor = (panel) => views.get(panel);
+const modelFor = (panel) => models.get(panel);
+const panelFor = (view) => panels.get(view);
+const workerFor = (panel) => workers.get(panel);
+const styleFor = (panel) => styles.get(panel);
+// Utility function takes `panel` instance and makes sure it will be
+// automatically hidden as soon as other panel is shown.
+let setupAutoHide = new function() {
+let refs = new WeakMap();
+return function setupAutoHide(panel) {
+// Create system event listener that reacts to any panel showing and
+// hides given `panel` if it's not the one being shown.
+function listener({subject}) {
+// It could be that listener is not GC-ed in the same cycle as
+// panel in such case we remove listener manually.
+let view = viewFor(panel);
+if (!view) systemEvents.off("popupshowing", listener);
+else if (subject !== view) panel.hide();
+}
+// system event listener is intentionally weak this way we'll allow GC
+// to claim panel if it's no longer referenced by an add-on code. This also
+// helps minimizing cleanup required on unload.
+systemEvents.on("popupshowing", listener);
+// To make sure listener is not claimed by GC earlier than necessary we
+// associate it with `panel` it's associated with. This way it won't be
+// GC-ed earlier than `panel` itself.
+refs.set(panel, listener);
+}
+}
+const Panel = Class({
+implements: [
+// Generate accessors for the validated properties that update model on
+// set and return values from model on get.
+panelContract.properties(modelFor),
+EventTarget,
+Disposable,
+WeakReference
+],
+extends: WorkerHost(workerFor),
+setup: function setup(options) {
+let model = merge({
+defaultWidth: 320,
+defaultHeight: 240,
+focus: true,
+position: Object.freeze({}),
+}, panelContract(options));
+models.set(this, model);
+if (model.contentStyle || model.contentStyleFile) {
+styles.set(this, Style({
+uri: model.contentStyleFile,
+source: model.contentStyle
+}));
+}
+// Setup view
+let view = domPanel.make();
+panels.set(view, this);
+views.set(this, view);
+// Load panel content.
+domPanel.setURL(view, model.contentURL);
+setupAutoHide(this);
+// Setup listeners.
+setListeners(this, options);
+let worker = new Worker(stripListeners(options));
+workers.set(this, worker);
+// pipe events from worker to a panel.
+pipe(worker, this);
+},
+dispose: function dispose() {
+this.hide();
+off(this);
+workerFor(this).destroy();
+detach(styleFor(this));
+domPanel.dispose(viewFor(this));
+// Release circular reference between view and panel instance. This
+// way view will be GC-ed. And panel as well once all the other refs
+// will be removed from it.
+views.delete(this);
+},
+/* Public API: Panel.width */
+get width() modelFor(this).width,
+set width(value) this.resize(value, this.height),
+/* Public API: Panel.height */
+get height() modelFor(this).height,
+set height(value) this.resize(this.width, value),
+/* Public API: Panel.focus */
+get focus() modelFor(this).focus,
+/* Public API: Panel.position */
+get position() modelFor(this).position,
+get contentURL() modelFor(this).contentURL,
+set contentURL(value) {
+let model = modelFor(this);
+model.contentURL = panelContract({ contentURL: value }).contentURL;
+domPanel.setURL(viewFor(this), model.contentURL);
+// Detach worker so that messages send will be queued until it's
+// reatached once panel content is ready.
+workerFor(this).detach();
+},
+/* Public API: Panel.isShowing */
+get isShowing() !isDisposed(this) && domPanel.isOpen(viewFor(this)),
+/* Public API: Panel.show */
+show: function show(options={}, anchor) {
+if (options instanceof Ci.nsIDOMElement) {
+[anchor, options] = [options, null];
+}
+if (anchor instanceof Ci.nsIDOMElement) {
+console.warn(
+"Passing a DOM node to Panel.show() method is an unsupported " +
+"feature that will be soon replaced. " +
+"See: https://bugzilla.mozilla.org/show_bug.cgi?id=878877"
+);
+}
+let model = modelFor(this);
+let view = viewFor(this);
+let anchorView = getNodeView(anchor || options.position || model.position);
+options = merge({
+position: model.position,
+width: model.width,
+height: model.height,
+defaultWidth: model.defaultWidth,
+defaultHeight: model.defaultHeight,
+focus: model.focus
+}, displayContract(options));
+if (!isDisposed(this))
+domPanel.show(view, options, anchorView);
+return this;
+},
+/* Public API: Panel.hide */
+hide: function hide() {
+// Quit immediately if panel is disposed or there is no state change.
+domPanel.close(viewFor(this));
+return this;
+},
+/* Public API: Panel.resize */
+resize: function resize(width, height) {
+let model = modelFor(this);
+let view = viewFor(this);
+let change = panelContract({
+width: width || model.width || model.defaultWidth,
+height: height || model.height || model.defaultHeight
+});
+model.width = change.width
+model.height = change.height
+domPanel.resize(view, model.width, model.height);
+return this;
+}
+});
+exports.Panel = Panel;
+// Note must be defined only after value to `Panel` is assigned.
+getActiveView.define(Panel, viewFor);
+// Filter panel events to only panels that are create by this module.
+let panelEvents = filter(events, ({target}) => panelFor(target));
+// Panel events emitted after panel has being shown.
+let shows = filter(panelEvents, ({type}) => type === "popupshown");
+// Panel events emitted after panel became hidden.
+let hides = filter(panelEvents, ({type}) => type === "popuphidden");
+// Panel events emitted after content inside panel is ready. For different
+// panels ready may mean different state based on `contentScriptWhen` attribute.
+// Weather given event represents readyness is detected by `getAttachEventType`
+// helper function.
+let ready = filter(panelEvents, ({type, target}) =>
+getAttachEventType(modelFor(panelFor(target))) === type);
+// Styles should be always added as soon as possible, and doesn't makes them
+// depends on `contentScriptWhen`
+let start = filter(panelEvents, ({type}) => type === "document-element-inserted");
+// Forward panel show / hide events to panel's own event listeners.
+on(shows, "data", ({target}) => emit(panelFor(target), "show"));
+on(hides, "data", ({target}) => emit(panelFor(target), "hide"));
+on(ready, "data", ({target}) => {
+let panel = panelFor(target);
+let window = domPanel.getContentDocument(target).defaultView;
+workerFor(panel).attach(window);
+});
+on(start, "data", ({target}) => {
+let panel = panelFor(target);
+let window = domPanel.getContentDocument(target).defaultView;
+attach(styleFor(panel), window);
+});