mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 576192 - "Use browser elements for browsing surface" []

This commit is contained in:
Chris Jones 2010-08-12 20:22:00 -07:00
Родитель 4159141418
Коммит b8531947fc
11 изменённых файлов: 91 добавлений и 1507 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
mobile/app/mobile.js
Просмотреть файл

@ -42,6 +42,7 @@ pref("browser.chromeURL", "chrome://browser/content/");
pref("browser.tabs.warnOnClose", true);
#ifdef MOZ_IPC
//pref("browser.tabs.remote", false);
pref("browser.tabs.remote", true);
#else
pref("browser.tabs.remote", false);

10
mobile/chrome/Makefile.in
Просмотреть файл

@ -52,14 +52,4 @@ ifdef ENABLE_TESTS
DIRS += tests
endif
# Preprocess some JS files!
TileManager.js: $(srcdir)/content/TileManager.js.in
ifneq (,$(filter WINNT WINCE,$(OS_ARCH)))
cl -EP -C -nologo -I$(srcdir) $< > $@
else
$(CC) -x c -C -E -P -I$(srcdir) $< > $@
endif
include $(topsrcdir)/config/rules.mk
export:: TileManager.js

258
mobile/chrome/content/BrowserView.js
Просмотреть файл

@ -227,31 +227,13 @@ BrowserView.prototype = {
}
}
this._tileManager = new TileManager(this._appendTile, this._removeTile, this, cacheSize, container);
this._visibleRectFactory = visibleRectFactory;
this._idleServiceObserver = new BrowserView.IdleServiceObserver(this);
this._idleService = Cc["@mozilla.org/widget/idleservice;1"].getService(Ci.nsIIdleService);
this._idleService.addIdleObserver(this._idleServiceObserver, kBrowserViewPrefetchBeginIdleWait);
this._idleServiceWait = kBrowserViewPrefetchBeginIdleWait;
let self = this;
messageManager.addMessageListener("Browser:MozScrolledAreaChanged", this);
messageManager.addMessageListener("Browser:MozAfterPaint", this);
messageManager.addMessageListener("Browser:PageScroll", this);
},
uninit: function uninit() {
this.setBrowser(null, null);
this._idleService.removeIdleObserver(this._idleServiceObserver, this._idleServiceWait);
},
/** When aggressive, spend more time rendering tiles. */
setAggressive: function setAggressive(aggro) {
let wait = aggro ? kBrowserViewPrefetchBeginIdleWait : kBrowserViewPrefetchBeginIdleWaitLoading;
this._idleService.removeIdleObserver(this._idleServiceObserver, this._idleServiceWait);
this._idleService.addIdleObserver(this._idleServiceObserver, wait);
this._idleServiceWait = wait;
},
getVisibleRect: function getVisibleRect() {
@ -276,6 +258,8 @@ BrowserView.prototype = {
},
setZoomLevel: function setZoomLevel(zoomLevel) {
return;
let bvs = this._browserViewportState;
if (!bvs)
return;
@ -324,6 +308,8 @@ BrowserView.prototype = {
},
beginOffscreenOperation: function beginOffscreenOperation(rect) {
return;
if (this._offscreenDepth == 0) {
let vis = this.getVisibleRect();
rect = rect || vis;
@ -342,6 +328,8 @@ BrowserView.prototype = {
},
commitOffscreenOperation: function commitOffscreenOperation() {
return;
this._offscreenDepth--;
if (this._offscreenDepth == 0) {
this.resumeRendering();
@ -349,92 +337,6 @@ BrowserView.prototype = {
}
},
beginBatchOperation: function beginBatchOperation() {
this._batchOps.push(BrowserView.Util.getNewBatchOperationState());
this.pauseRendering();
},
commitBatchOperation: function commitBatchOperation() {
let bops = this._batchOps;
if (bops.length == 0)
return;
let opState = bops.pop();
// XXX If stack is not empty, this just assigns opState variables to the next one
// on top. Why then have a stack of these booleans?
this._viewportChanged(opState.viewportSizeChanged, opState.dirtyAll);
this.resumeRendering();
},
discardBatchOperation: function discardBatchOperation() {
let bops = this._batchOps;
bops.pop();
this.resumeRendering();
},
discardAllBatchOperations: function discardAllBatchOperations() {
let bops = this._batchOps;
while (bops.length > 0)
this.discardBatchOperation();
},
/**
* Calls to this function need to be one-to-one with calls to
* resumeRendering()
*/
pauseRendering: function pauseRendering() {
this._renderMode++;
if (this._renderMode == 1 && this._browser) {
let event = document.createEvent("Events");
event.initEvent("RenderStateChanged", true, false);
event.isRendering = false;
this._browser.dispatchEvent(event);
}
},
/**
* Calls to this function need to be one-to-one with calls to
* pauseRendering()
*/
resumeRendering: function resumeRendering(renderNow) {
if (this._renderMode > 0)
this._renderMode--;
if (renderNow || this._renderMode == 0)
this.renderNow();
if (this._renderMode == 0 && this._browser) {
let event = document.createEvent("Events");
event.initEvent("RenderStateChanged", true, false);
event.isRendering = true;
this._browser.dispatchEvent(event);
}
},
/**
* Called while rendering is paused to allow update of critical area
*/
renderNow: function renderNow() {
this._tileManager.criticalRectPaint();
},
isRendering: function isRendering() {
return (this._renderMode == 0);
},
onAfterVisibleMove: function onAfterVisibleMove() {
let vs = this._browserViewportState;
let vr = this.getVisibleRect();
vs.visibleX = vr.left;
vs.visibleY = vr.top;
let cr = BrowserView.Util.visibleRectToCriticalRect(vr, vs);
this._tileManager.criticalMove(cr, this.isRendering());
},
/**
* Swap out the current browser and browser viewport state with a new pair.
*/
@ -448,6 +350,7 @@ BrowserView.prototype = {
if (oldBrowser) {
oldBrowser.setAttribute("type", "content");
oldBrowser.setAttribute("style", "display: none;");
oldBrowser.messageManager.sendAsyncMessage("Browser:Blur", {});
}
@ -456,14 +359,11 @@ BrowserView.prototype = {
if (browser) {
browser.setAttribute("type", "content-primary");
browser.setAttribute("style", "display: block;");
browser.messageManager.sendAsyncMessage("Browser:Focus", {});
this.beginBatchOperation();
if (browserChanged)
this._viewportChanged(true, true);
this.commitBatchOperation();
}
},
@ -473,9 +373,6 @@ BrowserView.prototype = {
receiveMessage: function receiveMessage(aMessage) {
switch (aMessage.name) {
case "Browser:MozAfterPaint":
this.updateDirtyTiles(aMessage);
break;
case "Browser:PageScroll":
this.updatePageScroll(aMessage);
break;
@ -485,39 +382,10 @@ BrowserView.prototype = {
}
},
updateDirtyTiles: function updateDirtyTiles(aMessage) {
let browser = aMessage.target;
if (browser != this._browser)
return;
let rects = aMessage.json.rects;
let tm = this._tileManager;
let vs = this._browserViewportState;
let dirtyRects = [];
// loop backwards to avoid xpconnect penalty for .length
for (let i = rects.length - 1; i >= 0; --i) {
let r = Rect.fromRect(rects[i]);
r = this.browserToViewportRect(r);
r.expandToIntegers();
r.restrictTo(vs.viewportRect);
if (!r.isEmpty())
dirtyRects.push(r);
}
tm.dirtyRects(dirtyRects, this.isRendering(), true);
},
/** If browser scrolls, pan content to new scroll area. */
updatePageScroll: function updatePageScroll(aMessage) {
if (aMessage.target != this._browser || this._ignorePageScroll)
return;
// XXX shouldn't really make calls to Browser
let json = aMessage.json;
Browser.scrollContentToBrowser(json.scrollX, json.scrollY);
},
_ignorePageScroll: false,
@ -549,8 +417,7 @@ BrowserView.prototype = {
if (vis.right > viewport.right || vis.bottom > viewport.bottom) {
// Content has shrunk outside of the visible rectangle.
// XXX for some reason scroller doesn't know it is outside its bounds
Browser.contentScrollboxScroller.scrollBy(0, 0);
this.onAfterVisibleMove();
// Browser.contentScrollboxScroller.scrollBy(0, 0);
}
}
},
@ -675,6 +542,8 @@ BrowserView.prototype = {
* This defaults to the visible rect rooted at the x,y of the critical rect.
*/
renderToCanvas: function renderToCanvas(destCanvas, destWidth, destHeight, srcRect) {
return;
let bvs = this._browserViewportState;
if (!bvs) {
throw "Browser viewport state null in call to renderToCanvas (probably no browser set on BrowserView).";
@ -725,43 +594,11 @@ BrowserView.prototype = {
ctx.scale(f, f);
},
forceContainerResize: function forceContainerResize() {
let bvs = this._browserViewportState;
if (bvs)
BrowserView.Util.resizeContainerToViewport(this._container, bvs.viewportRect);
},
/**
* Force any pending viewport changes to occur. Batch operations will still be on the
* stack so commitBatchOperation is still necessary afterwards.
*/
forceViewportChange: function forceViewportChange() {
let bops = this._batchOps;
if (bops.length > 0) {
let opState = bops[bops.length - 1];
this._applyViewportChanges(opState.viewportSizeChanged, opState.dirtyAll);
opState.viewportSizeChanged = false;
opState.dirtyAll = false;
}
},
// -----------------------------------------------------------
// Private instance methods
//
_viewportChanged: function _viewportChanged(viewportSizeChanged, dirtyAll) {
let bops = this._batchOps;
if (bops.length > 0) {
let opState = bops[bops.length - 1];
if (viewportSizeChanged)
opState.viewportSizeChanged = viewportSizeChanged;
if (dirtyAll)
opState.dirtyAll = dirtyAll;
return;
}
this._applyViewportChanges(viewportSizeChanged, dirtyAll);
},
@ -769,44 +606,8 @@ BrowserView.prototype = {
let bvs = this._browserViewportState;
if (bvs) {
BrowserView.Util.resizeContainerToViewport(this._container, bvs.viewportRect);
let vr = this.getVisibleRect();
this._tileManager.viewportChangeHandler(bvs.viewportRect,
BrowserView.Util.visibleRectToCriticalRect(vr, bvs),
viewportSizeChanged,
dirtyAll);
let rects = vr.subtract(bvs.viewportRect);
this._tileManager.clearRects(rects);
}
},
_appendTile: function _appendTile(tile) {
let canvas = tile.getContentImage();
//canvas.style.position = "absolute";
//canvas.style.left = tile.x + "px";
//canvas.style.top = tile.y + "px";
// XXX The above causes a trace abort, and this function is called back in the tight
// render-heavy loop in TileManager, so even though what we do below isn't so proper
// and takes longer on the Platform/C++ emd, it's better than causing a trace abort
// in our tight loop.
//
// But this also overwrites some style already set on the canvas in Tile constructor.
// Hack fail...
//
canvas.setAttribute("style", "display: none; position: absolute; left: " + tile.boundRect.left + "px; " + "top: " + tile.boundRect.top + "px;");
this._container.appendChild(canvas);
},
_removeTile: function _removeTile(tile) {
let canvas = tile.getContentImage();
this._container.removeChild(canvas);
}
};
@ -845,40 +646,3 @@ BrowserView.BrowserViewportState.prototype = {
}
};
/**
* nsIObserver that implements a callback for the nsIIdleService, which starts
* and stops the BrowserView's TileManager's prefetch crawl according to user
* idleness.
*/
BrowserView.IdleServiceObserver = function IdleServiceObserver(browserView) {
this._browserView = browserView;
this._idle = false;
this._paused = false;
};
BrowserView.IdleServiceObserver.prototype = {
/** No matter what idle is, make sure prefetching is not active. */
pause: function pause() {
this._paused = true;
this._updateTileManager();
},
/** Prefetch tiles in idle mode. */
resume: function resume() {
this._paused = false;
this._updateTileManager();
},
/** Idle event handler. */
observe: function observe(aSubject, aTopic, aUserIdleTime) {
this._idle = (aTopic == "idle") ? true : false;
this._updateTileManager();
},
_updateTileManager: function _updateTileManager() {
let bv = this._browserView;
bv._tileManager.setPrefetch(this._idle && !this._paused);
}
};

62
mobile/chrome/content/InputHandler.js
Просмотреть файл

@ -233,10 +233,6 @@ InputHandler.prototype = {
if (this._ignoreEvents)
return;
/* ignore all events that belong to other windows or documents (e.g. content events) */
if (aEvent.view != window)
return;
if (this._suppressNextClick && aEvent.type == "click") {
this._suppressNextClick = false;
aEvent.stopPropagation();
@ -350,6 +346,16 @@ MouseModule.prototype = {
if (aEvent.button !== 0 && aEvent.type != "contextmenu")
return;
try {
if (aEvent.view != window) {
// XXX we'd really like to do this to stop dragging code, but at least in
// non-e10s this is a problem. Since we catch the simulated mouseup and
// mousedown events, we eat up the ones we just generated.
// evt.stopPropagation();
// evt.preventDefault();
}
} catch (e) {};
switch (aEvent.type) {
case "mousedown":
this._onMouseDown(aEvent);
@ -426,29 +432,38 @@ MouseModule.prototype = {
// walk up the DOM tree in search of nearest scrollable ancestor. nulls are
// returned if none found.
let target = (aEvent.view == window) ? aEvent.target : getBrowser();
let [targetScrollbox, targetScrollInterface]
= this.getScrollboxFromElement(aEvent.target);
= this.getScrollboxFromElement(target);
let targetDragger = targetScrollbox ? targetScrollbox.customDragger : null;
if (!targetDragger && targetScrollInterface)
targetDragger = this._defaultDragger;
// stop kinetic panning if targetScrollbox has changed
let oldInterface = this._targetScrollInterface;
if (this._kinetic.isActive() && targetScrollInterface != oldInterface)
let oldDragger = this._dragger;
if (this._kinetic.isActive() && targetDragger != oldDragger)
this._kinetic.end();
let targetClicker = this.getClickerFromElement(aEvent.target);
// If the target is not part of the chrome UI, assume it comes from the current browser element.
let targetClicker = this.getClickerFromElement(target);
this._targetScrollInterface = targetScrollInterface;
this._dragger = (targetScrollInterface) ? (targetScrollbox.customDragger || this._defaultDragger)
: null;
this._dragger = targetDragger;
this._clicker = (targetClicker) ? targetClicker.customClicker : null;
if (this._clicker)
this._clicker.mouseDown(aEvent.clientX, aEvent.clientY);
if (targetScrollInterface && this._dragger.isDraggable(targetScrollbox, targetScrollInterface))
let draggable = this._dragger ? this._dragger.isDraggable(targetScrollbox, targetScrollInterface) : {};
if (this._dragger && (draggable.xDraggable || draggable.yDraggable))
this._doDragStart(aEvent);
else
this._dragger = null;
if (this._targetIsContent(aEvent)) {
this._recordEvent(aEvent);
aEvent.stopPropagation();
aEvent.preventDefault();
}
else {
if (this._clickTimeout) {
@ -457,12 +472,9 @@ MouseModule.prototype = {
this._cleanClickBuffer();
}
if (targetScrollInterface) {
if (this._dragger) {
// do not allow axis locking if panning is only possible in one direction
let cX = {}, cY = {};
targetScrollInterface.getScrolledSize(cX, cY);
let rect = targetScrollbox.getBoundingClientRect();
dragData.locked = ((cX.value > rect.width) != (cY.value > rect.height));
dragData.locked = !draggable.xDraggable || !draggable.yDraggable;
}
}
},
@ -486,6 +498,8 @@ MouseModule.prototype = {
}
if (this._targetIsContent(aEvent)) {
aEvent.stopPropagation();
aEvent.preventDefault();
// User possibly clicked on something in content
this._recordEvent(aEvent);
let commitToClicker = this._clicker && dragData.isClick() && (this._downUpEvents.length > 1);
@ -547,16 +561,7 @@ MouseModule.prototype = {
* Check if the event concern the browser content
*/
_targetIsContent: function _targetIsContent(aEvent) {
let target = aEvent.target;
while (target) {
if (target === window)
return false;
if (target === this._browserViewContainer)
return true;
target = target.parentNode;
}
return false;
return aEvent.view !== window;
},
/**
@ -704,7 +709,7 @@ MouseModule.prototype = {
let sX = {}, sY = {};
scroller.getScrolledSize(sX, sY);
let rect = target.getBoundingClientRect();
return sX.value > rect.width || sY.value > rect.height;
return { xDraggable: sX.value > rect.width, yDraggable: sY.value > rect.height };
},
dragStart: function dragStart(cx, cy, target, scroller) {},
@ -769,6 +774,9 @@ MouseModule.prototype = {
scrollbox._cachedSBO = qinterface = qi;
break;
}
} else if (elem.customDragger) {
scrollbox = elem;
break;
}
} catch (e) { /* we aren't here to deal with your exceptions, we'll just keep
traversing until we find something more well-behaved, as we

1044
mobile/chrome/content/TileManager.js.in
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

1
mobile/chrome/content/bindings.xml
Просмотреть файл

@ -1125,7 +1125,6 @@
// XXX this should probably be removed with layers
Browser.forceChromeReflow();
Browser.contentScrollboxScroller.scrollBy(0, 0);
Browser._browserView.onAfterVisibleMove();
]]></body>
</method>
</implementation>

1
mobile/chrome/content/browser-ui.js
Просмотреть файл

@ -1717,7 +1717,6 @@ var FormHelperUI = {
let [deltaX, deltaY] = this._getOffsetForCaret(caretRect, zoomRect);
if (deltaX != 0 || deltaY != 0) {
Browser.contentScrollboxScroller.scrollBy(deltaX, deltaY);
bv.onAfterVisibleMove();
}
Browser.animatedZoomTo(zoomRect);

198
mobile/chrome/content/browser.js
Просмотреть файл

@ -261,7 +261,6 @@ function onDebugKeyPress(ev) {
dump("Forced a GC\n");
break;
case r:
bv.onAfterVisibleMove();
//bv.setVisibleRect(Browser.getVisibleRect());
case d:
@ -343,8 +342,6 @@ var Browser = {
_selectedTab : null,
windowUtils: window.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsIDOMWindowUtils),
contentScrollbox: null,
contentScrollboxScroller: null,
controlsScrollbox: null,
controlsScrollboxScroller: null,
pageScrollbox: null,
@ -367,23 +364,41 @@ var Browser = {
if (needOverride == "new profile")
this.initNewProfile();
let container = document.getElementById("tile-container");
let container = document.getElementById("browsers");
let bv = this._browserView = new BrowserView(container, Browser.getVisibleRect);
/* handles dispatching clicks on tiles into clicks in content or zooms */
container.customClicker = new ContentCustomClicker(bv);
container.customKeySender = new ContentCustomKeySender(bv);
container.customDragger = new Browser.MainDragger(bv);
/* scrolling box that contains tiles */
let contentScrollbox = this.contentScrollbox = document.getElementById("content-scrollbox");
this.contentScrollboxScroller = contentScrollbox.boxObject.QueryInterface(Ci.nsIScrollBoxObject);
contentScrollbox.customDragger = new Browser.MainDragger(bv);
this.contentScrollbox = container;
this.contentScrollboxScroller = {
scrollBy: function(x, y) {
// FIXME ROMAXA
if (getBrowser().contentWindow) {
getBrowser().contentWindow.scrollBy(x, y);
}
},
scrollTo: function(x, y) {
// FIXME ROMAXA
if (getBrowser().contentWindow) {
getBrowser().contentWindow.scrollTo(x, y);
}
},
getPosition: function(scrollX, scrollY) {
let cwu = Util.getWindowUtils(getBrowser().contentWindow);
cwu.getScrollXY(false, scrollX, scrollY);
}
};
/* horizontally scrolling box that holds the sidebars as well as the contentScrollbox */
let controlsScrollbox = this.controlsScrollbox = document.getElementById("controls-scrollbox");
this.controlsScrollboxScroller = controlsScrollbox.boxObject.QueryInterface(Ci.nsIScrollBoxObject);
controlsScrollbox.customDragger = {
isDraggable: function isDraggable(target, content) { return false; },
isDraggable: function isDraggable(target, content) { return {}; },
dragStart: function dragStart(cx, cy, target, scroller) {},
dragStop: function dragStop(dx, dy, scroller) { return false; },
dragMove: function dragMove(dx, dy, scroller) { return false; }
@ -394,9 +409,6 @@ var Browser = {
this.pageScrollboxScroller = pageScrollbox.boxObject.QueryInterface(Ci.nsIScrollBoxObject);
pageScrollbox.customDragger = controlsScrollbox.customDragger;
// during startup a lot of viewportHandler calls happen due to content and window resizes
bv.beginBatchOperation();
let stylesheet = document.styleSheets[0];
for each (let style in ["viewport-width", "viewport-height", "window-width", "window-height", "toolbar-height"]) {
let index = stylesheet.insertRule("." + style + " {}", stylesheet.cssRules.length);
@ -414,8 +426,6 @@ var Browser = {
if (maximize && w > screen.width)
return;
bv.beginBatchOperation();
let toolbarHeight = Math.round(document.getElementById("toolbar-main").getBoundingClientRect().height);
let scaledDefaultH = (kDefaultBrowserWidth * (h / w));
let scaledScreenH = (window.screen.width * (h / w));
@ -443,13 +453,10 @@ var Browser = {
if (bv.isDefaultZoom())
// XXX this should really only happen on browser startup, not every resize
Browser.hideSidebars();
bv.onAfterVisibleMove();
for (let i = Browser.tabs.length - 1; i >= 0; i--)
Browser.tabs[i].updateViewportSize();
bv.commitBatchOperation();
let curEl = document.activeElement;
if (curEl && curEl.scrollIntoView)
curEl.scrollIntoView(false);
@ -470,7 +477,6 @@ var Browser = {
function notificationHandler() {
// Let the view know that the layout might have changed
Browser.forceChromeReflow();
bv.onAfterVisibleMove();
}
let notifications = document.getElementById("notifications");
notifications.addEventListener("AlertActive", notificationHandler, false);
@ -548,8 +554,6 @@ var Browser = {
button.hidden = false;
}
bv.commitBatchOperation();
// If some add-ons were disabled during during an application update, alert user
if (Services.prefs.prefHasUserValue("extensions.disabledAddons")) {
let addons = Services.prefs.getCharPref("extensions.disabledAddons").split(",");
@ -591,7 +595,7 @@ var Browser = {
let shouldPrompt = Services.prefs.getBoolPref("browser.tabs.warnOnClose");
if (shouldPrompt) {
let prompt = Services.prompt;
// Default to true: if it were false, we wouldn't get this far
let warnOnClose = { value: true };
@ -635,7 +639,7 @@ var Browser = {
Services.obs.notifyObservers(closingCanceled, "browser-lastwindow-close-requested", null);
if (closingCanceled.data)
return false;
Services.obs.notifyObservers(null, "browser-lastwindow-close-granted", null);
return true;
},
@ -673,41 +677,19 @@ var Browser = {
scrollContentToTop: function scrollContentToTop() {
this.contentScrollboxScroller.scrollTo(0, 0);
this.pageScrollboxScroller.scrollTo(0, 0);
this._browserView.onAfterVisibleMove();
},
/** Let current browser's scrollbox know about where content has been panned. */
scrollBrowserToContent: function scrollBrowserToContent() {
let browser = this.selectedBrowser;
if (browser) {
let scroll = Browser.getScrollboxPosition(Browser.contentScrollboxScroller);
browser.messageManager.sendAsyncMessage("Content:ScrollTo", { x: scroll.x, y: scroll.y });
}
},
/** Update viewport to location of browser's scrollbars. */
scrollContentToBrowser: function scrollContentToBrowser(aScrollX, aScrollY) {
if (aScrollY != 0)
Browser.hideTitlebar();
let zoomLevel = this._browserView.getZoomLevel();
Browser.contentScrollboxScroller.scrollTo(aScrollX*zoomLevel, aScrollY*zoomLevel);
this._browserView.onAfterVisibleMove();
},
hideSidebars: function scrollSidebarsOffscreen() {
let container = this.contentScrollbox;
let container = document.getElementById("browsers");
let rect = container.getBoundingClientRect();
this.controlsScrollboxScroller.scrollBy(Math.round(rect.left), 0);
this._browserView.onAfterVisibleMove();
},
hideTitlebar: function hideTitlebar() {
let container = this.contentScrollbox;
let container = document.getElementById("browsers");
let rect = container.getBoundingClientRect();
this.pageScrollboxScroller.scrollBy(0, Math.round(rect.top));
this.tryUnfloatToolbar();
this._browserView.onAfterVisibleMove();
},
/**
@ -839,7 +821,6 @@ var Browser = {
return;
if (this._selectedTab) {
this._selectedTab.contentScrollOffset = this.getScrollboxPosition(this.contentScrollboxScroller);
this._selectedTab.pageScrollOffset = this.getScrollboxPosition(this.pageScrollboxScroller);
// Make sure we leave the toolbar in an unlocked state
@ -855,10 +836,7 @@ var Browser = {
if (this._selectedTab.isLoading())
BrowserUI.lockToolbar();
bv.beginBatchOperation();
bv.setBrowser(tab.browser, tab.browserViewportState);
bv.forceContainerResize();
bv.updateDefaultZoom();
document.getElementById("tabs").selectedTab = tab.chromeTab;
@ -876,19 +854,10 @@ var Browser = {
tab.lastSelected = Date.now();
// XXX incorrect behavior if page was scrolled by tab in the background.
if (tab.contentScrollOffset) {
let { x: scrollX, y: scrollY } = tab.contentScrollOffset;
Browser.contentScrollboxScroller.scrollTo(scrollX, scrollY);
}
if (tab.pageScrollOffset) {
let { x: pageScrollX, y: pageScrollY } = tab.pageScrollOffset;
Browser.pageScrollboxScroller.scrollTo(pageScrollX, pageScrollY);
}
bv.setAggressive(!tab._loading);
bv.commitBatchOperation();
},
supportsCommand: function(cmd) {
@ -1176,27 +1145,14 @@ var Browser = {
// Hardware scrolling happens immediately when scrollTo is called. Hide to prevent artifacts.
bv.beginOffscreenOperation(rect);
// We must scroll to the correct area before TileManager is informed of the change
// so that only one render is done. Ensures setZoomLevel puts it off.
bv.beginBatchOperation();
// Critical rect changes when controls are hidden. Must hide before tilemanager viewport.
this.hideSidebars();
this.hideTitlebar();
bv.setZoomLevel(zoomLevel);
// Ensure container is big enough for scroll values.
bv.forceContainerResize();
this.forceChromeReflow();
this.contentScrollboxScroller.scrollTo(scrollX, scrollY);
bv.onAfterVisibleMove();
// Inform tile manager, which happens to render new tiles too. Must call in case a batch
// operation was in progress before zoom.
bv.forceViewportChange();
bv.commitBatchOperation();
bv.commitOffscreenOperation();
},
@ -1231,7 +1187,7 @@ var Browser = {
* Transform x and y from client coordinates to BrowserView coordinates.
*/
clientToBrowserView: function clientToBrowserView(x, y) {
let container = document.getElementById("tile-container");
let container = document.getElementById("browsers");
let containerBCR = container.getBoundingClientRect();
let x0 = Math.round(containerBCR.left);
@ -1243,7 +1199,7 @@ var Browser = {
},
browserViewToClient: function browserViewToClient(x, y) {
let container = document.getElementById("tile-container");
let container = document.getElementById("browsers");
let containerBCR = container.getBoundingClientRect();
let x0 = Math.round(-containerBCR.left);
@ -1255,7 +1211,7 @@ var Browser = {
},
browserViewToClientRect: function browserViewToClientRect(rect) {
let container = document.getElementById("tile-container");
let container = document.getElementById("browsers");
let containerBCR = container.getBoundingClientRect();
return rect.clone().translate(Math.round(containerBCR.left), Math.round(containerBCR.top));
},
@ -1274,7 +1230,7 @@ var Browser = {
*/
getVisibleRect: function getVisibleRect() {
let stack = document.getElementById("tile-stack");
let container = document.getElementById("tile-container");
let container = document.getElementById("browsers");
let containerBCR = container.getBoundingClientRect();
let x = Math.round(-containerBCR.left);
@ -1295,6 +1251,8 @@ var Browser = {
getScrollboxPosition: function getScrollboxPosition(scroller) {
let x = {};
let y = {};
// FIXME ROMAXA
return new Point(0, 0);
scroller.getPosition(x, y);
return new Point(x.value, y.value);
},
@ -1343,11 +1301,11 @@ Browser.MainDragger = function MainDragger(browserView) {
};
Browser.MainDragger.prototype = {
isDraggable: function isDraggable(target, scroller) { return true; },
isDraggable: function isDraggable(target, scroller) {
return { xDraggable: true, yDraggable: true };
},
dragStart: function dragStart(clientX, clientY, target, scroller) {
this._nextRender = Date.now() + 500;
this._dragMoved = false;
},
dragStop: function dragStop(dx, dy, scroller) {
@ -1355,9 +1313,6 @@ Browser.MainDragger.prototype = {
this.dragMove(Browser.snapSidebars(), 0, scroller);
Browser.tryUnfloatToolbar();
if (this._dragMoved)
this.bv.resumeRendering();
},
dragMove: function dragMove(dx, dy, scroller) {
@ -1365,7 +1320,6 @@ Browser.MainDragger.prototype = {
if (!this._dragMoved) {
this._dragMoved = true;
this.bv.pauseRendering();
}
// First calculate any panning to take sidebars out of view
@ -1381,13 +1335,6 @@ Browser.MainDragger.prototype = {
this._panScroller(Browser.controlsScrollboxScroller, doffset);
this._panScroller(Browser.pageScrollboxScroller, doffset);
this.bv.onAfterVisibleMove();
if (Date.now() >= this._nextRender) {
this.bv.renderNow();
this._nextRender = Date.now() + 500;
}
return !doffset.equals(dx, dy);
},
@ -2376,25 +2323,9 @@ ProgressController.prototype = {
},
_documentStop: function _documentStop() {
if (this._tab == Browser.selectedTab) {
// XXX Sometimes MozScrolledAreaChanged has not occurred, so the scroll pane will not
// be resized yet. We are assuming this event is on the queue, so scroll the pane
// "soon."
Util.executeSoon(function() {
let scroll = Browser.getScrollboxPosition(Browser.contentScrollboxScroller);
if (scroll.isZero())
Browser.scrollContentToBrowser(0, 0);
});
}
else {
// XXX: We don't know the current scroll position of the content, so assume
// it's at the top. This will be fixed by Layers
this._tab.contentScrollOffset = new Point(0, 0);
// Make sure the URLbar is in view. If this were the selected tab,
// onLocationChange would scroll to top.
this._tab.pageScrollOffset = new Point(0, 0);
}
}
};
@ -2587,27 +2518,11 @@ Tab.prototype = {
if (this._loading) throw "Already Loading!";
this._loading = true;
let bv = Browser._browserView;
if (this == Browser.selectedTab) {
bv.setAggressive(false);
// Sync up browser so previous and forward scroll positions are set. This is a good time to do
// this because the resulting invalidation is irrelevant.
bv.ignorePageScroll(true);
Browser.scrollBrowserToContent();
}
},
endLoading: function endLoading() {
if (!this._loading) throw "Not Loading!";
this._loading = false;
if (this == Browser.selectedTab) {
let bv = Browser._browserView;
bv.ignorePageScroll(false);
bv.setAggressive(true);
}
},
isLoading: function isLoading() {
@ -2636,13 +2551,12 @@ Tab.prototype = {
let browser = this._browser = document.createElement("browser");
this._chromeTab.linkedBrowser = browser;
browser.setAttribute("style", "overflow: -moz-hidden-unscrollable; visibility: hidden;");
browser.setAttribute("type", "content");
let useRemote = Services.prefs.getBoolPref("browser.tabs.remote");
let useLocal = Util.isLocalScheme(aURI);
browser.setAttribute("remote", (!useLocal && useRemote) ? "true" : "false");
// Append the browser to the document, which should start the page load
document.getElementById("browsers").appendChild(browser);
@ -2727,39 +2641,3 @@ var ImagePreloader = {
}
}
};
// Helper used to hide IPC / non-IPC differences for rendering to a canvas
function rendererFactory(aBrowser, aCanvas) {
let wrapper = {};
if (aBrowser.contentWindow) {
let ctx = aCanvas.getContext("2d");
let draw = function(browser, aLeft, aTop, aWidth, aHeight, aColor, aFlags) {
ctx.drawWindow(browser.contentWindow, aLeft, aTop, aWidth, aHeight, aColor, aFlags);
let e = document.createEvent("HTMLEvents");
e.initEvent("MozAsyncCanvasRender", true, true);
aCanvas.dispatchEvent(e);
};
wrapper.checkBrowser = function(browser) {
return browser.contentWindow;
};
wrapper.drawContent = function(callback) {
callback(ctx, draw);
};
}
else {
let ctx = aCanvas.MozGetIPCContext("2d");
let draw = function(browser, aLeft, aTop, aWidth, aHeight, aColor, aFlags) {
ctx.asyncDrawXULElement(browser, aLeft, aTop, aWidth, aHeight, aColor, aFlags);
};
wrapper.checkBrowser = function(browser) {
return !browser.contentWindow;
};
wrapper.drawContent = function(callback) {
callback(ctx, draw);
};
}
return wrapper;
}

12
mobile/chrome/content/browser.xul
Просмотреть файл

@ -260,13 +260,10 @@
<!-- Content viewport -->
<vbox class="window-width window-height">
<stack id="tile-stack" class="window-width" flex="1">
<scrollbox id="content-scrollbox" style="overflow: hidden;" class="window-width" flex="1">
<!-- Content viewport -->
<html:div id="tile-container" style="overflow: hidden;" tabindex="-1">
<html:canvas id="content-overlay" style="display: none; position: absolute; z-index: 1000; left: 0; top: 0;">
</html:canvas>
</html:div>
</scrollbox>
<!-- Content viewport -->
<html:div id="browsers" style="overflow: hidden;"/>
<html:canvas id="content-overlay" style="display: none; position: absolute; z-index: 1000; left: 0; top: 0;">
</html:canvas>
<html:canvas id="view-buffer" style="display: none;" moz-opaque="true">
</html:canvas>
</stack>
@ -562,7 +559,6 @@
<box>
<html:div style="position: relative; overflow: -moz-hidden-unscrollable; max-width: 0px; max-height: 0px; visibility: hidden;">
<html:div id="browsers" style="position: absolute;"/>
</html:div>
</box>

10
mobile/chrome/content/tabs.xml
Просмотреть файл

@ -44,18 +44,12 @@
<parameter name="height"/>
<body>
<![CDATA[
return;
const tabWidth = 106;
const tabHeight = 64;
let canvas = document.getAnonymousElementByAttribute(this, "anonid", "canvas");
let renderer = rendererFactory(browser, canvas)
renderer.drawContent(function(ctx, callback) {
ctx.clearRect(0, 0, tabWidth, tabHeight);
ctx.save();
ctx.scale(tabWidth / width, tabHeight / height);
callback(browser, 0, 0, width, height, "white");
ctx.restore();
});
dump("Not implemented updateThumbnail\n");
]]>
</body>
</method>

1
mobile/chrome/jar.mn
Просмотреть файл

@ -42,7 +42,6 @@ chrome.jar:
% content branding %content/branding/
content/sanitize.js (content/sanitize.js)
* content/BrowserView.js (content/BrowserView.js)
content/TileManager.js (TileManager.js)
* content/InputHandler.js (content/InputHandler.js)
* content/Util.js (content/Util.js)
content/forms.js (content/forms.js)