int RenderBR::lineHeight(bool firstLine) const
{
if (firstLine && document()->usesFirstLineRules()) {
RenderStyle* s = style(firstLine);
if (s != style())
return s->computedLineHeight(viewportSize());
}
if (m_lineHeight == -1)
m_lineHeight = style()->computedLineHeight(viewportSize());
return m_lineHeight;
}
void CCLayerTreeHostImpl::calculateRenderPasses(CCRenderPassList& passes, CCLayerList& renderSurfaceLayerList)
{
renderSurfaceLayerList.append(rootLayer());
if (!rootLayer()->renderSurface())
rootLayer()->createRenderSurface();
rootLayer()->renderSurface()->clearLayerList();
rootLayer()->renderSurface()->setContentRect(IntRect(IntPoint(), viewportSize()));
rootLayer()->setClipRect(IntRect(IntPoint(), viewportSize()));
{
TransformationMatrix identityMatrix;
TRACE_EVENT("CCLayerTreeHostImpl::calcDrawEtc", this, 0);
CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer(), rootLayer(), identityMatrix, identityMatrix, renderSurfaceLayerList, rootLayer()->renderSurface()->layerList(), &m_layerSorter, layerRendererCapabilities().maxTextureSize);
}
if (layerRendererCapabilities().usingPartialSwap)
trackDamageForAllSurfaces(rootLayer(), renderSurfaceLayerList);
m_rootDamageRect = rootLayer()->renderSurface()->damageTracker()->currentDamageRect();
for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface();
OwnPtr<CCRenderPass> pass = CCRenderPass::create(renderSurface);
FloatRect surfaceDamageRect;
if (layerRendererCapabilities().usingPartialSwap)
surfaceDamageRect = damageInSurfaceSpace(renderSurfaceLayer, m_rootDamageRect);
pass->setSurfaceDamageRect(surfaceDamageRect);
const CCLayerList& layerList = renderSurface->layerList();
for (unsigned layerIndex = 0; layerIndex < layerList.size(); ++layerIndex) {
CCLayerImpl* layer = layerList[layerIndex];
if (layer->visibleLayerRect().isEmpty())
continue;
if (CCLayerTreeHostCommon::renderSurfaceContributesToTarget(layer, renderSurfaceLayer->id())) {
pass->appendQuadsForRenderSurfaceLayer(layer);
continue;
}
layer->willDraw(m_layerRenderer.get());
pass->appendQuadsForLayer(layer);
}
passes.append(pass.release());
}
}
void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdater& updater)
{
TRACE_EVENT("CCLayerTreeHost::updateLayers", this, 0);
if (!rootLayer->renderSurface())
rootLayer->createRenderSurface();
rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), viewportSize()));
IntRect rootClipRect(IntPoint(), viewportSize());
rootLayer->setClipRect(rootClipRect);
LayerList updateList;
updateList.append(rootLayer);
RenderSurfaceChromium* rootRenderSurface = rootLayer->renderSurface();
rootRenderSurface->clearLayerList();
TransformationMatrix identityMatrix;
{
TRACE_EVENT("CCLayerTreeHost::updateLayers::calcDrawEtc", this, 0);
CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer, rootLayer, identityMatrix, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
}
// Reset partial texture update requests.
m_partialTextureUpdateRequests = 0;
reserveTextures(updateList);
paintLayerContents(updateList, PaintVisible, updater);
if (!m_triggerIdlePaints)
return;
size_t preferredLimitBytes = m_contentsTextureManager->preferredMemoryLimitBytes();
size_t maxLimitBytes = m_contentsTextureManager->maxMemoryLimitBytes();
m_contentsTextureManager->reduceMemoryToLimit(preferredLimitBytes);
if (m_contentsTextureManager->currentMemoryUseBytes() >= preferredLimitBytes)
return;
// Idle painting should fail when we hit the preferred memory limit,
// otherwise it will always push us towards the maximum limit.
m_contentsTextureManager->setMaxMemoryLimitBytes(preferredLimitBytes);
// The second (idle) paint will be a no-op in layers where painting already occured above.
paintLayerContents(updateList, PaintIdle, updater);
m_contentsTextureManager->setMaxMemoryLimitBytes(maxLimitBytes);
for (size_t i = 0; i < updateList.size(); ++i)
updateList[i]->clearRenderSurface();
}
// Tests that setting an alternate layout viewport scrolls the alternate
// instead of the original.
TEST_F(RootFrameViewportTest, SetAlternateLayoutViewport) {
IntSize viewportSize(100, 100);
RootFrameViewStub* layoutViewport =
RootFrameViewStub::create(viewportSize, IntSize(200, 300));
VisualViewportStub* visualViewport =
VisualViewportStub::create(viewportSize, viewportSize);
RootFrameViewStub* alternateScroller =
RootFrameViewStub::create(viewportSize, IntSize(600, 500));
RootFrameViewport* rootFrameViewport =
RootFrameViewport::create(*visualViewport, *layoutViewport);
visualViewport->setScale(2);
rootFrameViewport->setScrollOffset(ScrollOffset(100, 100), UserScroll);
EXPECT_SIZE_EQ(ScrollOffset(50, 50), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(50, 50), layoutViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(100, 100), rootFrameViewport->getScrollOffset());
rootFrameViewport->setLayoutViewport(*alternateScroller);
EXPECT_SIZE_EQ(ScrollOffset(50, 50), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(0, 0), alternateScroller->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(50, 50), rootFrameViewport->getScrollOffset());
rootFrameViewport->setScrollOffset(ScrollOffset(200, 200), UserScroll);
EXPECT_SIZE_EQ(ScrollOffset(50, 50), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(150, 150), alternateScroller->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(200, 200), rootFrameViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(50, 50), layoutViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(550, 450),
rootFrameViewport->maximumScrollOffset());
}
void CCLayerTreeHost::paintLayerContents(const LayerList& renderSurfaceLayerList, PaintType paintType, CCTextureUpdater& updater)
{
// Use FrontToBack to allow for testing occlusion and performing culling during the tree walk.
typedef CCLayerIterator<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
bool recordMetricsForFrame = true; // FIXME: In the future, disable this when about:tracing is off.
CCOcclusionTracker occlusionTracker(IntRect(IntPoint(), viewportSize()), recordMetricsForFrame);
occlusionTracker.setUsePaintTracking(true); // FIXME: Remove this after m19 branch.
CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
occlusionTracker.enterLayer(it);
if (it.representsTargetRenderSurface()) {
ASSERT(it->renderSurface()->drawOpacity() || it->renderSurface()->drawOpacityIsAnimating());
paintMasksForRenderSurface(*it, paintType, updater);
} else if (it.representsItself()) {
ASSERT(!it->bounds().isEmpty());
update(*it, paintType, updater, &occlusionTracker);
}
occlusionTracker.leaveLayer(it);
}
occlusionTracker.overdrawMetrics().recordMetrics(this);
}
ScrollOffset maximumScrollOffset() const override {
ScrollOffset visibleViewport(viewportSize());
visibleViewport.scale(1 / m_scale);
ScrollOffset maxOffset = ScrollOffset(contentsSize()) - visibleViewport;
return ScrollOffset(maxOffset);
}
/*!
Starts scrolling the widget so that the point \a pos is visible inside the
viewport with margins specified in pixels by \a xmargin and \a ymargin.
If the specified point cannot be reached, the contents are scrolled to the
nearest valid position. The default value for both margins is 50 pixels.
This function performs the actual scrolling by calling scrollTo().
\sa maximumContentPosition()
*/
void QKineticScroller::ensureVisible(const QPointF &pos, int xmargin, int ymargin, int scrollTime)
{
QSizeF visible = viewportSize();
QPointF currentPos = contentPosition();
qKSDebug() << "QKS::ensureVisible(" << pos << " [pix], " << xmargin << " [pix], " << ymargin << " [pix], " << scrollTime << "[ms])";
qKSDebug() << " --> content position:" << contentPosition();
QRectF posRect(pos.x() - xmargin, pos.y() - ymargin, 2 * xmargin, 2 * ymargin);
QRectF visibleRect(currentPos, visible);
if (visibleRect.contains(posRect))
return;
QPointF newPos = currentPos;
if (posRect.top() < visibleRect.top())
newPos.setY(posRect.top());
else if (posRect.bottom() > visibleRect.bottom())
newPos.setY(posRect.bottom() - visible.height());
if (posRect.left() < visibleRect.left())
newPos.setX(posRect.left());
else if (posRect.right() > visibleRect.right())
newPos.setY(posRect.right() - visible.width());
scrollTo(newPos, scrollTime);
}
void VolumeRenderer::InitializeProjector(int type){
Vector projectorLocation(0,0,0);
projectorLocation = new Vector(0,0,2500) ;
Vector projectorDirection(0.0, 0.0, -1.0) ;
Vector centralSpot((double)projectionWidth/2,(double)projectionHeight/2, 0.0) ;
iPoint viewportSize(projectionWidth,projectionHeight,0) ;
float fSourceToDetector = this->params.RedSourceToDetector ;
float fDetectorPixelSize = 0.125;
this->projector.Configure(projectorLocation, // set up the projector system
projectorDirection,
fSourceToDetector,
viewportSize,
fDetectorPixelSize,
centralSpot);
this->projector.iFastPassSamplingInterval = 8; // configure the fast-pass projection method
// every 8th pixel is ray-casted. Rest are interpolated
//updating the transfer functions
this->projector.opacityFunction = this->params.opTranFunc ;
this->projector.colorTranFun = this->params.colTranFunc ;
// the scaling factors
this->projector.vProjectorScale.fVector[0] = 1;
this->projector.vProjectorScale.fVector[1] = 1;
this->projector.vProjectorScale.fVector[2] = 1;
//calculate transformation matrices
this->projector.CalculateTransformations() ;
//projector.printProjector() ;
}
Length ViewportStyleResolver::viewportLengthValue(CSSPropertyID id) const
{
ASSERT(id == CSSPropertyMaxHeight
|| id == CSSPropertyMinHeight
|| id == CSSPropertyMaxWidth
|| id == CSSPropertyMinWidth);
CSSValue* value = m_propertySet->getPropertyCSSValue(id);
if (!value || !value->isPrimitiveValue())
return Length(); // auto
CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
if (primitiveValue->getValueID() == CSSValueInternalExtendToZoom)
return Length(ExtendToZoom);
ComputedStyle* documentStyle = m_document->mutableComputedStyle();
// If we have viewport units the conversion will mark the document style as having viewport units.
bool documentStyleHasViewportUnits = documentStyle->hasViewportUnits();
documentStyle->setHasViewportUnits(false);
CSSToLengthConversionData::FontSizes fontSizes(documentStyle, documentStyle);
CSSToLengthConversionData::ViewportSize viewportSize(m_document->layoutView());
if (primitiveValue->getValueID() == CSSValueAuto)
return Length(Auto);
Length result = primitiveValue->convertToLength(CSSToLengthConversionData(documentStyle, fontSizes, viewportSize, 1.0f));
if (documentStyle->hasViewportUnits())
m_document->setHasViewportUnits();
documentStyle->setHasViewportUnits(documentStyleHasViewportUnits);
return result;
}
IntRect BackingStoreClient::absoluteRect() const
{
IntRect rect = IntRect(IntPoint::zero(), viewportSize());
if (!isMainFrame()) {
// It is possible that the owner HTML element has been removed at this point,
// especially when the frame is loading a JavaScript URL.
if (Element* elt = m_frame->ownerElement()) {
if (RenderBox* obj = elt->renderBox())
rect.move(obj->borderLeft() + obj->paddingLeft(), obj->borderTop() + obj->paddingTop());
}
}
Frame* frame = m_frame;
while (frame) {
if (Element* element = static_cast<Element*>(frame->ownerElement())) {
do {
rect.move(element->offsetLeft(), element->offsetTop());
} while ((element = element->offsetParent()));
}
if ((frame = frame->tree()->parent()))
rect.move((-frame->view()->scrollOffset()));
}
return rect;
}
/*!
Starts scrolling the widget so that the point \a pos is visible inside the
viewport with margins specified in pixels by \a xmargin and \a ymargin.
If the specified point cannot be reached, the contents are scrolled to the
nearest valid position. The default value for both margins is 50 pixels.
This function performs the actual scrolling by calling scrollTo().
\sa maximumScrollPosition()
*/
void QAbstractKineticScroller::ensureVisible(const QPoint &pos, int xmargin, int ymargin)
{
QSize visible = viewportSize();
QPoint currentPos = scrollPosition();
qKSDebug() << "QAbstractKineticScroller::ensureVisible(" << pos << ", " << xmargin << ", " << ymargin << ") - position: " << scrollPosition();
QRect posRect(pos.x() - xmargin, pos.y() - ymargin, 2 * xmargin, 2 * ymargin);
QRect visibleRect(currentPos, visible);
if (visibleRect.contains(posRect))
return;
QPoint newPos = currentPos;
if (posRect.top() < visibleRect.top())
newPos.setY(posRect.top());
else if (posRect.bottom() > visibleRect.bottom())
newPos.setY(posRect.bottom() - visible.height());
if (posRect.left() < visibleRect.left())
newPos.setX(posRect.left());
else if (posRect.right() > visibleRect.right())
newPos.setX(posRect.right() - visible.width());
scrollTo(newPos);
}
static inline float dimensionForViewportUnit(const SVGElement* context, CSSPrimitiveValue::UnitType unit)
{
if (!context)
return 0;
const Document& document = context->document();
FrameView* view = document.view();
if (!view)
return 0;
const ComputedStyle* style = computedStyleForLengthResolving(context);
if (!style)
return 0;
FloatSize viewportSize(view->width(), view->height());
switch (unit) {
case CSSPrimitiveValue::UnitType::ViewportWidth:
return viewportLengthPercent(viewportSize.width()) / style->effectiveZoom();
case CSSPrimitiveValue::UnitType::ViewportHeight:
return viewportLengthPercent(viewportSize.height()) / style->effectiveZoom();
case CSSPrimitiveValue::UnitType::ViewportMin:
return viewportMinPercent(viewportSize) / style->effectiveZoom();
case CSSPrimitiveValue::UnitType::ViewportMax:
return viewportMaxPercent(viewportSize) / style->effectiveZoom();
default:
break;
}
ASSERT_NOT_REACHED();
return 0;
}
// Tests that scrolling the viewport when the layout viewport is
// !userInputScrollable (as happens when overflow:hidden is set) works
// correctly, that is, the visual viewport can scroll, but not the layout.
TEST_F(RootFrameViewportTest, UserInputScrollable) {
IntSize viewportSize(100, 150);
RootFrameViewStub* layoutViewport =
RootFrameViewStub::create(viewportSize, IntSize(200, 300));
VisualViewportStub* visualViewport =
VisualViewportStub::create(viewportSize, viewportSize);
ScrollableArea* rootFrameViewport =
RootFrameViewport::create(*visualViewport, *layoutViewport);
visualViewport->setScale(2);
// Disable just the layout viewport's horizontal scrolling, the
// RootFrameViewport should remain scrollable overall.
layoutViewport->setUserInputScrollable(false, true);
visualViewport->setUserInputScrollable(true, true);
EXPECT_TRUE(rootFrameViewport->userInputScrollable(HorizontalScrollbar));
EXPECT_TRUE(rootFrameViewport->userInputScrollable(VerticalScrollbar));
// Layout viewport shouldn't scroll since it's not horizontally scrollable,
// but visual viewport should.
rootFrameViewport->userScroll(ScrollByPixel, FloatSize(300, 0));
EXPECT_SIZE_EQ(ScrollOffset(0, 0), layoutViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(50, 0), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(50, 0), rootFrameViewport->getScrollOffset());
// Vertical scrolling should be unaffected.
rootFrameViewport->userScroll(ScrollByPixel, FloatSize(0, 300));
EXPECT_SIZE_EQ(ScrollOffset(0, 150), layoutViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(50, 75), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(50, 225), rootFrameViewport->getScrollOffset());
// Try the same checks as above but for the vertical direction.
// ===============================================
rootFrameViewport->setScrollOffset(ScrollOffset(), ProgrammaticScroll);
// Disable just the layout viewport's vertical scrolling, the
// RootFrameViewport should remain scrollable overall.
layoutViewport->setUserInputScrollable(true, false);
visualViewport->setUserInputScrollable(true, true);
EXPECT_TRUE(rootFrameViewport->userInputScrollable(HorizontalScrollbar));
EXPECT_TRUE(rootFrameViewport->userInputScrollable(VerticalScrollbar));
// Layout viewport shouldn't scroll since it's not vertically scrollable,
// but visual viewport should.
rootFrameViewport->userScroll(ScrollByPixel, FloatSize(0, 300));
EXPECT_SIZE_EQ(ScrollOffset(0, 0), layoutViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(0, 75), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(0, 75), rootFrameViewport->getScrollOffset());
// Horizontal scrolling should be unaffected.
rootFrameViewport->userScroll(ScrollByPixel, FloatSize(300, 0));
EXPECT_SIZE_EQ(ScrollOffset(100, 0), layoutViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(50, 75), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(150, 75), rootFrameViewport->getScrollOffset());
}
bool CCLayerTreeHostImpl::canDraw()
{
if (!rootLayer())
return false;
if (viewportSize().isEmpty())
return false;
return true;
}
CSSToLengthConversionData StyleResolverState::fontSizeConversionData() const
{
float em = parentStyle()->specifiedFontSize();
float rem = rootElementStyle() ? rootElementStyle()->specifiedFontSize() : 1;
CSSToLengthConversionData::FontSizes fontSizes(em, rem, &parentStyle()->font());
CSSToLengthConversionData::ViewportSize viewportSize(document().layoutViewItem());
return CSSToLengthConversionData(style(), fontSizes, viewportSize, 1);
}
WTF::Optional<IntRect> DevToolsEmulator::visibleContentRectForPainting() const {
if (!m_viewportOverride)
return WTF::nullopt;
FloatSize viewportSize(m_webViewImpl->layerTreeView()->getViewportSize());
viewportSize.scale(1. / compositorDeviceScaleFactor());
viewportSize.scale(1. / m_viewportOverride->scale);
return enclosingIntRect(
FloatRect(m_viewportOverride->position.x, m_viewportOverride->position.y,
viewportSize.width(), viewportSize.height()));
}
void WebScrollBarManager::addWebView(WebView *view)
{
if (!m_enabled) {
return;
}
delete m_scrollbars.value(view);
ScrollBarData *data = new ScrollBarData;
data->vscrollbar = new WebScrollBar(Qt::Vertical, view);
data->hscrollbar = new WebScrollBar(Qt::Horizontal, view);
data->corner = new WebScrollBarCornerWidget(view);
m_scrollbars[view] = data;
const int thickness = data->vscrollbar->thickness();
auto updateValues = [=]() {
const QSize viewport = viewportSize(view, thickness);
data->vscrollbar->updateValues(viewport);
data->vscrollbar->setVisible(data->vscrollbarVisible);
data->hscrollbar->updateValues(viewport);
data->hscrollbar->setVisible(data->hscrollbarVisible);
data->corner->updateVisibility(data->vscrollbarVisible && data->hscrollbarVisible, thickness);
};
connect(view, &WebView::viewportResized, data->vscrollbar, updateValues);
connect(view->page(), &WebPage::scrollPositionChanged, data->vscrollbar, updateValues);
connect(view->page(), &WebPage::contentsSizeChanged, data->vscrollbar, [=]() {
const QString source = QL1S("var out = {"
"vertical: document.documentElement && window.innerWidth > document.documentElement.clientWidth,"
"horizontal: document.documentElement && window.innerHeight > document.documentElement.clientHeight"
"};out;");
QPointer<WebView> p(view);
view->page()->runJavaScript(source, WebPage::SafeJsWorld, [=](const QVariant &res) {
if (!p || !m_scrollbars.contains(view)) {
return;
}
const QVariantMap map = res.toMap();
data->vscrollbarVisible = map.value(QSL("vertical")).toBool();
data->hscrollbarVisible = map.value(QSL("horizontal")).toBool();
updateValues();
});
});
connect(view, &WebView::zoomLevelChanged, data->vscrollbar, [=]() {
view->page()->runJavaScript(m_scrollbarJs.arg(thickness));
});
if (m_scrollbars.size() == 1) {
createUserScript(thickness);
}
}
bool WebPuppeteerTab::screenshot(const QString &filename) {
// disable scrollbars, not as anyone is going to use them anyway
mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
QImage img(viewportSize(), QImage::Format_RGB32);
QPainter paint(&img);
mainFrame()->render(&paint);
paint.end();
mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAsNeeded);
mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAsNeeded);
return img.save(filename);
}
void CCLayerTreeHost::updateLayers(CCTextureUpdater& updater, size_t memoryAllocationLimitBytes)
{
ASSERT(m_layerRendererInitialized);
ASSERT(memoryAllocationLimitBytes);
if (!rootLayer())
return;
if (viewportSize().isEmpty())
return;
m_contentsTextureManager->setMaxMemoryLimitBytes(memoryAllocationLimitBytes);
updateLayers(rootLayer(), updater);
}
void CCDirectRenderer::drawFrame(const CCRenderPassList& renderPassesInDrawOrder, const CCRenderPassIdHashMap& renderPassesById)
{
const CCRenderPass* rootRenderPass = renderPassesInDrawOrder.last();
ASSERT(rootRenderPass);
DrawingFrame frame;
frame.renderPassesById = &renderPassesById;
frame.rootRenderPass = rootRenderPass;
frame.rootDamageRect = capabilities().usingPartialSwap ? rootRenderPass->damageRect() : rootRenderPass->outputRect();
frame.rootDamageRect.intersect(IntRect(IntPoint::zero(), viewportSize()));
beginDrawingFrame(frame);
for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i)
drawRenderPass(frame, renderPassesInDrawOrder[i]);
finishDrawingFrame(frame);
}
void ChromeClientQt::didReceiveViewportArguments(Frame* frame, const ViewportArguments& arguments) const
{
if (m_webPage->mainFrame()->d->initialLayoutComplete)
return;
QSize viewportSize(arguments.width, arguments.height);
bool isUserScalable = arguments.userScalable == 1;
QWebPage::ViewportHints hints;
hints.m_isValid = true;
hints.m_size = viewportSize;
hints.m_initialScaleFactor = arguments.initialScale;
hints.m_minimumScaleFactor = arguments.minimumScale;
hints.m_maximumScaleFactor = arguments.maximumScale;
hints.m_isUserScalable = isUserScalable;
emit m_webPage->viewportChangeRequested(hints);
}
// Reimplemented
void QmvList::resizeEvent( QResizeEvent *e )
{
QListView::resizeEvent( e );
QSize vs = viewportSize( 0, contentsHeight() );
int os = header()->sectionSize( 1 );
int ns = vs.width() - header()->sectionSize( 0 );
if ( ns < 16 )
ns = 16;
header()->resizeSection( 1, ns );
header()->repaint( header()->width() - header()->sectionSize( 1 ),
0, header()->sectionSize( 1 ), header()->height() );
int elipsis = fontMetrics().width("...") + 10;
viewport()->repaint( header()->sectionPos(1) + os - elipsis, 0, elipsis, viewport()->height(), FALSE );
if ( currentItem() )
( ( QmvItem* )currentItem() )->showEditor();
}
// This function commits the CCLayerTreeHost to an impl tree. When modifying
// this function, keep in mind that the function *runs* on the impl thread! Any
// code that is logically a main thread operation, e.g. deletion of a LayerChromium,
// should be delayed until the CCLayerTreeHost::commitComplete, which will run
// after the commit, but on the main thread.
void CCLayerTreeHost::finishCommitOnImplThread(CCLayerTreeHostImpl* hostImpl)
{
ASSERT(CCProxy::isImplThread());
hostImpl->setRootLayer(TreeSynchronizer::synchronizeTrees(rootLayer(), hostImpl->releaseRootLayer()));
// We may have added an animation during the tree sync. This will cause both layer tree hosts
// to visit their controllers.
if (rootLayer()) {
hostImpl->setNeedsAnimateLayers();
m_needsAnimateLayers = true;
}
hostImpl->setSourceFrameNumber(frameNumber());
hostImpl->setViewportSize(viewportSize());
hostImpl->setPageScaleFactorAndLimits(m_pageScaleFactor, m_minPageScaleFactor, m_maxPageScaleFactor);
hostImpl->setBackgroundColor(m_backgroundColor);
m_frameNumber++;
}
// Tests that scrolls on the root frame scroll the visual viewport before
// trying to scroll the layout viewport.
TEST_F(RootFrameViewportTest, ViewportScrollOrder) {
IntSize viewportSize(100, 100);
RootFrameViewStub* layoutViewport =
RootFrameViewStub::create(viewportSize, IntSize(200, 300));
VisualViewportStub* visualViewport =
VisualViewportStub::create(viewportSize, viewportSize);
ScrollableArea* rootFrameViewport =
RootFrameViewport::create(*visualViewport, *layoutViewport);
visualViewport->setScale(2);
rootFrameViewport->setScrollOffset(ScrollOffset(40, 40), UserScroll);
EXPECT_SIZE_EQ(ScrollOffset(40, 40), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(0, 0), layoutViewport->getScrollOffset());
rootFrameViewport->setScrollOffset(ScrollOffset(60, 60), ProgrammaticScroll);
EXPECT_SIZE_EQ(ScrollOffset(50, 50), visualViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(10, 10), layoutViewport->getScrollOffset());
}
void CCLayerTreeHost::initializeLayerRenderer()
{
TRACE_EVENT("CCLayerTreeHost::initializeLayerRenderer", this, 0);
if (!m_proxy->initializeLayerRenderer()) {
// Uh oh, better tell the client that we can't do anything with this context.
m_client->didRecreateContext(false);
return;
}
// Update m_settings based on capabilities that we got back from the renderer.
m_settings.acceleratePainting = m_proxy->layerRendererCapabilities().usingAcceleratedPainting;
// Update m_settings based on partial update capability.
m_settings.maxPartialTextureUpdates = min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates());
m_contentsTextureManager = TextureManager::create(TextureManager::highLimitBytes(viewportSize()),
TextureManager::reclaimLimitBytes(viewportSize()),
m_proxy->layerRendererCapabilities().maxTextureSize);
m_layerRendererInitialized = true;
}
void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdater& updater)
{
TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers");
if (!rootLayer->renderSurface())
rootLayer->createRenderSurface();
rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), deviceViewportSize()));
IntRect rootClipRect(IntPoint(), deviceViewportSize());
rootLayer->setClipRect(rootClipRect);
LayerList updateList;
updateList.append(rootLayer);
RenderSurfaceChromium* rootRenderSurface = rootLayer->renderSurface();
rootRenderSurface->clearLayerList();
{
TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers::calcDrawEtc");
WebTransformationMatrix identityMatrix;
WebTransformationMatrix deviceScaleTransform;
deviceScaleTransform.scale(m_deviceScaleFactor);
CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
FloatRect rootScissorRect(FloatPoint(0, 0), viewportSize());
CCLayerTreeHostCommon::calculateVisibleAndScissorRects(updateList, rootScissorRect);
}
// Reset partial texture update requests.
m_partialTextureUpdateRequests = 0;
prioritizeTextures(updateList);
bool needMoreUpdates = paintLayerContents(updateList, updater);
if (m_triggerIdleUpdates && needMoreUpdates)
setNeedsCommit();
for (size_t i = 0; i < updateList.size(); ++i)
updateList[i]->clearRenderSurface();
}
bool CCLayerTreeHost::updateLayers(CCTextureUpdater& updater)
{
if (!m_layerRendererInitialized) {
initializeLayerRenderer();
// If we couldn't initialize, then bail since we're returning to software mode.
if (!m_layerRendererInitialized)
return false;
}
if (m_contextLost) {
if (recreateContext() != RecreateSucceeded)
return false;
}
if (!rootLayer())
return true;
if (viewportSize().isEmpty())
return true;
updateLayers(rootLayer(), updater);
return true;
}
// This function commits the CCLayerTreeHost to an impl tree. When modifying
// this function, keep in mind that the function *runs* on the impl thread! Any
// code that is logically a main thread operation, e.g. deletion of a LayerChromium,
// should be delayed until the CCLayerTreeHost::commitComplete, which will run
// after the commit, but on the main thread.
void CCLayerTreeHost::finishCommitOnImplThread(CCLayerTreeHostImpl* hostImpl)
{
ASSERT(CCProxy::isImplThread());
hostImpl->setRootLayer(TreeSynchronizer::synchronizeTrees(rootLayer(), hostImpl->detachLayerTree(), hostImpl));
// We may have added an animation during the tree sync. This will cause both layer tree hosts
// to visit their controllers.
if (rootLayer() && m_needsAnimateLayers)
hostImpl->setNeedsAnimateLayers();
hostImpl->setSourceFrameNumber(frameNumber());
hostImpl->setViewportSize(viewportSize());
hostImpl->setDeviceScaleFactor(deviceScaleFactor());
hostImpl->setPageScaleFactorAndLimits(m_pageScaleFactor, m_minPageScaleFactor, m_maxPageScaleFactor);
hostImpl->setBackgroundColor(m_backgroundColor);
hostImpl->setHasTransparentBackground(m_hasTransparentBackground);
hostImpl->setVisible(m_visible);
hostImpl->setSourceFrameCanBeDrawn(m_frameIsForDisplay);
m_frameNumber++;
}
void CCLayerTreeHost::updateLayers(CCTextureUpdater& updater)
{
ASSERT(m_layerRendererInitialized);
// The visible state and memory allocation are set independently and in
// arbitrary order, so do not change the memory allocation used for the
// current commit until both values match intentions.
// FIXME: These two states should be combined into a single action so we
// need a single commit to change visible state, and this can be removed.
bool memoryAllocationStateMatchesVisibility = m_visible == m_memoryAllocationIsForDisplay;
if (memoryAllocationStateMatchesVisibility) {
m_contentsTextureManager->setMemoryAllocationLimitBytes(m_memoryAllocationBytes);
m_frameIsForDisplay = m_memoryAllocationIsForDisplay;
}
if (!rootLayer())
return;
if (viewportSize().isEmpty())
return;
updateLayers(rootLayer(), updater);
}
// Make sure scrolls using the scroll animator (scroll(), setScrollOffset())
// work correctly when one of the subviewports is explicitly scrolled without
// using the // RootFrameViewport interface.
TEST_F(RootFrameViewportTest, TestScrollAnimatorUpdatedBeforeScroll) {
IntSize viewportSize(100, 150);
RootFrameViewStub* layoutViewport =
RootFrameViewStub::create(viewportSize, IntSize(200, 300));
VisualViewportStub* visualViewport =
VisualViewportStub::create(viewportSize, viewportSize);
ScrollableArea* rootFrameViewport =
RootFrameViewport::create(*visualViewport, *layoutViewport);
visualViewport->setScale(2);
visualViewport->setScrollOffset(ScrollOffset(50, 75), ProgrammaticScroll);
EXPECT_SIZE_EQ(ScrollOffset(50, 75), rootFrameViewport->getScrollOffset());
// If the scroll animator doesn't update, it will still think it's at (0, 0)
// and so it may early exit.
rootFrameViewport->setScrollOffset(ScrollOffset(0, 0), ProgrammaticScroll);
EXPECT_SIZE_EQ(ScrollOffset(0, 0), rootFrameViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(0, 0), visualViewport->getScrollOffset());
// Try again for userScroll()
visualViewport->setScrollOffset(ScrollOffset(50, 75), ProgrammaticScroll);
EXPECT_SIZE_EQ(ScrollOffset(50, 75), rootFrameViewport->getScrollOffset());
rootFrameViewport->userScroll(ScrollByPixel, FloatSize(-50, 0));
EXPECT_SIZE_EQ(ScrollOffset(0, 75), rootFrameViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(0, 75), visualViewport->getScrollOffset());
// Make sure the layout viewport is also accounted for.
rootFrameViewport->setScrollOffset(ScrollOffset(0, 0), ProgrammaticScroll);
layoutViewport->setScrollOffset(ScrollOffset(100, 150), ProgrammaticScroll);
EXPECT_SIZE_EQ(ScrollOffset(100, 150), rootFrameViewport->getScrollOffset());
rootFrameViewport->userScroll(ScrollByPixel, FloatSize(-100, 0));
EXPECT_SIZE_EQ(ScrollOffset(0, 150), rootFrameViewport->getScrollOffset());
EXPECT_SIZE_EQ(ScrollOffset(0, 150), layoutViewport->getScrollOffset());
}
