1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/* 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';
module.metadata = {
'stability': 'unstable'
};
const { Cc, Ci } = require('chrome');
const array = require('../util/array');
const windowWatcher = Cc['@mozilla.org/embedcomp/window-watcher;1'].
getService(Ci.nsIWindowWatcher);
const appShellService = Cc['@mozilla.org/appshell/appShellService;1'].
getService(Ci.nsIAppShellService);
const observers = require('../deprecated/observer-service');
const WM = Cc['@mozilla.org/appshell/window-mediator;1'].
getService(Ci.nsIWindowMediator);
const BROWSER = 'navigator:browser',
URI_BROWSER = 'chrome://browser/content/browser.xul',
NAME = '_blank',
FEATURES = 'chrome,all,dialog=no';
function getMostRecentBrowserWindow() {
return WM.getMostRecentWindow(BROWSER);
}
exports.getMostRecentBrowserWindow = getMostRecentBrowserWindow;
/**
* Returns the ID of the window's current inner window.
*/
function getInnerId(window) {
return window.QueryInterface(Ci.nsIInterfaceRequestor).
getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID;
};
exports.getInnerId = getInnerId;
/**
* Returns the ID of the window's outer window.
*/
function getOuterId(window) {
return window.QueryInterface(Ci.nsIInterfaceRequestor).
getInterface(Ci.nsIDOMWindowUtils).outerWindowID;
};
exports.getOuterId = getOuterId;
/**
* Returns `nsIXULWindow` for the given `nsIDOMWindow`.
*/
function getXULWindow(window) {
return window.QueryInterface(Ci.nsIInterfaceRequestor).
getInterface(Ci.nsIWebNavigation).
QueryInterface(Ci.nsIDocShellTreeItem).
treeOwner.QueryInterface(Ci.nsIInterfaceRequestor).
getInterface(Ci.nsIXULWindow);
};
exports.getXULWindow = getXULWindow;
/**
* Returns `nsIBaseWindow` for the given `nsIDOMWindow`.
*/
function getBaseWindow(window) {
return window.QueryInterface(Ci.nsIInterfaceRequestor).
getInterface(Ci.nsIWebNavigation).
QueryInterface(Ci.nsIDocShell).
QueryInterface(Ci.nsIDocShellTreeItem).
treeOwner.
QueryInterface(Ci.nsIBaseWindow);
}
exports.getBaseWindow = getBaseWindow;
function getWindowDocShell(window) window.gBrowser.docShell;
exports.getWindowDocShell = getWindowDocShell;
function getWindowLoadingContext(window) {
return getWindowDocShell(window).
QueryInterface(Ci.nsILoadContext);
}
exports.getWindowLoadingContext = getWindowLoadingContext;
/**
* Removes given window from the application's window registry. Unless
* `options.close` is `false` window is automatically closed on application
* quit.
* @params {nsIDOMWindow} window
* @params {Boolean} options.close
*/
function backgroundify(window, options) {
let base = getBaseWindow(window);
base.visibility = false;
base.enabled = false;
appShellService.unregisterTopLevelWindow(getXULWindow(window));
if (!options || options.close !== false)
observers.add('quit-application-granted', window.close.bind(window));
return window;
}
exports.backgroundify = backgroundify;
/**
* Takes hash of options and serializes it to a features string that
* can be used passed to `window.open`. For more details on features string see:
* https://developer.mozilla.org/en/DOM/window.open#Position_and_size_features
*/
function serializeFeatures(options) {
return Object.keys(options).reduce(function(result, name) {
let value = options[name];
return result + ',' + name + '=' +
(value === true ? 'yes' : value === false ? 'no' : value);
}, '').substr(1);
}
/**
* Opens a top level window and returns it's `nsIDOMWindow` representation.
* @params {String} uri
* URI of the document to be loaded into window.
* @params {nsIDOMWindow} options.parent
* Used as parent for the created window.
* @params {String} options.name
* Optional name that is assigned to the window.
* @params {Object} options.features
* Map of key, values like: `{ width: 10, height: 15, chrome: true }`.
*/
function open(uri, options) {
options = options || {};
return windowWatcher.
openWindow(options.parent || null,
uri,
options.name || null,
serializeFeatures(options.features || {}),
options.args || null);
}
exports.open = open;
/**
* Opens a top level window and returns it's `nsIDOMWindow` representation.
* Same as `open` but with more features
* @param {Object} options
*
*/
function openDialog(options) {
options = options || {};
let browser = WM.getMostRecentWindow(BROWSER);
return browser.openDialog.apply(
browser,
array.flatten([
options.url || URI_BROWSER,
options.name || '_blank',
options.features || 'chrome,all,dialog=no',
options.args || null
])
);
}
exports.openDialog = openDialog;
/**
* Returns an array of all currently opened windows.
* Note that these windows may still be loading.
*/
function windows() {
let list = [];
let winEnum = windowWatcher.getWindowEnumerator();
while (winEnum.hasMoreElements()) {
let window = winEnum.getNext().QueryInterface(Ci.nsIDOMWindow);
list.push(window);
}
return list;
}
exports.windows = windows;
/**
* Check if the given window is completely loaded.
* i.e. if its "load" event has already been fired and all possible DOM content
* is done loading (the whole DOM document, images content, ...)
* @params {nsIDOMWindow} window
*/
function isDocumentLoaded(window) {
return window.document.readyState == "complete";
}
exports.isDocumentLoaded = isDocumentLoaded;
function isBrowser(window) {
return window.document.documentElement.getAttribute("windowtype") === BROWSER;
};
exports.isBrowser = isBrowser;
function getWindowTitle(window) {
return window && window.document ? window.document.title : null;
}
exports.getWindowTitle = getWindowTitle;
function isXULBrowser(window) {
return !!(isBrowser(window) && window.XULBrowserWindow);
}
exports.isXULBrowser = isXULBrowser;
function getFrames(window) {
return Array.slice(window.frames).reduce(function(frames, frame) {
return frames.concat(frame, getFrames(frame))
}, [])
}
exports.getFrames = getFrames;
|
