The Tor Browser / file comparison

comparison: browser/modules/WindowsPreviewPerTab.jsm

browser/modules/WindowsPreviewPerTab.jsm

branch
TOR_BUG_9701
changeset 14
925c144e1f1f
equal deleted inserted replaced
-1:000000000000 0:7a9590a62bb4
1 /* vim: se cin sw=2 ts=2 et filetype=javascript :
2 * This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5 /*
6 * This module implements the front end behavior for AeroPeek. Starting in
7 * Windows Vista, the taskbar began showing live thumbnail previews of windows
8 * when the user hovered over the window icon in the taskbar. Starting with
9 * Windows 7, the taskbar allows an application to expose its tabbed interface
10 * in the taskbar by showing thumbnail previews rather than the default window
11 * preview. Additionally, when a user hovers over a thumbnail (tab or window),
12 * they are shown a live preview of the window (or tab + its containing window).
13 *
14 * In Windows 7, a title, icon, close button and optional toolbar are shown for
15 * each preview. This feature does not make use of the toolbar. For window
16 * previews, the title is the window title and the icon the window icon. For
17 * tab previews, the title is the page title and the page's favicon. In both
18 * cases, the close button "does the right thing."
19 *
20 * The primary objects behind this feature are nsITaskbarTabPreview and
21 * nsITaskbarPreviewController. Each preview has a controller. The controller
22 * responds to the user's interactions on the taskbar and provides the required
23 * data to the preview for determining the size of the tab and thumbnail. The
24 * PreviewController class implements this interface. The preview will request
25 * the controller to provide a thumbnail or preview when the user interacts with
26 * the taskbar. To reduce the overhead of drawing the tab area, the controller
27 * implementation caches the tab's contents in a <canvas> element. If no
28 * previews or thumbnails have been requested for some time, the controller will
29 * discard its cached tab contents.
30 *
31 * Screen real estate is limited so when there are too many thumbnails to fit
32 * on the screen, the taskbar stops displaying thumbnails and instead displays
33 * just the title, icon and close button in a similar fashion to previous
34 * versions of the taskbar. If there are still too many previews to fit on the
35 * screen, the taskbar resorts to a scroll up and scroll down button pair to let
36 * the user scroll through the list of tabs. Since this is undoubtedly
37 * inconvenient for users with many tabs, the AeroPeek objects turns off all of
38 * the tab previews. This tells the taskbar to revert to one preview per window.
39 * If the number of tabs falls below this magic threshold, the preview-per-tab
40 * behavior returns. There is no reliable way to determine when the scroll
41 * buttons appear on the taskbar, so a magic pref-controlled number determines
42 * when this threshold has been crossed.
43 */
44 this.EXPORTED_SYMBOLS = ["AeroPeek"];
45
46 const Cc = Components.classes;
47 const Ci = Components.interfaces;
48 const Cu = Components.utils;
49
50 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
51 Cu.import("resource://gre/modules/NetUtil.jsm");
52 Cu.import("resource://gre/modules/PrivateBrowsingUtils.jsm");
53
54 // Pref to enable/disable preview-per-tab
55 const TOGGLE_PREF_NAME = "browser.taskbar.previews.enable";
56 // Pref to determine the magic auto-disable threshold
57 const DISABLE_THRESHOLD_PREF_NAME = "browser.taskbar.previews.max";
58 // Pref to control the time in seconds that tab contents live in the cache
59 const CACHE_EXPIRATION_TIME_PREF_NAME = "browser.taskbar.previews.cachetime";
60
61 const WINTASKBAR_CONTRACTID = "@mozilla.org/windows-taskbar;1";
62
63 ////////////////////////////////////////////////////////////////////////////////
64 //// Various utility properties
65 XPCOMUtils.defineLazyServiceGetter(this, "ioSvc",
66 "@mozilla.org/network/io-service;1",
67 "nsIIOService");
68 XPCOMUtils.defineLazyServiceGetter(this, "imgTools",
69 "@mozilla.org/image/tools;1",
70 "imgITools");
71 XPCOMUtils.defineLazyServiceGetter(this, "faviconSvc",
72 "@mozilla.org/browser/favicon-service;1",
73 "nsIFaviconService");
74
75 // nsIURI -> imgIContainer
76 function _imageFromURI(uri, privateMode, callback) {
77 let channel = ioSvc.newChannelFromURI(uri);
78 try {
79 channel.QueryInterface(Ci.nsIPrivateBrowsingChannel);
80 channel.setPrivate(privateMode);
81 } catch (e) {
82 // Ignore channels which do not support nsIPrivateBrowsingChannel
83 }
84 NetUtil.asyncFetch(channel, function(inputStream, resultCode) {
85 if (!Components.isSuccessCode(resultCode))
86 return;
87 try {
88 let out_img = { value: null };
89 imgTools.decodeImageData(inputStream, channel.contentType, out_img);
90 callback(out_img.value);
91 } catch (e) {
92 // We failed, so use the default favicon (only if this wasn't the default
93 // favicon).
94 let defaultURI = faviconSvc.defaultFavicon;
95 if (!defaultURI.equals(uri))
96 _imageFromURI(defaultURI, callback);
97 }
98 });
99 }
100
101 // string? -> imgIContainer
102 function getFaviconAsImage(iconurl, privateMode, callback) {
103 if (iconurl)
104 _imageFromURI(NetUtil.newURI(iconurl), privateMode, callback);
105 else
106 _imageFromURI(faviconSvc.defaultFavicon, privateMode, callback);
107 }
108
109 // Snaps the given rectangle to be pixel-aligned at the given scale
110 function snapRectAtScale(r, scale) {
111 let x = Math.floor(r.x * scale);
112 let y = Math.floor(r.y * scale);
113 let width = Math.ceil((r.x + r.width) * scale) - x;
114 let height = Math.ceil((r.y + r.height) * scale) - y;
115
116 r.x = x / scale;
117 r.y = y / scale;
118 r.width = width / scale;
119 r.height = height / scale;
120 }
121
122 ////////////////////////////////////////////////////////////////////////////////
123 //// PreviewController
124
125 /*
126 * This class manages the behavior of the preview.
127 *
128 * To give greater performance when drawing, the dirty areas of the content
129 * window are tracked and drawn on demand into a canvas of the same size.
130 * This provides a great increase in responsiveness when drawing a preview
131 * for unchanged (or even only slightly changed) tabs.
132 *
133 * @param win
134 * The TabWindow (see below) that owns the preview that this controls
135 * @param tab
136 * The <tab> that this preview is associated with
137 */
138 function PreviewController(win, tab) {
139 this.win = win;
140 this.tab = tab;
141 this.linkedBrowser = tab.linkedBrowser;
142 this.preview = this.win.createTabPreview(this);
143
144 this.linkedBrowser.addEventListener("MozAfterPaint", this, false);
145 this.tab.addEventListener("TabAttrModified", this, false);
146
147 XPCOMUtils.defineLazyGetter(this, "canvasPreview", function () {
148 let canvas = this.win.win.document.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
149 canvas.mozOpaque = true;
150 return canvas;
151 });
152
153 XPCOMUtils.defineLazyGetter(this, "dirtyRegion",
154 function () {
155 let dirtyRegion = Cc["@mozilla.org/gfx/region;1"]
156 .createInstance(Ci.nsIScriptableRegion);
157 dirtyRegion.init();
158 return dirtyRegion;
159 });
160
161 XPCOMUtils.defineLazyGetter(this, "winutils",
162 function () {
163 let win = tab.linkedBrowser.contentWindow;
164 return win.QueryInterface(Ci.nsIInterfaceRequestor)
165 .getInterface(Ci.nsIDOMWindowUtils);
166 });
167 }
168
169 PreviewController.prototype = {
170 QueryInterface: XPCOMUtils.generateQI([Ci.nsITaskbarPreviewController,
171 Ci.nsIDOMEventListener]),
172 destroy: function () {
173 this.tab.removeEventListener("TabAttrModified", this, false);
174 this.linkedBrowser.removeEventListener("MozAfterPaint", this, false);
175
176 // Break cycles, otherwise we end up leaking the window with everything
177 // attached to it.
178 delete this.win;
179 delete this.preview;
180 delete this.dirtyRegion;
181 },
182 get wrappedJSObject() {
183 return this;
184 },
185
186 get dirtyRects() {
187 let rectstream = this.dirtyRegion.getRects();
188 if (!rectstream)
189 return [];
190 let rects = [];
191 for (let i = 0; i < rectstream.length; i+= 4) {
192 let r = {x: rectstream[i],
193 y: rectstream[i+1],
194 width: rectstream[i+2],
195 height: rectstream[i+3]};
196 rects.push(r);
197 }
198 return rects;
199 },
200
201 // Resizes the canvasPreview to 0x0, essentially freeing its memory.
202 // updateCanvasPreview() will detect the size mismatch as a resize event
203 // the next time it is called.
204 resetCanvasPreview: function () {
205 this.canvasPreview.width = 0;
206 this.canvasPreview.height = 0;
207 },
208
209 get zoom() {
210 // Note that winutils.fullZoom accounts for "quantization" of the zoom factor
211 // from nsIMarkupDocumentViewer due to conversion through appUnits.
212 // We do -not- want screenPixelsPerCSSPixel here, because that would -also-
213 // incorporate any scaling that is applied due to hi-dpi resolution options.
214 return this.winutils.fullZoom;
215 },
216
217 // Updates the controller's canvas with the parts of the <browser> that need
218 // to be redrawn.
219 updateCanvasPreview: function () {
220 let win = this.linkedBrowser.contentWindow;
221 let bx = this.linkedBrowser.boxObject;
222 // Check for resize
223 if (bx.width != this.canvasPreview.width ||
224 bx.height != this.canvasPreview.height) {
225 // Invalidate the entire area and repaint
226 this.onTabPaint({left:0, top:0, right:win.innerWidth, bottom:win.innerHeight});
227 this.canvasPreview.width = bx.width;
228 this.canvasPreview.height = bx.height;
229 }
230
231 // Draw dirty regions
232 let ctx = this.canvasPreview.getContext("2d");
233 let scale = this.zoom;
234
235 let flags = this.canvasPreviewFlags;
236 // The dirty region may include parts that are offscreen so we clip to the
237 // canvas area.
238 this.dirtyRegion.intersectRect(0, 0, win.innerWidth, win.innerHeight);
239 this.dirtyRects.forEach(function (r) {
240 // We need to snap the rectangle to be pixel aligned in the destination
241 // coordinate space. Otherwise natively themed widgets might not draw.
242 snapRectAtScale(r, scale);
243 let x = r.x;
244 let y = r.y;
245 let width = r.width;
246 let height = r.height;
247
248 ctx.save();
249 ctx.scale(scale, scale);
250 ctx.translate(x, y);
251 ctx.drawWindow(win, x, y, width, height, "white", flags);
252 ctx.restore();
253 });
254 this.dirtyRegion.setToRect(0,0,0,0);
255
256 // If we're updating the canvas, then we're in the middle of a peek so
257 // don't discard the cache of previews.
258 AeroPeek.resetCacheTimer();
259 },
260
261 onTabPaint: function (rect) {
262 let x = Math.floor(rect.left),
263 y = Math.floor(rect.top),
264 width = Math.ceil(rect.right) - x,
265 height = Math.ceil(rect.bottom) - y;
266 this.dirtyRegion.unionRect(x, y, width, height);
267 },
268
269 updateTitleAndTooltip: function () {
270 let title = this.win.tabbrowser.getWindowTitleForBrowser(this.linkedBrowser);
271 this.preview.title = title;
272 this.preview.tooltip = title;
273 },
274
275 //////////////////////////////////////////////////////////////////////////////
276 //// nsITaskbarPreviewController
277
278 get width() {
279 return this.win.width;
280 },
281
282 get height() {
283 return this.win.height;
284 },
285
286 get thumbnailAspectRatio() {
287 let boxObject = this.tab.linkedBrowser.boxObject;
288 // Avoid returning 0
289 let tabWidth = boxObject.width || 1;
290 // Avoid divide by 0
291 let tabHeight = boxObject.height || 1;
292 return tabWidth / tabHeight;
293 },
294
295 drawPreview: function (ctx) {
296 let self = this;
297 this.win.tabbrowser.previewTab(this.tab, function () self.previewTabCallback(ctx));
298
299 // We must avoid having the frame drawn around the window. See bug 520807
300 return false;
301 },
302
303 previewTabCallback: function (ctx) {
304 // This will extract the resolution-scale component of the scaling we need,
305 // which should be applied to both chrome and content;
306 // the page zoom component is applied (to content only) within updateCanvasPreview.
307 let scale = this.winutils.screenPixelsPerCSSPixel / this.winutils.fullZoom;
308 ctx.save();
309 ctx.scale(scale, scale);
310 let width = this.win.width;
311 let height = this.win.height;
312 // Draw our toplevel window
313 ctx.drawWindow(this.win.win, 0, 0, width, height, "transparent");
314
315 // XXX (jfkthame): Pending tabs don't seem to draw with the proper scaling
316 // unless we use this block of code; but doing this for "normal" (loaded) tabs
317 // results in blurry rendering on hidpi systems, so we avoid it if possible.
318 // I don't understand why pending and loaded tabs behave differently here...
319 // (see bug 857061).
320 if (this.tab.hasAttribute("pending")) {
321 // Compositor, where art thou?
322 // Draw the tab content on top of the toplevel window
323 this.updateCanvasPreview();
324
325 let boxObject = this.linkedBrowser.boxObject;
326 ctx.translate(boxObject.x, boxObject.y);
327 ctx.drawImage(this.canvasPreview, 0, 0);
328 }
329
330 ctx.restore();
331 },
332
333 drawThumbnail: function (ctx, width, height) {
334 this.updateCanvasPreview();
335
336 let scale = width/this.linkedBrowser.boxObject.width;
337 ctx.scale(scale, scale);
338 ctx.drawImage(this.canvasPreview, 0, 0);
339
340 // Don't draw a frame around the thumbnail
341 return false;
342 },
343
344 onClose: function () {
345 this.win.tabbrowser.removeTab(this.tab);
346 },
347
348 onActivate: function () {
349 this.win.tabbrowser.selectedTab = this.tab;
350
351 // Accept activation - this will restore the browser window
352 // if it's minimized
353 return true;
354 },
355
356 //// nsIDOMEventListener
357 handleEvent: function (evt) {
358 switch (evt.type) {
359 case "MozAfterPaint":
360 if (evt.originalTarget === this.linkedBrowser.contentWindow) {
361 let clientRects = evt.clientRects;
362 let length = clientRects.length;
363 for (let i = 0; i < length; i++) {
364 let r = clientRects.item(i);
365 this.onTabPaint(r);
366 }
367 }
368 let preview = this.preview;
369 if (preview.visible)
370 preview.invalidate();
371 break;
372 case "TabAttrModified":
373 this.updateTitleAndTooltip();
374 break;
375 }
376 }
377 };
378
379 XPCOMUtils.defineLazyGetter(PreviewController.prototype, "canvasPreviewFlags",
380 function () { let canvasInterface = Ci.nsIDOMCanvasRenderingContext2D;
381 return canvasInterface.DRAWWINDOW_DRAW_VIEW
382 | canvasInterface.DRAWWINDOW_DRAW_CARET
383 | canvasInterface.DRAWWINDOW_ASYNC_DECODE_IMAGES
384 | canvasInterface.DRAWWINDOW_DO_NOT_FLUSH;
385 });
386
387 ////////////////////////////////////////////////////////////////////////////////
388 //// TabWindow
389
390 /*
391 * This class monitors a browser window for changes to its tabs
392 *
393 * @param win
394 * The nsIDOMWindow browser window
395 */
396 function TabWindow(win) {
397 this.win = win;
398 this.tabbrowser = win.gBrowser;
399
400 this.previews = new Map();
401
402 for (let i = 0; i < this.tabEvents.length; i++)
403 this.tabbrowser.tabContainer.addEventListener(this.tabEvents[i], this, false);
404 this.tabbrowser.addTabsProgressListener(this);
405
406 for (let i = 0; i < this.winEvents.length; i++)
407 this.win.addEventListener(this.winEvents[i], this, false);
408
409 AeroPeek.windows.push(this);
410 let tabs = this.tabbrowser.tabs;
411 for (let i = 0; i < tabs.length; i++)
412 this.newTab(tabs[i]);
413
414 this.updateTabOrdering();
415 AeroPeek.checkPreviewCount();
416 }
417
418 TabWindow.prototype = {
419 _enabled: false,
420 tabEvents: ["TabOpen", "TabClose", "TabSelect", "TabMove"],
421 winEvents: ["tabviewshown", "tabviewhidden"],
422
423 destroy: function () {
424 this._destroying = true;
425
426 let tabs = this.tabbrowser.tabs;
427
428 this.tabbrowser.removeTabsProgressListener(this);
429 for (let i = 0; i < this.tabEvents.length; i++)
430 this.tabbrowser.tabContainer.removeEventListener(this.tabEvents[i], this, false);
431
432 for (let i = 0; i < this.winEvents.length; i++)
433 this.win.removeEventListener(this.winEvents[i], this, false);
434
435 for (let i = 0; i < tabs.length; i++)
436 this.removeTab(tabs[i]);
437
438 let idx = AeroPeek.windows.indexOf(this.win.gTaskbarTabGroup);
439 AeroPeek.windows.splice(idx, 1);
440 AeroPeek.checkPreviewCount();
441 },
442
443 get width () {
444 return this.win.innerWidth;
445 },
446 get height () {
447 return this.win.innerHeight;
448 },
449
450 // Invoked when the given tab is added to this window
451 newTab: function (tab) {
452 let controller = new PreviewController(this, tab);
453 // It's OK to add the preview now while the favicon still loads.
454 this.previews.set(tab, controller.preview);
455 AeroPeek.addPreview(controller.preview);
456 // updateTitleAndTooltip relies on having controller.preview which is lazily resolved.
457 // Now that we've updated this.previews, it will resolve successfully.
458 controller.updateTitleAndTooltip();
459 },
460
461 createTabPreview: function (controller) {
462 let docShell = this.win
463 .QueryInterface(Ci.nsIInterfaceRequestor)
464 .getInterface(Ci.nsIWebNavigation)
465 .QueryInterface(Ci.nsIDocShell);
466 let preview = AeroPeek.taskbar.createTaskbarTabPreview(docShell, controller);
467 preview.visible = AeroPeek.enabled;
468 preview.active = this.tabbrowser.selectedTab == controller.tab;
469 // Grab the default favicon
470 getFaviconAsImage(null, PrivateBrowsingUtils.isWindowPrivate(this.win), function (img) {
471 // It is possible that we've already gotten the real favicon, so make sure
472 // we have not set one before setting this default one.
473 if (!preview.icon)
474 preview.icon = img;
475 });
476
477 return preview;
478 },
479
480 // Invoked when the given tab is closed
481 removeTab: function (tab) {
482 let preview = this.previewFromTab(tab);
483 preview.active = false;
484 preview.visible = false;
485 preview.move(null);
486 preview.controller.wrappedJSObject.destroy();
487
488 this.previews.delete(tab);
489 AeroPeek.removePreview(preview);
490 },
491
492 get enabled () {
493 return this._enabled;
494 },
495
496 set enabled (enable) {
497 this._enabled = enable;
498 // Because making a tab visible requires that the tab it is next to be
499 // visible, it is far simpler to unset the 'next' tab and recreate them all
500 // at once.
501 for (let [tab, preview] of this.previews) {
502 preview.move(null);
503 preview.visible = enable;
504 }
505 this.updateTabOrdering();
506 },
507
508 previewFromTab: function (tab) {
509 return this.previews.get(tab);
510 },
511
512 updateTabOrdering: function () {
513 let previews = this.previews;
514 let tabs = this.tabbrowser.tabs;
515
516 // Previews are internally stored using a map, so we need to iterate the
517 // tabbrowser's array of tabs to retrieve previews in the same order.
518 let inorder = [previews.get(t) for (t of tabs) if (previews.has(t))];
519
520 // Since the internal taskbar array has not yet been updated we must force
521 // on it the sorting order of our local array. To do so we must walk
522 // the local array backwards, otherwise we would send move requests in the
523 // wrong order. See bug 522610 for details.
524 for (let i = inorder.length - 1; i >= 0; i--) {
525 inorder[i].move(inorder[i + 1] || null);
526 }
527 },
528
529 //// nsIDOMEventListener
530 handleEvent: function (evt) {
531 let tab = evt.originalTarget;
532 switch (evt.type) {
533 case "TabOpen":
534 this.newTab(tab);
535 this.updateTabOrdering();
536 break;
537 case "TabClose":
538 this.removeTab(tab);
539 this.updateTabOrdering();
540 break;
541 case "TabSelect":
542 this.previewFromTab(tab).active = true;
543 break;
544 case "TabMove":
545 this.updateTabOrdering();
546 break;
547 case "tabviewshown":
548 this.enabled = false;
549 break;
550 case "tabviewhidden":
551 if (!AeroPeek._prefenabled)
552 return;
553 this.enabled = true;
554 break;
555 }
556 },
557
558 //// Browser progress listener
559 onLinkIconAvailable: function (aBrowser, aIconURL) {
560 let self = this;
561 getFaviconAsImage(aIconURL, PrivateBrowsingUtils.isWindowPrivate(this.win), function (img) {
562 let index = self.tabbrowser.browsers.indexOf(aBrowser);
563 // Only add it if we've found the index. The tab could have closed!
564 if (index != -1) {
565 let tab = self.tabbrowser.tabs[index];
566 self.previews.get(tab).icon = img;
567 }
568 });
569 }
570 }
571
572 ////////////////////////////////////////////////////////////////////////////////
573 //// AeroPeek
574
575 /*
576 * This object acts as global storage and external interface for this feature.
577 * It maintains the values of the prefs.
578 */
579 this.AeroPeek = {
580 available: false,
581 // Does the pref say we're enabled?
582 _prefenabled: true,
583
584 _enabled: true,
585
586 // nsITaskbarTabPreview array
587 previews: [],
588
589 // TabWindow array
590 windows: [],
591
592 // nsIWinTaskbar service
593 taskbar: null,
594
595 // Maximum number of previews
596 maxpreviews: 20,
597
598 // Length of time in seconds that previews are cached
599 cacheLifespan: 20,
600
601 initialize: function () {
602 if (!(WINTASKBAR_CONTRACTID in Cc))
603 return;
604 this.taskbar = Cc[WINTASKBAR_CONTRACTID].getService(Ci.nsIWinTaskbar);
605 this.available = this.taskbar.available;
606 if (!this.available)
607 return;
608
609 this.prefs.addObserver(TOGGLE_PREF_NAME, this, false);
610 this.prefs.addObserver(DISABLE_THRESHOLD_PREF_NAME, this, false);
611 this.prefs.addObserver(CACHE_EXPIRATION_TIME_PREF_NAME, this, false);
612
613 this.cacheLifespan = this.prefs.getIntPref(CACHE_EXPIRATION_TIME_PREF_NAME);
614
615 this.maxpreviews = this.prefs.getIntPref(DISABLE_THRESHOLD_PREF_NAME);
616
617 this.enabled = this._prefenabled = this.prefs.getBoolPref(TOGGLE_PREF_NAME);
618 },
619
620 destroy: function destroy() {
621 this._enabled = false;
622
623 this.prefs.removeObserver(TOGGLE_PREF_NAME, this);
624 this.prefs.removeObserver(DISABLE_THRESHOLD_PREF_NAME, this);
625 this.prefs.removeObserver(CACHE_EXPIRATION_TIME_PREF_NAME, this);
626
627 if (this.cacheTimer)
628 this.cacheTimer.cancel();
629 },
630
631 get enabled() {
632 return this._enabled;
633 },
634
635 set enabled(enable) {
636 if (this._enabled == enable)
637 return;
638
639 this._enabled = enable;
640
641 this.windows.forEach(function (win) {
642 win.enabled = enable;
643 });
644 },
645
646 addPreview: function (preview) {
647 this.previews.push(preview);
648 this.checkPreviewCount();
649 },
650
651 removePreview: function (preview) {
652 let idx = this.previews.indexOf(preview);
653 this.previews.splice(idx, 1);
654 this.checkPreviewCount();
655 },
656
657 checkPreviewCount: function () {
658 if (this.previews.length > this.maxpreviews)
659 this.enabled = false;
660 else
661 this.enabled = this._prefenabled;
662 },
663
664 onOpenWindow: function (win) {
665 // This occurs when the taskbar service is not available (xp, vista)
666 if (!this.available)
667 return;
668
669 win.gTaskbarTabGroup = new TabWindow(win);
670 },
671
672 onCloseWindow: function (win) {
673 // This occurs when the taskbar service is not available (xp, vista)
674 if (!this.available)
675 return;
676
677 win.gTaskbarTabGroup.destroy();
678 delete win.gTaskbarTabGroup;
679
680 if (this.windows.length == 0)
681 this.destroy();
682 },
683
684 resetCacheTimer: function () {
685 this.cacheTimer.cancel();
686 this.cacheTimer.init(this, 1000*this.cacheLifespan, Ci.nsITimer.TYPE_ONE_SHOT);
687 },
688
689 //// nsIObserver
690 observe: function (aSubject, aTopic, aData) {
691 switch (aTopic) {
692 case "nsPref:changed":
693 if (aData == CACHE_EXPIRATION_TIME_PREF_NAME)
694 break;
695
696 if (aData == TOGGLE_PREF_NAME)
697 this._prefenabled = this.prefs.getBoolPref(TOGGLE_PREF_NAME);
698 else if (aData == DISABLE_THRESHOLD_PREF_NAME)
699 this.maxpreviews = this.prefs.getIntPref(DISABLE_THRESHOLD_PREF_NAME);
700 // Might need to enable/disable ourselves
701 this.checkPreviewCount();
702 break;
703 case "timer-callback":
704 this.previews.forEach(function (preview) {
705 let controller = preview.controller.wrappedJSObject;
706 controller.resetCanvasPreview();
707 });
708 break;
709 }
710 }
711 };
712
713 XPCOMUtils.defineLazyGetter(AeroPeek, "cacheTimer", function ()
714 Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer)
715 );
716
717 XPCOMUtils.defineLazyServiceGetter(AeroPeek, "prefs",
718 "@mozilla.org/preferences-service;1",
719 "nsIPrefBranch");
720
721 AeroPeek.initialize();

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial