void WebPagePopupImpl::resize(const WebSize& newSize)
{
m_windowRectInScreen = WebRect(m_windowRectInScreen.x, m_windowRectInScreen.y, newSize.width, newSize.height);
m_widgetClient->setWindowRect(m_windowRectInScreen);
if (m_page) {
toLocalFrame(m_page->mainFrame())->view()->resize(newSize);
m_page->frameHost().visualViewport().setSize(newSize);
}
m_widgetClient->didInvalidateRect(WebRect(0, 0, newSize.width, newSize.height));
}
// FIXME: Take an X window and use XRandR to find the dimensions of the monitor
// that it's on (probably using XRRGetScreenInfo() and XRRConfigSizes() from
// X11/extensions/Xrandr.h). GDK provides a gdk_screen_get_monitor_geometry()
// function, but it appears to return stale data after the screen is resized.
WebScreenInfo WebScreenInfoFactory::screenInfo(Display* display, int screenNumber)
{
// XDisplayWidth() and XDisplayHeight() return cached values. To ensure that
// we return the correct dimensions after the screen is resized, query the
// root window's geometry each time.
Window root = RootWindow(display, screenNumber);
Window rootRet;
int x, y;
unsigned int width, height, border, depth;
XGetGeometry(
display, root, &rootRet, &x, &y, &width, &height, &border, &depth);
WebScreenInfo results;
// FIXME: Initialize the device scale factor.
// FIXME: Not all screens use 8bpp.
results.depthPerComponent = 8;
results.depth = depth;
results.isMonochrome = depth == 1;
results.rect = WebRect(x, y, width, height);
// FIXME: Query the _NET_WORKAREA property from EWMH.
results.availableRect = results.rect;
return results;
}
bool ThemePainterDefault::paintSliderThumb(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
WebThemeEngine::ExtraParams extraParams;
WebCanvas* canvas = i.context.canvas();
extraParams.slider.vertical =
o.styleRef().appearance() == SliderThumbVerticalPart;
extraParams.slider.inDrag = LayoutTheme::isPressed(o);
// FIXME: Mock theme doesn't handle zoomed sliders.
float zoomLevel = useMockTheme() ? 1 : o.styleRef().effectiveZoom();
GraphicsContextStateSaver stateSaver(i.context, false);
IntRect unzoomedRect = rect;
if (zoomLevel != 1) {
stateSaver.save();
unzoomedRect.setWidth(unzoomedRect.width() / zoomLevel);
unzoomedRect.setHeight(unzoomedRect.height() / zoomLevel);
i.context.translate(unzoomedRect.x(), unzoomedRect.y());
i.context.scale(zoomLevel, zoomLevel);
i.context.translate(-unzoomedRect.x(), -unzoomedRect.y());
}
Platform::current()->themeEngine()->paint(
canvas, WebThemeEngine::PartSliderThumb, getWebThemeState(o),
WebRect(unzoomedRect), &extraParams);
return false;
}
bool ThemePainterDefault::paintMenuList(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
if (!o.isBox())
return false;
WebThemeEngine::ExtraParams extraParams;
const LayoutBox& box = toLayoutBox(o);
// Match Chromium Win behaviour of showing all borders if any are shown.
extraParams.menuList.hasBorder = box.borderRight() || box.borderLeft() ||
box.borderTop() || box.borderBottom();
extraParams.menuList.hasBorderRadius = o.styleRef().hasBorderRadius();
// Fallback to transparent if the specified color object is invalid.
Color backgroundColor(Color::transparent);
if (o.styleRef().hasBackground())
backgroundColor = o.resolveColor(CSSPropertyBackgroundColor);
extraParams.menuList.backgroundColor = backgroundColor.rgb();
// If we have a background image, don't fill the content area to expose the
// parent's background. Also, we shouldn't fill the content area if the
// alpha of the color is 0. The API of Windows GDI ignores the alpha.
// FIXME: the normal Aura theme doesn't care about this, so we should
// investigate if we really need fillContentArea.
extraParams.menuList.fillContentArea =
!o.styleRef().hasBackgroundImage() && backgroundColor.alpha();
setupMenuListArrow(box, rect, extraParams);
WebCanvas* canvas = i.context.canvas();
Platform::current()->themeEngine()->paint(
canvas, WebThemeEngine::PartMenuList, getWebThemeState(o), WebRect(rect),
&extraParams);
return false;
}
void ScrollbarThemeAura::paintTrackPiece(GraphicsContext& gc,
const Scrollbar& scrollbar,
const IntRect& rect,
ScrollbarPart partType) {
DisplayItem::Type displayItemType = trackPiecePartToDisplayItemType(partType);
if (DrawingRecorder::useCachedDrawingIfPossible(gc, scrollbar,
displayItemType))
return;
DrawingRecorder recorder(gc, scrollbar, displayItemType, rect);
WebThemeEngine::State state = scrollbar.hoveredPart() == partType
? WebThemeEngine::StateHover
: WebThemeEngine::StateNormal;
if (useMockTheme() && !scrollbar.enabled())
state = WebThemeEngine::StateDisabled;
IntRect alignRect = trackRect(scrollbar, false);
WebThemeEngine::ExtraParams extraParams;
extraParams.scrollbarTrack.isBack = (partType == BackTrackPart);
extraParams.scrollbarTrack.trackX = alignRect.x();
extraParams.scrollbarTrack.trackY = alignRect.y();
extraParams.scrollbarTrack.trackWidth = alignRect.width();
extraParams.scrollbarTrack.trackHeight = alignRect.height();
Platform::current()->themeEngine()->paint(
gc.canvas(), scrollbar.orientation() == HorizontalScrollbar
? WebThemeEngine::PartScrollbarHorizontalTrack
: WebThemeEngine::PartScrollbarVerticalTrack,
state, WebRect(rect), &extraParams);
}
bool ThemePainterDefault::paintCheckbox(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
WebThemeEngine::ExtraParams extraParams;
WebCanvas* canvas = i.context.canvas();
extraParams.button.checked = LayoutTheme::isChecked(o);
extraParams.button.indeterminate = LayoutTheme::isIndeterminate(o);
float zoomLevel = o.styleRef().effectiveZoom();
GraphicsContextStateSaver stateSaver(i.context, false);
IntRect unzoomedRect = rect;
if (zoomLevel != 1) {
stateSaver.save();
unzoomedRect.setWidth(unzoomedRect.width() / zoomLevel);
unzoomedRect.setHeight(unzoomedRect.height() / zoomLevel);
i.context.translate(unzoomedRect.x(), unzoomedRect.y());
i.context.scale(zoomLevel, zoomLevel);
i.context.translate(-unzoomedRect.x(), -unzoomedRect.y());
}
Platform::current()->themeEngine()->paint(
canvas, WebThemeEngine::PartCheckbox, getWebThemeState(o),
WebRect(unzoomedRect), &extraParams);
return false;
}
void ScrollbarThemeOverlay::paintThumb(GraphicsContext& context, const ScrollbarThemeClient& scrollbar, const IntRect& rect)
{
if (DrawingRecorder::useCachedDrawingIfPossible(context, scrollbar, DisplayItem::ScrollbarThumb))
return;
DrawingRecorder recorder(context, scrollbar, DisplayItem::ScrollbarThumb, rect);
IntRect thumbRect = rect;
if (scrollbar.orientation() == HorizontalScrollbar) {
thumbRect.setHeight(thumbRect.height() - m_scrollbarMargin);
} else {
thumbRect.setWidth(thumbRect.width() - m_scrollbarMargin);
if (scrollbar.isLeftSideVerticalScrollbar())
thumbRect.setX(thumbRect.x() + m_scrollbarMargin);
}
if (m_useSolidColor) {
context.fillRect(thumbRect, m_color);
return;
}
WebThemeEngine::State state = WebThemeEngine::StateNormal;
if (scrollbar.pressedPart() == ThumbPart)
state = WebThemeEngine::StatePressed;
else if (scrollbar.hoveredPart() == ThumbPart)
state = WebThemeEngine::StateHover;
WebCanvas* canvas = context.canvas();
WebThemeEngine::Part part = WebThemeEngine::PartScrollbarHorizontalThumb;
if (scrollbar.orientation() == VerticalScrollbar)
part = WebThemeEngine::PartScrollbarVerticalThumb;
Platform::current()->themeEngine()->paint(canvas, part, state, WebRect(rect), 0);
}
WebRect WebFloatQuad::enclosingRect() const
{
int left = static_cast<int>(floorf(std::min(std::min(std::min(p[0].x, p[1].x), p[2].x), p[3].x)));
int top = static_cast<int>(floorf(std::min(std::min(std::min(p[0].y, p[1].y), p[2].y), p[3].y)));
int right = static_cast<int>(ceilf(std::max(std::max(std::max(p[0].x, p[1].x), p[2].x), p[3].x)));
int bottom = static_cast<int>(ceilf(std::max(std::max(std::max(p[0].y, p[1].y), p[2].y), p[3].y)));
return WebRect(left, top, right - left, bottom - top);
}
WebRect WebFontImpl::estimateTextBounds(const WebTextRun& run, const WebFloatPoint& leftBaseline) const
{
FontCachePurgePreventer fontCachePurgePreventer;
int totalWidth = m_font.width(run, 0);
const WebCore::FontMetrics& fontMetrics = m_font.fontMetrics();
return WebRect(leftBaseline.x - (fontMetrics.ascent() + fontMetrics.descent()) / 2,
leftBaseline.y - fontMetrics.ascent() - fontMetrics.lineGap(),
totalWidth + fontMetrics.ascent() + fontMetrics.descent(),
fontMetrics.lineSpacing());
}
void WebContentLayerImpl::paintContents(GraphicsContext& gc, const IntRect& clip)
{
if (!m_contentClient)
return;
#if WEBKIT_USING_SKIA
WebCanvas* canvas = gc.platformContext()->canvas();
#elif WEBKIT_USING_CG
WebCanvas* canvas = gc.platformContext();
#endif
m_contentClient->paintContents(canvas, WebRect(clip));
}
void WebViewBenchmarkSupportImpl::softwarePaint(PaintClient* paintClient, PaintMode paintMode)
{
WebSize size = m_webViewImpl->size();
WebRect paintSize;
switch (paintMode) {
case PaintModeEverything:
if (m_webViewImpl->page() && m_webViewImpl->page()->mainFrame()) {
FrameView* view = m_webViewImpl->page()->mainFrame()->view();
IntSize contentsSize = view->contentsSize();
paintSize = WebRect(0, 0, contentsSize.width(), contentsSize.height());
} else
paintSize = WebRect(0, 0, size.width, size.height);
break;
}
WebSize canvasSize(paintSize.width, paintSize.height);
WebCanvas* canvas = paintClient->willPaint(canvasSize);
m_webViewImpl->paint(canvas, paintSize);
paintClient->didPaint(canvas);
}
void WebPluginScrollbarImpl::setLocation(const WebRect& rect)
{
IntRect oldRect = m_scrollbar->frameRect();
m_scrollbar->setFrameRect(rect);
if (WebRect(oldRect) != rect)
m_scrollbar->invalidate();
int length = m_scrollbar->orientation() == HorizontalScrollbar ? m_scrollbar->width() : m_scrollbar->height();
m_scrollbar->setEnabled(m_scrollbar->totalSize() > length);
m_scrollbar->setProportion(length, m_scrollbar->totalSize());
}
bool ThemePainterDefault::paintRadio(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
WebThemeEngine::ExtraParams extraParams;
WebCanvas* canvas = i.context.canvas();
extraParams.button.checked = LayoutTheme::isChecked(o);
Platform::current()->themeEngine()->paint(canvas, WebThemeEngine::PartRadio,
getWebThemeState(o), WebRect(rect),
&extraParams);
return false;
}
void WebScrollbarImpl::setLocation(const WebRect& rect)
{
WebCore::IntRect oldRect = m_scrollbar->frameRect();
m_scrollbar->setFrameRect(rect);
if (WebRect(oldRect) != rect)
m_scrollbar->invalidate();
int length = m_scrollbar->orientation() == HorizontalScrollbar ? m_scrollbar->width() : m_scrollbar->height();
int pageStep = max(max<int>(length * Scrollbar::minFractionToStepWhenPaging(), length - Scrollbar::maxOverlapBetweenPages()), 1);
m_scrollbar->setSteps(Scrollbar::pixelsPerLineStep(), pageStep);
m_scrollbar->setEnabled(m_scrollbar->totalSize() > length);
m_scrollbar->setProportion(length, m_scrollbar->totalSize());
}
static void paintLayers(PaintLayer& layer, SimDisplayItemList& displayList)
{
if (layer.isAllowedToQueryCompositingState() && layer.compositingState() == PaintsIntoOwnBacking) {
CompositedLayerMapping* mapping = layer.compositedLayerMapping();
GraphicsLayer* graphicsLayer = mapping->mainGraphicsLayer();
if (graphicsLayer->hasTrackedPaintInvalidations()) {
ContentLayerDelegate* delegate = graphicsLayer->contentLayerDelegateForTesting();
delegate->paintContents(&displayList, WebRect(0, 0, layer.size().width(), layer.size().height()));
graphicsLayer->resetTrackedPaintInvalidations();
}
}
for (PaintLayer* child = layer.firstChild(); child; child = child->nextSibling())
paintLayers(*child, displayList);
}
static void paintArtifactToWebDisplayItemList(WebDisplayItemList* list, const PaintArtifact& artifact, const gfx::Rect& bounds)
{
if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
// This is a temporary path to paint the artifact using the paint chunk
// properties. Ultimately, we should instead split the artifact into
// separate layers and send those to the compositor, instead of sending
// one big flat SkPicture.
SkRect skBounds = SkRect::MakeXYWH(bounds.x(), bounds.y(), bounds.width(), bounds.height());
RefPtr<SkPicture> picture = paintArtifactToSkPicture(artifact, skBounds);
list->appendDrawingItem(WebRect(bounds.x(), bounds.y(), bounds.width(), bounds.height()), picture.get());
return;
}
artifact.appendToWebDisplayItemList(list);
}
bool ThemePainterDefault::paintInnerSpinButton(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
WebThemeEngine::ExtraParams extraParams;
WebCanvas* canvas = i.context.canvas();
extraParams.innerSpin.spinUp =
(LayoutTheme::controlStatesForLayoutObject(o) & SpinUpControlState);
extraParams.innerSpin.readOnly = LayoutTheme::isReadOnlyControl(o);
Platform::current()->themeEngine()->paint(
canvas, WebThemeEngine::PartInnerSpinButton, getWebThemeState(o),
WebRect(rect), &extraParams);
return false;
}
void ScrollbarThemeAura::paintButton(GraphicsContext& gc,
const Scrollbar& scrollbar,
const IntRect& rect,
ScrollbarPart part) {
DisplayItem::Type displayItemType = buttonPartToDisplayItemType(part);
if (DrawingRecorder::useCachedDrawingIfPossible(gc, scrollbar,
displayItemType))
return;
PartPaintingParams params =
buttonPartPaintingParams(scrollbar, scrollbar.currentPos(), part);
if (!params.shouldPaint)
return;
DrawingRecorder recorder(gc, scrollbar, displayItemType, rect);
Platform::current()->themeEngine()->paint(
gc.canvas(), params.part, params.state, WebRect(rect), nullptr);
}
bool ThemePainterDefault::paintButton(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
WebThemeEngine::ExtraParams extraParams;
WebCanvas* canvas = i.context.canvas();
extraParams.button.hasBorder = true;
extraParams.button.backgroundColor =
useMockTheme() ? 0xffc0c0c0 : defaultButtonBackgroundColor;
if (o.styleRef().hasBackground())
extraParams.button.backgroundColor =
o.resolveColor(CSSPropertyBackgroundColor).rgb();
Platform::current()->themeEngine()->paint(canvas, WebThemeEngine::PartButton,
getWebThemeState(o), WebRect(rect),
&extraParams);
return false;
}
void AccessibilityUIElement::scrollToMakeVisibleWithSubFocusCallback(const CppArgumentList& arguments, CppVariant* result)
{
result->setNull();
if (arguments.size() != 4
|| !arguments[0].isNumber()
|| !arguments[1].isNumber()
|| !arguments[2].isNumber()
|| !arguments[3].isNumber())
return;
int x = arguments[0].toInt32();
int y = arguments[1].toInt32();
int width = arguments[2].toInt32();
int height = arguments[3].toInt32();
accessibilityObject().scrollToMakeVisibleWithSubFocus(WebRect(x, y, width, height));
result->setNull();
}
void LinkHighlightImpl::paintContents(WebDisplayItemList* webDisplayItemList, WebContentLayerClient::PaintingControlSetting paintingControl)
{
if (!m_node || !m_node->layoutObject())
return;
SkPictureRecorder recorder;
gfx::Rect visualRect = paintableRegion();
SkCanvas* canvas = recorder.beginRecording(visualRect.width(), visualRect.height());
SkPaint paint;
paint.setStyle(SkPaint::kFill_Style);
paint.setFlags(SkPaint::kAntiAlias_Flag);
paint.setColor(m_node->layoutObject()->style()->tapHighlightColor().rgb());
canvas->drawPath(m_path.getSkPath(), paint);
webDisplayItemList->appendDrawingItem(WebRect(visualRect.x(), visualRect.y(),
visualRect.width(), visualRect.height()), recorder.finishRecordingAsPicture());
}
bool ThemePainterDefault::paintMenuListButton(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
if (!o.isBox())
return false;
WebThemeEngine::ExtraParams extraParams;
extraParams.menuList.hasBorder = false;
extraParams.menuList.hasBorderRadius = o.styleRef().hasBorderRadius();
extraParams.menuList.backgroundColor = Color::transparent;
extraParams.menuList.fillContentArea = false;
setupMenuListArrow(toLayoutBox(o), rect, extraParams);
WebCanvas* canvas = i.context.canvas();
Platform::current()->themeEngine()->paint(
canvas, WebThemeEngine::PartMenuList, getWebThemeState(o), WebRect(rect),
&extraParams);
return false;
}
void WebPagePopupImpl::resize(const WebSize& newSizeInViewport) {
WebRect newSize(0, 0, newSizeInViewport.width, newSizeInViewport.height);
widgetClient()->convertViewportToWindow(&newSize);
WebRect windowRect = windowRectInScreen();
// TODO(bokan): We should only call into this if the bounds actually changed
// but this reveals a bug in Aura. crbug.com/633140.
windowRect.width = newSize.width;
windowRect.height = newSize.height;
setWindowRect(windowRect);
if (m_page) {
toLocalFrame(m_page->mainFrame())->view()->resize(newSizeInViewport);
m_page->frameHost().visualViewport().setSize(newSizeInViewport);
}
m_widgetClient->didInvalidateRect(
WebRect(0, 0, newSize.width, newSize.height));
}
void ScrollbarTheme::paintScrollCorner(
GraphicsContext& context,
const DisplayItemClient& displayItemClient,
const IntRect& cornerRect) {
if (cornerRect.isEmpty())
return;
if (DrawingRecorder::useCachedDrawingIfPossible(
context, displayItemClient, DisplayItem::kScrollbarCorner))
return;
DrawingRecorder recorder(context, displayItemClient,
DisplayItem::kScrollbarCorner, cornerRect);
#if OS(MACOSX)
context.fillRect(cornerRect, Color::white);
#else
Platform::current()->themeEngine()->paint(
context.canvas(), WebThemeEngine::PartScrollbarCorner,
WebThemeEngine::StateNormal, WebRect(cornerRect), 0);
#endif
}
bool ThemePainterDefault::paintProgressBar(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
if (!o.isProgress())
return true;
const LayoutProgress& layoutProgress = toLayoutProgress(o);
IntRect valueRect = progressValueRectFor(layoutProgress, rect);
WebThemeEngine::ExtraParams extraParams;
extraParams.progressBar.determinate = layoutProgress.isDeterminate();
extraParams.progressBar.valueRectX = valueRect.x();
extraParams.progressBar.valueRectY = valueRect.y();
extraParams.progressBar.valueRectWidth = valueRect.width();
extraParams.progressBar.valueRectHeight = valueRect.height();
DirectionFlippingScope scope(o, i, rect);
WebCanvas* canvas = i.context.canvas();
Platform::current()->themeEngine()->paint(
canvas, WebThemeEngine::PartProgressBar, getWebThemeState(o),
WebRect(rect), &extraParams);
return false;
}
void ScrollbarThemeAura::paintThumb(GraphicsContext& gc,
const Scrollbar& scrollbar,
const IntRect& rect) {
if (DrawingRecorder::useCachedDrawingIfPossible(gc, scrollbar,
DisplayItem::kScrollbarThumb))
return;
DrawingRecorder recorder(gc, scrollbar, DisplayItem::kScrollbarThumb, rect);
WebThemeEngine::State state;
WebCanvas* canvas = gc.canvas();
if (scrollbar.pressedPart() == ThumbPart)
state = WebThemeEngine::StatePressed;
else if (scrollbar.hoveredPart() == ThumbPart)
state = WebThemeEngine::StateHover;
else
state = WebThemeEngine::StateNormal;
Platform::current()->themeEngine()->paint(
canvas, scrollbar.orientation() == HorizontalScrollbar
? WebThemeEngine::PartScrollbarHorizontalThumb
: WebThemeEngine::PartScrollbarVerticalThumb,
state, WebRect(rect), nullptr);
}
bool ThemePainterDefault::paintTextField(const LayoutObject& o,
const PaintInfo& i,
const IntRect& rect) {
// WebThemeEngine does not handle border rounded corner and background image
// so return true to draw CSS border and background.
if (o.styleRef().hasBorderRadius() || o.styleRef().hasBackgroundImage())
return true;
ControlPart part = o.styleRef().appearance();
WebThemeEngine::ExtraParams extraParams;
extraParams.textField.isTextArea = part == TextAreaPart;
extraParams.textField.isListbox = part == ListboxPart;
WebCanvas* canvas = i.context.canvas();
Color backgroundColor = o.resolveColor(CSSPropertyBackgroundColor);
extraParams.textField.backgroundColor = backgroundColor.rgb();
Platform::current()->themeEngine()->paint(
canvas, WebThemeEngine::PartTextField, getWebThemeState(o), WebRect(rect),
&extraParams);
return false;
}
WebRect WebRemoteFrameImpl::selectionBoundsRect() const
{
ASSERT_NOT_REACHED();
return WebRect();
}
WebRect WebRemoteFrameImpl::visibleContentRect() const
{
ASSERT_NOT_REACHED();
return WebRect();
}
