void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo) { if (!m_scrollLayerImpl) return; // Only send fake scroll/zoom deltas if we're pinch zooming out by a // significant amount. This also ensures only one fake delta set will be // sent. const float pinchZoomOutSensitivity = 0.95; if (m_pageScaleDelta > pinchZoomOutSensitivity) return; // Compute where the scroll offset/page scale would be if fully pinch-zoomed // out from the anchor point. FloatSize scrollBegin = toSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta()); scrollBegin.scale(m_pageScaleDelta); float scaleBegin = m_pageScale * m_pageScaleDelta; float pageScaleDeltaToSend = m_minPageScale / m_pageScale; FloatSize scaledContentsSize = contentSize(); scaledContentsSize.scale(pageScaleDeltaToSend); FloatSize anchor = toSize(m_previousPinchAnchor); FloatSize scrollEnd = scrollBegin + anchor; scrollEnd.scale(m_minPageScale / scaleBegin); scrollEnd -= anchor; scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_viewportSize)).expandedTo(FloatSize(0, 0)); scrollEnd.scale(1 / pageScaleDeltaToSend); makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScale); }
void CCLayerImpl::scrollBy(const FloatSize& scroll) { FloatSize newDelta = m_scrollDelta + scroll; IntSize minDelta = -toSize(m_scrollPosition); IntSize maxDelta = m_maxScrollPosition - toSize(m_scrollPosition); // Clamp newDelta so that position + delta stays within scroll bounds. m_scrollDelta = newDelta.expandedTo(minDelta).shrunkTo(maxDelta); noteLayerPropertyChangedForSubtree(); }
void FixedRatioTransform::setView(double zoom, QPointF dataPoint, QPointF scenePoint) { zoom = clamp(zoom, m_minZoom, m_maxZoom); m_zoom = zoom; QPointF p1 = -toPoint(dataToScene(toSize(m_dataRect.topLeft()))); QPointF p2 = -toPoint(dataToScene(toSize(m_dataRect.bottomRight()))); m_clampRect = QRectF(p1, p2).normalized(); pan(dataPoint, scenePoint); }
void LinearAllocator::dumpMemoryStats(const char* prefix) { float prettySize; const char* prettySuffix; prettySuffix = toSize(mTotalAllocated, prettySize); ALOGD("%sTotal allocated: %.2f%s", prefix, prettySize, prettySuffix); prettySuffix = toSize(mWastedSpace, prettySize); ALOGD("%sWasted space: %.2f%s (%.1f%%)", prefix, prettySize, prettySuffix, (float) mWastedSpace / (float) mTotalAllocated * 100.0f); ALOGD("%sPages %zu (dedicated %zu)", prefix, mPageCount, mDedicatedPageCount); }
void CCLayerImpl::scrollBy(const FloatSize& scroll) { IntSize minDelta = -toSize(m_scrollPosition); IntSize maxDelta = m_maxScrollPosition - toSize(m_scrollPosition); // Clamp newDelta so that position + delta stays within scroll bounds. FloatSize newDelta = (m_scrollDelta + scroll).expandedTo(minDelta).shrunkTo(maxDelta); if (m_scrollDelta == newDelta) return; m_scrollDelta = newDelta; if (m_scrollbarAnimationController) m_scrollbarAnimationController->updateScrollOffset(this); noteLayerPropertyChangedForSubtree(); }
bool RenderSVGRoot::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const IntPoint& pointInContainer, const IntPoint& accumulatedOffset, HitTestAction hitTestAction) { IntPoint pointInParent = pointInContainer - toSize(accumulatedOffset); IntPoint pointInBorderBox = pointInParent - parentOriginToBorderBox(); // Note: For now, we're ignoring hits to border and padding for <svg> IntPoint pointInContentBox = pointInBorderBox - borderOriginToContentBox(); if (!contentBoxRect().contains(pointInContentBox)) return false; IntPoint localPoint = localToParentTransform().inverse().mapPoint(pointInParent); for (RenderObject* child = lastChild(); child; child = child->previousSibling()) { if (child->nodeAtFloatPoint(request, result, localPoint, hitTestAction)) { // FIXME: CSS/HTML assumes the local point is relative to the border box, right? updateHitTestResult(result, pointInBorderBox); // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet. result.addNodeToRectBasedTestResult(child->node(), pointInContainer); return true; } } // If we didn't early exit above, we've just hit the container <svg> element. Unlike SVG 1.1, 2nd Edition allows container elements to be hit. if (hitTestAction == HitTestBlockBackground && style()->pointerEvents() != PE_NONE) { // Only return true here, if the last hit testing phase 'BlockBackground' is executed. If we'd return true in the 'Foreground' phase, // hit testing would stop immediately. For SVG only trees this doesn't matter. Though when we have a <foreignObject> subtree we need // to be able to detect hits on the background of a <div> element. If we'd return true here in the 'Foreground' phase, we are not able // to detect these hits anymore. updateHitTestResult(result, roundedIntPoint(localPoint)); return true; } return false; }
MouseRelatedEvent::MouseRelatedEvent(const AtomicString& eventType, bool canBubble, bool cancelable, PassRefPtr<AbstractView> abstractView, int detail, const LayoutPoint& screenLocation, const LayoutPoint& windowLocation, bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, bool isSimulated) : UIEventWithKeyState(eventType, canBubble, cancelable, abstractView, detail, ctrlKey, altKey, shiftKey, metaKey) , m_screenLocation(screenLocation) , m_isSimulated(isSimulated) { LayoutPoint adjustedPageLocation; LayoutPoint scrollPosition; Frame* frame = view() ? view()->frame() : 0; if (frame && !isSimulated) { if (FrameView* frameView = frame->view()) { scrollPosition = frameView->scrollPosition(); adjustedPageLocation = frameView->windowToContents(windowLocation); float pageZoom = frame->pageZoomFactor(); if (pageZoom != 1.0f) { // Adjust our pageX and pageY to account for the page zoom. adjustedPageLocation.scale(1 / pageZoom, 1 / pageZoom); // FIXME: Change this to use float math and proper rounding (or // better yet, use LayoutPoint::scale). scrollPosition.setX(scrollPosition.x() / pageZoom); scrollPosition.setY(scrollPosition.y() / pageZoom); } } } m_clientLocation = adjustedPageLocation - toSize(scrollPosition); m_pageLocation = adjustedPageLocation; initCoordinates(); }
void FixedRatioTransform::pan(QPointF dataPoint, QPointF scenePoint) { QSizeF offsetToOrigin = dataToScene(toSize(dataPoint)); m_origin = scenePoint - toPoint(offsetToOrigin); m_origin = clamp(m_origin, m_clampRect); emit viewChanged(); }
void RenderTextControl::hitInnerTextElement(HitTestResult& result, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset) { LayoutPoint adjustedLocation = accumulatedOffset + location(); HTMLElement* innerText = innerTextElement(); result.setInnerNode(innerText); result.setInnerNonSharedNode(innerText); result.setLocalPoint(pointInContainer - toSize(adjustedLocation + innerText->renderBox()->location())); }
void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale) { if (!m_scrollLayerImpl) return; CCLayerTreeHostCommon::ScrollUpdateInfo scroll; scroll.layerId = m_scrollLayerImpl->id(); scroll.scrollDelta = scrollOffset - toSize(m_scrollLayerImpl->scrollPosition()); scrollInfo->scrolls.append(scroll); m_scrollLayerImpl->setSentScrollDelta(scroll.scrollDelta); m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScale; }
dSettingWindow::dSettingWindow( const QString &_key, dSetting *_parent, dWindowFrame *_window ): window(_window), dSetting(_key,_parent ) { positionElement = getChildXmlElement(tr("position")); sizeElement = getChildXmlElement(tr("size")); skinElement = getChildXmlElement(tr("skin")); setNode(false); window->move( positionElement.attribute(tr("x"),tr("0")).toInt(), positionElement.attribute(tr("y"),tr("0")).toInt()); window->resize( toSize(tr("size"),QSize(500,200))); double b = toInt(tr("opacity"),tr("value"),100)+1; window->setWindowOpacity(b/100); skinFileName = skinElement.attribute(tr("value"),tr("window-skin/default/window-skin.ini")); window->setSkin(skinFileName); window->setMinimumSize( toSize(tr("minimum_size"),QSize(200,200))); };
void LayerRendererChromium::drawLayer(CCLayerImpl* layer, CCRenderSurface* targetSurface) { if (layer->renderSurface() && layer->renderSurface() != targetSurface) { layer->renderSurface()->draw(this, layer->getDrawRect()); layer->renderSurface()->releaseContentsTexture(); return; } if (!layer->drawsContent()) return; if (!layer->opacity()) return; if (layer->bounds().isEmpty()) return; IntRect targetSurfaceRect = layer->targetRenderSurface() ? layer->targetRenderSurface()->contentRect() : m_defaultRenderSurface->contentRect(); if (layer->usesLayerScissor()) { IntRect scissorRect = layer->scissorRect(); targetSurfaceRect.intersect(scissorRect); if (targetSurfaceRect.isEmpty()) return; setScissorToRect(scissorRect); } else GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST)); IntRect visibleLayerRect = CCLayerTreeHostCommon::calculateVisibleLayerRect(targetSurfaceRect, layer->bounds(), layer->contentBounds(), layer->drawTransform()); visibleLayerRect.move(toSize(layer->scrollPosition())); layer->setVisibleLayerRect(visibleLayerRect); // The layer should not be drawn if (1) it is not double-sided and (2) the back of the layer is facing the screen. // This second condition is checked by computing the transformed normal of the layer. if (!layer->doubleSided()) { FloatRect layerRect(FloatPoint(0, 0), FloatSize(layer->bounds())); FloatQuad mappedLayer = layer->screenSpaceTransform().mapQuad(FloatQuad(layerRect)); FloatSize horizontalDir = mappedLayer.p2() - mappedLayer.p1(); FloatSize verticalDir = mappedLayer.p4() - mappedLayer.p1(); FloatPoint3D xAxis(horizontalDir.width(), horizontalDir.height(), 0); FloatPoint3D yAxis(verticalDir.width(), verticalDir.height(), 0); FloatPoint3D zAxis = xAxis.cross(yAxis); if (zAxis.z() < 0) return; } layer->draw(this); // Draw the debug border if there is one. layer->drawDebugBorder(this); }
void CCLayerTreeHostImpl::animatePageScale(double frameBeginTimeMs) { if (!m_pageScaleAnimation) return; IntSize scrollTotal = toSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta()); setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(frameBeginTimeMs) / m_pageScale); IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(frameBeginTimeMs); nextScroll.scale(1 / m_pageScaleDelta); m_scrollLayerImpl->scrollBy(nextScroll - scrollTotal); m_client->setNeedsRedrawOnImplThread(); if (m_pageScaleAnimation->isAnimationCompleteAtTime(frameBeginTimeMs)) { m_pageScaleAnimation.clear(); m_client->setNeedsCommitOnImplThread(); } }
void MouseRelatedEvent::computeRelativePosition() { Node* targetNode = target() ? target()->toNode() : 0; if (!targetNode) return; // Compute coordinates that are based on the target. m_layerLocation = m_pageLocation; m_offsetLocation = m_pageLocation; // Must have an updated render tree for this math to work correctly. targetNode->document()->updateStyleIfNeeded(); // Adjust offsetLocation to be relative to the target's position. if (!isSimulated()) { if (RenderObject* r = targetNode->renderer()) { FloatPoint localPos = r->absoluteToLocal(absoluteLocation(), false, true); m_offsetLocation = roundedLayoutPoint(localPos); float scaleFactor = 1 / pageZoomFactor(this); if (scaleFactor != 1.0f) m_offsetLocation.scale(scaleFactor, scaleFactor); } } // Adjust layerLocation to be relative to the layer. // FIXME: We're pretty sure this is the wrong definition of "layer." // Our RenderLayer is a more modern concept, and layerX/Y is some // other notion about groups of elements (left over from the Netscape 4 days?); // we should test and fix this. Node* n = targetNode; while (n && !n->renderer()) n = n->parentNode(); RenderLayer* layer; if (n && (layer = n->renderer()->enclosingLayer())) { layer->updateLayerPosition(); for (; layer; layer = layer->parent()) { m_layerLocation -= toSize(layer->location()); } } m_hasCachedRelativePosition = true; }
void RenderScrollbarPart::paintIntoRect(GraphicsContext* graphicsContext, const LayoutPoint& paintOffset, const LayoutRect& rect) { // Make sure our dimensions match the rect. setLocation(rect.location() - toSize(paintOffset)); setWidth(rect.width()); setHeight(rect.height()); if (graphicsContext->paintingDisabled()) return; // Now do the paint. PaintInfo paintInfo(graphicsContext, rect, PaintPhaseBlockBackground, false, 0, 0, 0); paint(paintInfo, paintOffset); paintInfo.phase = PaintPhaseChildBlockBackgrounds; paint(paintInfo, paintOffset); paintInfo.phase = PaintPhaseFloat; paint(paintInfo, paintOffset); paintInfo.phase = PaintPhaseForeground; paint(paintInfo, paintOffset); paintInfo.phase = PaintPhaseOutline; paint(paintInfo, paintOffset); }
void NonCompositedContentHost::setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin) { if (!haveScrollLayer()) return; bool visibleRectChanged = m_viewportSize != viewportSize; m_viewportSize = viewportSize; WebLayer* layer = scrollLayer(); layer->setScrollPosition(scrollPosition + scrollOrigin); layer->setPosition(WebFloatPoint(-scrollPosition)); // Due to the possibility of pinch zoom, the noncomposited layer is always // assumed to be scrollable. layer->setScrollable(true); m_graphicsLayer->setSize(contentsSize); // In RTL-style pages, the origin of the initial containing block for the // root layer may be positive; translate the layer to avoid negative // coordinates. m_layerAdjust = -toSize(scrollOrigin); if (m_graphicsLayer->transform().m41() != m_layerAdjust.width() || m_graphicsLayer->transform().m42() != m_layerAdjust.height()) { WebCore::TransformationMatrix transform = m_graphicsLayer->transform(); transform.setM41(m_layerAdjust.width()); transform.setM42(m_layerAdjust.height()); m_graphicsLayer->setTransform(transform); // If a tiled layer is shifted left or right, the content that goes into // each tile will change. Invalidate the entire layer when this happens. m_graphicsLayer->setNeedsDisplay(); } else if (visibleRectChanged) m_graphicsLayer->setNeedsDisplay(); WebCore::GraphicsLayer* clipLayer = m_graphicsLayer->parent()->parent(); WebCore::GraphicsLayer* rootLayer = clipLayer; while (rootLayer->parent()) rootLayer = rootLayer->parent(); setScrollbarBoundsContainPageScale(rootLayer, clipLayer); }
void RenderScrollbarPart::paintIntoRect(GraphicsContext* graphicsContext, const LayoutPoint& paintOffset, const LayoutRect& rect) { // Make sure our dimensions match the rect. setLocation(rect.location() - toSize(paintOffset)); setWidth(rect.width()); setHeight(rect.height()); if (graphicsContext->paintingDisabled() || !style()->opacity()) return; // We don't use RenderLayers for scrollbar parts, so we need to handle opacity here. // Opacity for ScrollbarBGPart is handled by RenderScrollbarTheme::willPaintScrollbar(). bool needsTransparencyLayer = m_part != ScrollbarBGPart && style()->opacity() < 1; if (needsTransparencyLayer) { graphicsContext->save(); graphicsContext->clip(rect); graphicsContext->beginTransparencyLayer(style()->opacity()); } // Now do the paint. PaintInfo paintInfo(graphicsContext, pixelSnappedIntRect(rect), PaintPhaseBlockBackground, PaintBehaviorNormal); paint(paintInfo, paintOffset); paintInfo.phase = PaintPhaseChildBlockBackgrounds; paint(paintInfo, paintOffset); paintInfo.phase = PaintPhaseFloat; paint(paintInfo, paintOffset); paintInfo.phase = PaintPhaseForeground; paint(paintInfo, paintOffset); paintInfo.phase = PaintPhaseOutline; paint(paintInfo, paintOffset); if (needsTransparencyLayer) { graphicsContext->endTransparencyLayer(); graphicsContext->restore(); } }
void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTimeMs, double durationMs) { if (!m_scrollLayerImpl) return; IntSize scrollTotal = toSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta()); scrollTotal.scale(m_pageScaleDelta); float scaleTotal = m_pageScale * m_pageScaleDelta; IntSize scaledContentSize = contentSize(); scaledContentSize.scale(m_pageScaleDelta); m_pageScaleAnimation = CCPageScaleAnimation::create(scrollTotal, scaleTotal, m_viewportSize, scaledContentSize, startTimeMs); if (anchorPoint) { IntSize windowAnchor(targetPosition); windowAnchor.scale(scaleTotal / pageScale); windowAnchor -= scrollTotal; m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, durationMs); } else m_pageScaleAnimation->zoomTo(targetPosition, pageScale, durationMs); m_client->setNeedsRedrawOnImplThread(); m_client->setNeedsCommitOnImplThread(); }
QSize DocumentAdapter::GetPageSize (int) const { auto size = Doc_->pageSize (); size.setWidth (std::ceil (size.width ())); return size.toSize (); }
// Implicit conversion to size_t function. numeric::operator size_t() const { return toSize(); }
QPointF FixedRatioTransform::sceneToData(QPointF scenePoint) const { return toPoint(sceneToData(toSize(scenePoint - m_origin))); }
QPointF FixedRatioTransform::dataToScene(QPointF dataPoint) const { return m_origin + toPoint(dataToScene(toSize(dataPoint))); }