IntSize SVGImage::size() const
{
IntSize defaultSize(300, 150);
// FIXME: Eventually we'll be passed in the dest size and can scale against that
IntSize destSize = defaultSize;
if (!m_frame || !m_frame->document())
return IntSize();
SVGSVGElement* rootElement = static_cast<SVGDocument*>(m_frame->document())->rootElement();
if (!rootElement)
return defaultSize;
SVGLength width = rootElement->width();
SVGLength height = rootElement->height();
IntSize svgSize;
if (width.unitType() == LengthTypePercentage)
svgSize.setWidth(static_cast<int>(width.valueInSpecifiedUnits() * destSize.width()));
else
svgSize.setWidth(static_cast<int>(width.value()));
if (height.unitType() == LengthTypePercentage)
svgSize.setHeight(static_cast<int>(height.valueInSpecifiedUnits() * destSize.height()));
else
svgSize.setHeight(static_cast<int>(height.value()));
return svgSize;
}
IntSize SVGImage::size() const
{
if (!m_page)
return IntSize();
Frame* frame = m_page->mainFrame();
SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
if (!rootElement)
return IntSize();
SVGLength width = rootElement->width();
SVGLength height = rootElement->height();
IntSize svgSize;
if (width.unitType() == LengthTypePercentage)
svgSize.setWidth(rootElement->relativeWidthValue());
else
svgSize.setWidth(static_cast<int>(width.value(rootElement)));
if (height.unitType() == LengthTypePercentage)
svgSize.setHeight(rootElement->relativeHeightValue());
else
svgSize.setHeight(static_cast<int>(height.value(rootElement)));
return svgSize;
}
void CCHeadsUpDisplay::draw(CCLayerTreeHostImpl* layerTreeHostImpl)
{
CCRenderer* layerRenderer = layerTreeHostImpl->layerRenderer();
WebKit::WebGraphicsContext3D* context = layerTreeHostImpl->context()->context3D();
if (!context) {
// FIXME: Implement this path for software compositing.
return;
}
if (!m_hudTexture)
m_hudTexture = ManagedTexture::create(layerRenderer->implTextureManager());
const CCLayerTreeSettings& settings = layerTreeHostImpl->settings();
// Use a fullscreen texture only if we need to...
IntSize hudSize;
if (showPlatformLayerTree(settings) || showDebugRects(settings)) {
hudSize.setWidth(min(2048, layerTreeHostImpl->deviceViewportSize().width()));
hudSize.setHeight(min(2048, layerTreeHostImpl->deviceViewportSize().height()));
} else {
hudSize.setWidth(512);
hudSize.setHeight(128);
}
if (!m_hudTexture->reserve(hudSize, GraphicsContext3D::RGBA))
return;
// Render pixels into the texture.
PlatformCanvas canvas;
canvas.resize(hudSize);
{
PlatformCanvas::Painter painter(&canvas, PlatformCanvas::Painter::GrayscaleText);
painter.context()->clearRect(FloatRect(0, 0, hudSize.width(), hudSize.height()));
drawHudContents(painter.context(), layerTreeHostImpl, settings, hudSize);
}
// Upload to GL.
{
PlatformCanvas::AutoLocker locker(&canvas);
m_hudTexture->bindTexture(layerTreeHostImpl->context(), layerRenderer->implTextureAllocator());
bool uploadedViaMap = false;
if (layerRenderer->capabilities().usingMapSub) {
uint8_t* pixelDest = static_cast<uint8_t*>(context->mapTexSubImage2DCHROMIUM(GraphicsContext3D::TEXTURE_2D, 0, 0, 0, hudSize.width(), hudSize.height(), GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, Extensions3DChromium::WRITE_ONLY));
if (pixelDest) {
uploadedViaMap = true;
memcpy(pixelDest, locker.pixels(), hudSize.width() * hudSize.height() * 4);
context->unmapTexSubImage2DCHROMIUM(pixelDest);
}
}
if (!uploadedViaMap) {
GLC(context, context->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, canvas.size().width(), canvas.size().height(), 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, locker.pixels()));
}
}
layerRenderer->drawHeadsUpDisplay(m_hudTexture.get(), hudSize);
m_hudTexture->unreserve();
}
IntSize ScrollView::overhangAmount() const
{
IntSize stretch;
if (scrollY() < 0)
stretch.setHeight(scrollY());
else if (scrollY() > contentsHeight() - visibleContentRect().height())
stretch.setHeight(scrollY() - (contentsHeight() - visibleContentRect().height()));
if (scrollX() < 0)
stretch.setWidth(scrollX());
else if (scrollX() > contentsWidth() - visibleContentRect().width())
stretch.setWidth(scrollX() - (contentsWidth() - visibleContentRect().width()));
return stretch;
}
bool RenderThemeSafari::paintButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
{
ASSERT(SafariThemeLibrary());
// We inflate the rect as needed to account for padding included in the cell to accommodate the button
// shadow. We don't consider this part of the bounds of the control in WebKit.
NSControlSize controlSize = controlSizeFromRect(r, buttonSizes());
IntRect inflatedRect = r;
ThemePart part;
if (r.height() <= buttonSizes()[NSRegularControlSize].height()) {
// Push button
part = SafariTheme::PushButtonPart;
IntSize size = buttonSizes()[controlSize];
size.setWidth(r.width());
// Center the button within the available space.
if (inflatedRect.height() > size.height()) {
inflatedRect.setY(inflatedRect.y() + (inflatedRect.height() - size.height()) / 2);
inflatedRect.setHeight(size.height());
}
// Now inflate it to account for the shadow.
inflatedRect = inflateRect(inflatedRect, size, buttonMargins(controlSize));
} else
part = SafariTheme::SquareButtonPart;
paintThemePart(part, paintInfo.context->platformContext(), inflatedRect, controlSize, determineState(o));
return false;
}
LayoutUnit RenderImage::computeReplacedLogicalWidth(bool includeMaxWidth) const
{
// If we've got an explicit width/height assigned, propagate it to the image resource.
if (style()->logicalWidth().isFixed() && style()->logicalHeight().isFixed()) {
LayoutUnit width = RenderReplaced::computeReplacedLogicalWidth(includeMaxWidth);
m_imageResource->setContainerSizeForRenderer(IntSize(width, computeReplacedLogicalHeight()));
return width;
}
IntSize containerSize;
if (m_imageResource->imageHasRelativeWidth() || m_imageResource->imageHasRelativeHeight()) {
// Propagate the containing block size to the image resource, otherwhise we can't compute our own intrinsic size, if it's relative.
RenderObject* containingBlock = isPositioned() ? container() : this->containingBlock();
if (containingBlock->isBox()) {
RenderBox* box = toRenderBox(containingBlock);
containerSize = IntSize(box->availableWidth(), box->availableHeight()); // Already contains zooming information.
}
} else {
// Propagate the current zoomed image size to the image resource, otherwhise the image size will remain the same on-screen.
CachedImage* cachedImage = m_imageResource->cachedImage();
if (cachedImage && cachedImage->image()) {
containerSize = cachedImage->image()->size();
// FIXME: Remove unnecessary rounding when layout is off ints: webkit.org/b/63656
containerSize.setWidth(static_cast<LayoutUnit>(containerSize.width() * style()->effectiveZoom()));
containerSize.setHeight(static_cast<LayoutUnit>(containerSize.height() * style()->effectiveZoom()));
}
}
if (!containerSize.isEmpty()) {
m_imageResource->setContainerSizeForRenderer(containerSize);
const_cast<RenderImage*>(this)->updateIntrinsicSizeIfNeeded(containerSize, false);
}
return RenderReplaced::computeReplacedLogicalWidth(includeMaxWidth);
}
FloatSize AutoscrollController::calculateAutoscrollDelta() {
LocalFrame* frame = m_autoscrollLayoutObject->frame();
if (!frame)
return FloatSize();
IntPoint lastKnownMousePosition =
frame->eventHandler().lastKnownMousePosition();
// We need to check if the last known mouse position is out of the window.
// When the mouse is out of the window, the position is incoherent
static IntPoint previousMousePosition;
if (lastKnownMousePosition.x() < 0 || lastKnownMousePosition.y() < 0)
lastKnownMousePosition = previousMousePosition;
else
previousMousePosition = lastKnownMousePosition;
IntSize delta = lastKnownMousePosition - m_middleClickAutoscrollStartPos;
// at the center we let the space for the icon.
if (abs(delta.width()) <= noMiddleClickAutoscrollRadius)
delta.setWidth(0);
if (abs(delta.height()) <= noMiddleClickAutoscrollRadius)
delta.setHeight(0);
return FloatSize(adjustedScrollDelta(delta));
}
IntSize DrawingBuffer::adjustSize(const IntSize& size) {
IntSize adjustedSize = size;
// Clamp if the desired size is greater than the maximum texture size for the device.
if (adjustedSize.height() > m_maxTextureSize)
adjustedSize.setHeight(m_maxTextureSize);
if (adjustedSize.width() > m_maxTextureSize)
adjustedSize.setWidth(m_maxTextureSize);
// Try progressively smaller sizes until we find a size that fits or reach a scale limit.
int scaleAttempts = 0;
while ((s_currentResourceUsePixels + pixelDelta(adjustedSize)) > s_maximumResourceUsePixels) {
scaleAttempts++;
if (scaleAttempts > s_maxScaleAttempts)
return IntSize();
adjustedSize.scale(s_resourceAdjustedRatio);
if (adjustedSize.isEmpty())
return IntSize();
}
return adjustedSize;
}
IntSize ScrollView::overhangAmount() const
{
IntSize stretch;
int physicalScrollY = scrollPosition().y() + m_scrollOrigin.y();
if (physicalScrollY < 0)
stretch.setHeight(physicalScrollY);
else if (physicalScrollY > contentsHeight() - visibleContentRect().height())
stretch.setHeight(physicalScrollY - (contentsHeight() - visibleContentRect().height()));
int physicalScrollX = scrollPosition().x() + m_scrollOrigin.x();
if (physicalScrollX < 0)
stretch.setWidth(physicalScrollX);
else if (physicalScrollX > contentsWidth() - visibleContentRect().width())
stretch.setWidth(physicalScrollX - (contentsWidth() - visibleContentRect().width()));
return stretch;
}
IntSize ScrollbarGroup::contentsSize() const
{
IntSize size;
if (m_horizontalScrollbar)
size.setWidth(m_horizontalScrollbar->scrollbar()->totalSize());
else if (m_verticalScrollbar) {
size.setWidth(m_verticalScrollbar->scrollbar()->x());
if (m_verticalScrollbar->scrollbar()->isOverlayScrollbar())
size.expand(WebPluginScrollbar::defaultThickness(), 0);
}
if (m_verticalScrollbar)
size.setHeight(m_verticalScrollbar->scrollbar()->totalSize());
else if (m_horizontalScrollbar) {
size.setHeight(m_horizontalScrollbar->scrollbar()->y());
if (m_horizontalScrollbar->scrollbar()->isOverlayScrollbar())
size.expand(0, WebPluginScrollbar::defaultThickness());
}
return size;
}
PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(float sw, float sh) const
{
FloatSize unscaledSize(sw, sh);
IntSize scaledSize = m_canvas->convertLogicalToDevice(unscaledSize);
if (scaledSize.width() < 1)
scaledSize.setWidth(1);
if (scaledSize.height() < 1)
scaledSize.setHeight(1);
return createEmptyImageData(scaledSize);
}
static inline IntSize outsetSizeForBlur(float stdDeviation)
{
IntSize kernelSize = FEGaussianBlur::calculateUnscaledKernelSize(FloatPoint(stdDeviation, stdDeviation));
IntSize outset;
// We take the half kernel size and multiply it with three, because we run box blur three times.
outset.setWidth(3 * kernelSize.width() * 0.5f);
outset.setHeight(3 * kernelSize.height() * 0.5f);
return outset;
}
void LayoutThemeDefault::setRadioSize(ComputedStyle& style) const
{
// If the width and height are both specified, then we have nothing to do.
if (!style.width().isIntrinsicOrAuto() && !style.height().isAuto())
return;
IntSize size = Platform::current()->themeEngine()->getSize(WebThemeEngine::PartRadio);
float zoomLevel = style.effectiveZoom();
size.setWidth(size.width() * zoomLevel);
size.setHeight(size.height() * zoomLevel);
setSizeIfAuto(style, size);
}
void RenderThemeChromiumDefault::setRadioSize(RenderStyle* style) const
{
// If the width and height are both specified, then we have nothing to do.
if (!style->width().isIntrinsicOrAuto() && !style->height().isAuto())
return;
IntSize size = WebKit::Platform::current()->themeEngine()->getSize(WebKit::WebThemeEngine::PartRadio);
float zoomLevel = style->effectiveZoom();
size.setWidth(size.width() * zoomLevel);
size.setHeight(size.height() * zoomLevel);
setSizeIfAuto(style, size);
}
static inline IntSize outsetSizeForBlur(float stdDeviation)
{
unsigned kernelSizeX = 0;
unsigned kernelSizeY = 0;
FEGaussianBlur::calculateUnscaledKernelSize(kernelSizeX, kernelSizeY, stdDeviation, stdDeviation);
IntSize outset;
// We take the half kernel size and multiply it with three, because we run box blur three times.
outset.setWidth(3 * kernelSizeX * 0.5f);
outset.setHeight(3 * kernelSizeY * 0.5f);
return outset;
}
IntSize DrawingBuffer::adjustSize(const IntSize& desiredSize, const IntSize& curSize, int maxTextureSize)
{
IntSize adjustedSize = desiredSize;
// Clamp if the desired size is greater than the maximum texture size for the device.
if (adjustedSize.height() > maxTextureSize)
adjustedSize.setHeight(maxTextureSize);
if (adjustedSize.width() > maxTextureSize)
adjustedSize.setWidth(maxTextureSize);
return adjustedSize;
}
IntSize FEGaussianBlur::calculateUnscaledKernelSize(const FloatPoint& stdDeviation)
{
ASSERT(stdDeviation.x() >= 0 && stdDeviation.y() >= 0);
IntSize kernelSize;
if (stdDeviation.x())
kernelSize.setWidth(clampedToKernelSize(stdDeviation.x()));
if (stdDeviation.y())
kernelSize.setHeight(clampedToKernelSize(stdDeviation.y()));
return kernelSize;
}
void RenderStyle::getInnerBorderRadiiForRectWithBorderWidths(const IntRect& innerRect, unsigned short topWidth, unsigned short bottomWidth, unsigned short leftWidth, unsigned short rightWidth, IntSize& innerTopLeft, IntSize& innerTopRight, IntSize& innerBottomLeft, IntSize& innerBottomRight) const
{
innerTopLeft = IntSize(surround->border.topLeft().width().calcValue(innerRect.width()), surround->border.topLeft().height().calcValue(innerRect.height()));
innerTopRight = IntSize(surround->border.topRight().width().calcValue(innerRect.width()), surround->border.topRight().height().calcValue(innerRect.height()));
innerBottomLeft = IntSize(surround->border.bottomLeft().width().calcValue(innerRect.width()), surround->border.bottomLeft().height().calcValue(innerRect.height()));
innerBottomRight = IntSize(surround->border.bottomRight().width().calcValue(innerRect.width()), surround->border.bottomRight().height().calcValue(innerRect.height()));
innerTopLeft.setWidth(max(0, innerTopLeft.width() - leftWidth));
innerTopLeft.setHeight(max(0, innerTopLeft.height() - topWidth));
innerTopRight.setWidth(max(0, innerTopRight.width() - rightWidth));
innerTopRight.setHeight(max(0, innerTopRight.height() - topWidth));
innerBottomLeft.setWidth(max(0, innerBottomLeft.width() - leftWidth));
innerBottomLeft.setHeight(max(0, innerBottomLeft.height() - bottomWidth));
innerBottomRight.setWidth(max(0, innerBottomRight.width() - rightWidth));
innerBottomRight.setHeight(max(0, innerBottomRight.height() - bottomWidth));
constrainCornerRadiiForRect(innerRect, innerTopLeft, innerTopRight, innerBottomLeft, innerBottomRight);
}
ViewportAttributes computeViewportAttributes(ViewportArguments args, int desktopWidth, int deviceWidth, int deviceHeight, float devicePixelRatio, IntSize visibleViewport)
{
#if PLATFORM(IOS)
// FIXME: This should probably be fixed elsewhere on iOS. iOS may only use computeViewportAttributes for tests.
CGSize screenSize = wkGetViewportScreenSize();
visibleViewport.setWidth(screenSize.width);
visibleViewport.setHeight(screenSize.height);
#endif
FloatSize initialViewportSize = convertToUserSpace(visibleViewport, devicePixelRatio);
FloatSize deviceSize = convertToUserSpace(FloatSize(deviceWidth, deviceHeight), devicePixelRatio);
return args.resolve(initialViewportSize, deviceSize, desktopWidth);
}
void clampImageBufferSizeToViewport(FrameView* frameView, IntSize& size)
{
if (!frameView)
return;
int viewWidth = frameView->visibleWidth();
int viewHeight = frameView->visibleHeight();
if (size.width() > viewWidth)
size.setWidth(viewWidth);
if (size.height() > viewHeight)
size.setHeight(viewHeight);
}
void ScrollView::setScrollOffset(const IntPoint& offset)
{
int horizontalOffset = offset.x();
int verticalOffset = offset.y();
if (constrainsScrollingToContentEdge()) {
horizontalOffset = max(min(horizontalOffset, contentsWidth() - visibleWidth()), 0);
verticalOffset = max(min(verticalOffset, contentsHeight() - visibleHeight()), 0);
}
IntSize newOffset = m_scrollOffset;
newOffset.setWidth(horizontalOffset - m_scrollOrigin.x());
newOffset.setHeight(verticalOffset - m_scrollOrigin.y());
scrollTo(newOffset);
}
PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionCode& ec) const
{
ec = 0;
if (!isfinite(sw) || !isfinite(sh)) {
ec = NOT_SUPPORTED_ERR;
return 0;
}
FloatSize unscaledSize(sw, sh);
IntSize scaledSize = canvas()->convertLogicalToDevice(unscaledSize);
if (scaledSize.width() < 1)
scaledSize.setWidth(1);
if (scaledSize.height() < 1)
scaledSize.setHeight(1);
return createEmptyImageData(scaledSize);
}
bool RenderThemeSafari::paintMenuList(RenderObject* o, const PaintInfo& info, const IntRect& r)
{
ASSERT(SafariThemeLibrary());
NSControlSize controlSize = controlSizeFromRect(r, popupButtonSizes());
IntRect inflatedRect = r;
IntSize size = popupButtonSizes()[controlSize];
size.setWidth(r.width());
// Now inflate it to account for the shadow.
if (r.width() >= minimumMenuListSize(o->style()))
inflatedRect = inflateRect(inflatedRect, size, popupButtonMargins(controlSize));
paintThemePart(DropDownButtonPart, info.context->platformContext(), inflatedRect, controlSize, determineState(o));
return false;
}
void clampImageBufferSizeToViewport(RenderObject* object, IntSize& size)
{
if (!object || !object->isRenderView())
return;
RenderView* view = static_cast<RenderView*>(object);
if (!view->frameView())
return;
int viewWidth = view->frameView()->visibleWidth();
int viewHeight = view->frameView()->visibleHeight();
if (size.width() > viewWidth)
size.setWidth(viewWidth);
if (size.height() > viewHeight)
size.setHeight(viewHeight);
}
IntSize FEGaussianBlur::calculateUnscaledKernelSize(const FloatPoint& std)
{
ASSERT(std.x() >= 0 && std.y() >= 0);
IntSize kernelSize;
// Limit the kernel size to 1000. A bigger radius won't make a big difference for the result image but
// inflates the absolute paint rect to much. This is compatible with Firefox' behavior.
if (std.x()) {
int size = std::max<unsigned>(2, static_cast<unsigned>(floorf(std.x() * gaussianKernelFactor() + 0.5f)));
kernelSize.setWidth(std::min(size, gMaxKernelSize));
}
if (std.y()) {
int size = std::max<unsigned>(2, static_cast<unsigned>(floorf(std.y() * gaussianKernelFactor() + 0.5f)));
kernelSize.setHeight(std::min(size, gMaxKernelSize));
}
return kernelSize;
}
IntSize ScrollAnchor::computeAdjustment() const {
// The anchor node can report fractional positions, but it is DIP-snapped when
// painting (crbug.com/610805), so we must round the offsets to determine the
// visual delta. If we scroll by the delta in LayoutUnits, the snapping of the
// anchor node may round differently from the snapping of the scroll position.
// (For example, anchor moving from 2.4px -> 2.6px is really 2px -> 3px, so we
// should scroll by 1px instead of 0.2px.) This is true regardless of whether
// the ScrollableArea actually uses fractional scroll positions.
IntSize delta = roundedIntSize(computeRelativeOffset(m_anchorObject,
m_scroller, m_corner)) -
roundedIntSize(m_savedRelativeOffset);
// Only adjust on the block layout axis.
if (scrollerLayoutBox(m_scroller)->isHorizontalWritingMode())
delta.setWidth(0);
else
delta.setHeight(0);
return delta;
}
void RenderTheme::adjustRadioStyleUsingFallbackTheme(RenderStyle* style, Element*) const
{
// If the width and height are both specified, then we have nothing to do.
if (!style->width().isIntrinsicOrAuto() && !style->height().isAuto())
return;
IntSize size = WebKit::Platform::current()->fallbackThemeEngine()->getSize(WebKit::WebFallbackThemeEngine::PartRadio);
float zoomLevel = style->effectiveZoom();
size.setWidth(size.width() * zoomLevel);
size.setHeight(size.height() * zoomLevel);
setSizeIfAuto(style, size);
// padding - not honored by WinIE, needs to be removed.
style->resetPadding();
// border - honored by WinIE, but looks terrible (just paints in the control box and turns off the Windows XP theme)
// for now, we will not honor it.
style->resetBorder();
}
void ScrollView::valueChanged(Scrollbar* scrollbar)
{
// Figure out if we really moved.
IntSize newOffset = m_scrollOffset;
if (scrollbar) {
if (scrollbar->orientation() == HorizontalScrollbar)
newOffset.setWidth(scrollbar->value());
else if (scrollbar->orientation() == VerticalScrollbar)
newOffset.setHeight(scrollbar->value());
}
IntSize scrollDelta = newOffset - m_scrollOffset;
if (scrollDelta == IntSize())
return;
m_scrollOffset = newOffset;
if (scrollbarsSuppressed())
return;
scrollContents(scrollDelta);
}
void Gradient::adjustParametersForTiledDrawing(IntSize& size, FloatRect& srcRect)
{
if (m_radial)
return;
if (srcRect.isEmpty())
return;
if (m_p0.x() == m_p1.x()) {
size.setWidth(1);
srcRect.setWidth(1);
srcRect.setX(0);
return;
}
if (m_p0.y() != m_p1.y())
return;
size.setHeight(1);
srcRect.setHeight(1);
srcRect.setY(0);
}
static void adjustmentChanged(GtkAdjustment* adjustment, gpointer _that)
{
ScrollView* that = reinterpret_cast<ScrollView*>(_that);
// Figure out if we really moved.
IntSize newOffset = that->scrollOffset();
if (adjustment == that->m_horizontalAdjustment)
newOffset.setWidth(static_cast<int>(gtk_adjustment_get_value(adjustment)));
else if (adjustment == that->m_verticalAdjustment)
newOffset.setHeight(static_cast<int>(gtk_adjustment_get_value(adjustment)));
IntSize scrollDelta = newOffset - that->scrollOffset();
if (scrollDelta == IntSize())
return;
that->setScrollOffset(newOffset);
if (that->scrollbarsSuppressed())
return;
that->scrollContents(scrollDelta);
}