void InspectorOverlay::drawNodeHighlight()
{
if (!m_highlightNode)
return;
Highlight highlight;
buildNodeHighlight(m_highlightNode.get(), m_nodeHighlightConfig, &highlight);
RefPtr<InspectorObject> highlightObject = buildObjectForHighlight(m_page->mainFrame()->view(), highlight);
Node* node = m_highlightNode.get();
if (node->isElementNode() && m_nodeHighlightConfig.showInfo && node->renderer() && node->document()->frame()) {
RefPtr<InspectorObject> elementInfo = InspectorObject::create();
Element* element = toElement(node);
bool isXHTML = element->document()->isXHTMLDocument();
elementInfo->setString("tagName", isXHTML ? element->nodeName() : element->nodeName().lower());
elementInfo->setString("idValue", element->getIdAttribute());
HashSet<AtomicString> usedClassNames;
if (element->hasClass() && element->isStyledElement()) {
StringBuilder classNames;
const SpaceSplitString& classNamesString = static_cast<StyledElement*>(element)->classNames();
size_t classNameCount = classNamesString.size();
for (size_t i = 0; i < classNameCount; ++i) {
const AtomicString& className = classNamesString[i];
if (usedClassNames.contains(className))
continue;
usedClassNames.add(className);
classNames.append('.');
classNames.append(className);
}
elementInfo->setString("className", classNames.toString());
}
RenderObject* renderer = node->renderer();
Frame* containingFrame = node->document()->frame();
FrameView* containingView = containingFrame->view();
IntRect boundingBox = pixelSnappedIntRect(containingView->contentsToRootView(renderer->absoluteBoundingBoxRect()));
RenderBoxModelObject* modelObject = renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : 0;
elementInfo->setString("nodeWidth", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetWidth(), modelObject) : boundingBox.width()));
elementInfo->setString("nodeHeight", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetHeight(), modelObject) : boundingBox.height()));
highlightObject->setObject("elementInfo", elementInfo.release());
}
evaluateInOverlay("drawNodeHighlight", highlightObject);
}
void EventTargetNode::dispatchWheelEvent(PlatformWheelEvent& e)
{
ASSERT(!eventDispatchForbidden());
if (e.deltaX() == 0 && e.deltaY() == 0)
return;
FrameView* view = document()->view();
if (!view)
return;
IntPoint pos = view->windowToContents(e.pos());
RefPtr<WheelEvent> we = WheelEvent::create(e.deltaX(), e.deltaY(),
document()->defaultView(), e.globalX(), e.globalY(), pos.x(), pos.y(),
e.ctrlKey(), e.altKey(), e.shiftKey(), e.metaKey());
ExceptionCode ec = 0;
if (!dispatchEvent(we.release(), ec, true))
e.accept();
}
HRESULT DOMHTMLInputElement::rectOnScreen(_Out_ LPRECT rect)
{
if (!rect)
return E_POINTER;
ASSERT(is<HTMLInputElement>(m_element));
rect->left = rect->top = rect->right = rect->bottom = 0;
RenderObject* renderer = m_element->renderer();
FrameView* view = m_element->document().view();
if (!renderer || !view)
return E_FAIL;
IntRect coreRect = view->contentsToScreen(renderer->absoluteBoundingBoxRect());
rect->left = coreRect.x();
rect->top = coreRect.y();
rect->right = coreRect.maxX();
rect->bottom = coreRect.maxY();
return S_OK;
}
void ChromeClientImpl::scheduleAnimation(Widget* widget)
{
ASSERT(widget->isFrameView());
FrameView* view = toFrameView(widget);
LocalFrame* frame = view->frame().localFrameRoot();
// If the frame is still being created, it might not yet have a WebWidget.
// FIXME: Is this the right thing to do? Is there a way to avoid having
// a local frame root that doesn't have a WebWidget? During initialization
// there is no content to draw so this call serves no purpose.
if (WebLocalFrameImpl::fromFrame(frame) && WebLocalFrameImpl::fromFrame(frame)->frameWidget()) {
WebLocalFrameImpl::fromFrame(frame)->frameWidget()->scheduleAnimation();
} else {
// TODO(lfg): We need to keep this for now because we still have some
// WebViews who don't have a WebViewFrameWidget. This should be
// removed once the WebViewFrameWidget refactor is complete.
m_webView->scheduleAnimation();
}
}
HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::rectOnScreen(
/* [retval][out] */ LPRECT rect)
{
ASSERT(m_element);
ASSERT(isHTMLInputElement(m_element));
rect->left = rect->top = rect->right = rect->bottom = 0;
RenderObject* renderer = m_element->renderer();
FrameView* view = m_element->document().view();
if (!renderer || !view)
return E_FAIL;
IntRect coreRect = view->contentsToScreen(renderer->absoluteBoundingBoxRect());
rect->left = coreRect.x();
rect->top = coreRect.y();
rect->right = coreRect.maxX();
rect->bottom = coreRect.maxY();
return S_OK;
}
HitTestResult hitTestInDocument(const Document* document, int x, int y)
{
LocalFrame* frame = document->frame();
if (!frame)
return HitTestResult();
FrameView* frameView = frame->view();
if (!frameView)
return HitTestResult();
IntPoint point(x, y);
if (!frameView->visibleContentRect().contains(point))
return HitTestResult();
HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
HitTestResult result(point);
document->renderView()->hitTest(request, result);
return result;
}
TEST_F(ScrollingCoordinatorTest, iframeScrolling)
{
registerMockedHttpURLLoad("iframe-scrolling.html");
registerMockedHttpURLLoad("iframe-scrolling-inner.html");
navigateTo(m_baseURL + "iframe-scrolling.html");
forceFullCompositingUpdate();
// Verify the properties of the accelerated scrolling element starting from the LayoutObject
// all the way to the WebLayer.
Element* scrollableFrame = frame()->document()->getElementById("scrollable");
ASSERT_TRUE(scrollableFrame);
LayoutObject* layoutObject = scrollableFrame->layoutObject();
ASSERT_TRUE(layoutObject);
ASSERT_TRUE(layoutObject->isLayoutPart());
LayoutPart* layoutPart = toLayoutPart(layoutObject);
ASSERT_TRUE(layoutPart);
ASSERT_TRUE(layoutPart->widget());
ASSERT_TRUE(layoutPart->widget()->isFrameView());
FrameView* innerFrameView = toFrameView(layoutPart->widget());
LayoutView* innerLayoutView = innerFrameView->layoutView();
ASSERT_TRUE(innerLayoutView);
PaintLayerCompositor* innerCompositor = innerLayoutView->compositor();
ASSERT_TRUE(innerCompositor->inCompositingMode());
ASSERT_TRUE(innerCompositor->scrollLayer());
GraphicsLayer* scrollLayer = innerCompositor->scrollLayer();
ASSERT_EQ(innerFrameView, scrollLayer->scrollableArea());
WebLayer* webScrollLayer = scrollLayer->platformLayer();
ASSERT_TRUE(webScrollLayer->scrollable());
#if OS(ANDROID)
// Now verify we've attached impl-side scrollbars onto the scrollbar layers
ASSERT_TRUE(innerCompositor->layerForHorizontalScrollbar());
ASSERT_TRUE(innerCompositor->layerForHorizontalScrollbar()->hasContentsLayer());
ASSERT_TRUE(innerCompositor->layerForVerticalScrollbar());
ASSERT_TRUE(innerCompositor->layerForVerticalScrollbar()->hasContentsLayer());
#endif
}
TEST_F(ScrollingCoordinatorTest, fractionalScrollingNonLayerFixedPosition)
{
registerMockedHttpURLLoad("fractional-scroll-fixed-position.html");
navigateTo(m_baseURL + "fractional-scroll-fixed-position.html");
// Prevent fixed-position element from getting its own layer.
webViewImpl()->settings()->setPreferCompositingToLCDTextEnabled(false);
forceFullCompositingUpdate();
FrameView* frameView = frame()->view();
frameView->scrollTo(DoublePoint(1.5, 1.5));
WebLayer* rootScrollLayer = getRootScrollLayer();
// Scroll on main if there is non-composited fixed position element.
// And the containing scroll layer should not get fractional scroll offset.
ASSERT_TRUE(rootScrollLayer->shouldScrollOnMainThread());
ASSERT_EQ(1.0, rootScrollLayer->scrollPositionDouble().x);
ASSERT_EQ(1.0, rootScrollLayer->scrollPositionDouble().y);
ASSERT_EQ(0.0, rootScrollLayer->position().x);
ASSERT_EQ(0.0, rootScrollLayer->position().y);
}
GtkPolicyType webkit_web_frame_get_vertical_scrollbar_policy(WebKitWebFrame* frame)
{
g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), GTK_POLICY_AUTOMATIC);
Frame* coreFrame = core(frame);
FrameView* view = coreFrame->view();
if (!view)
return GTK_POLICY_AUTOMATIC;
ScrollbarMode vMode = view->verticalScrollbarMode();
if (vMode == ScrollbarAlwaysOn)
return GTK_POLICY_ALWAYS;
if (vMode == ScrollbarAlwaysOff)
return GTK_POLICY_NEVER;
return GTK_POLICY_AUTOMATIC;
}
void RenderWidget::updateWidgetPosition()
{
if (!m_widget)
return;
WeakPtr<RenderWidget> weakThis = createWeakPtr();
bool widgetSizeChanged = updateWidgetGeometry();
if (!weakThis)
return;
// if the frame size got changed, or if view needs layout (possibly indicating
// content size is wrong) we have to do a layout to set the right widget size.
if (m_widget->isFrameView()) {
FrameView* frameView = toFrameView(m_widget.get());
// Check the frame's page to make sure that the frame isn't in the process of being destroyed.
if ((widgetSizeChanged || frameView->needsLayout()) && frameView->frame().page())
frameView->layout();
}
}
InRegionScrollableArea::InRegionScrollableArea(WebPagePrivate* webPage, RenderLayer* layer)
: m_webPage(webPage)
, m_layer(layer)
, m_hasWindowVisibleRectCalculated(false)
{
ASSERT(webPage);
ASSERT(layer);
m_isNull = false;
// FIXME: Add an ASSERT here as the 'layer' must be scrollable.
RenderObject* layerRenderer = layer->renderer();
ASSERT(layerRenderer);
if (layerRenderer->isRenderView()) { // #document case
FrameView* view = toRenderView(layerRenderer)->frameView();
ASSERT(view);
Frame* frame = view->frame();
ASSERT_UNUSED(frame, frame);
m_scrollPosition = m_webPage->mapToTransformed(view->scrollPosition());
m_contentsSize = m_webPage->mapToTransformed(view->contentsSize());
m_viewportSize = m_webPage->mapToTransformed(view->visibleContentRect(false /*includeScrollbars*/)).size();
m_scrollsHorizontally = view->contentsWidth() > view->visibleWidth();
m_scrollsVertically = view->contentsHeight() > view->visibleHeight();
m_overscrollLimitFactor = 0.0; // FIXME eventually support overscroll
} else { // RenderBox-based elements case (scrollable boxes (div's, p's, textarea's, etc)).
RenderBox* box = m_layer->renderBox();
ASSERT(box);
ASSERT(box->canBeScrolledAndHasScrollableArea());
ScrollableArea* scrollableArea = static_cast<ScrollableArea*>(m_layer);
m_scrollPosition = m_webPage->mapToTransformed(scrollableArea->scrollPosition());
m_contentsSize = m_webPage->mapToTransformed(scrollableArea->contentsSize());
m_viewportSize = m_webPage->mapToTransformed(scrollableArea->visibleContentRect(false /*includeScrollbars*/)).size();
m_scrollsHorizontally = box->scrollWidth() != box->clientWidth() && box->scrollsOverflowX();
m_scrollsVertically = box->scrollHeight() != box->clientHeight() && box->scrollsOverflowY();
m_overscrollLimitFactor = 0.0; // FIXME eventually support overscroll
}
}
void EmbeddedWidget::frameRectsChanged()
{
if (!parent())
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = toFrameView(parent());
IntRect oldWindowRect = m_windowRect;
IntRect oldClipRect = m_clipRect;
m_windowRect = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());
m_clipRect = windowClipRect();
m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());
if (!m_window)
return;
if (m_windowRect == oldWindowRect && m_clipRect == oldClipRect)
return;
// To prevent flashes while scrolling, we disable drawing during the window
// update process by clipping the window to the zero rect.
bool clipToZeroRect = true;
if (clipToZeroRect) {
auto rgn = adoptGDIObject(::CreateRectRgn(0, 0, 0, 0));
::SetWindowRgn(m_window, rgn.leak(), FALSE);
} else {
auto rgn = adoptGDIObject(::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.maxX(), m_clipRect.maxY()));
::SetWindowRgn(m_window, rgn.leak(), TRUE);
}
if (m_windowRect != oldWindowRect)
::MoveWindow(m_window, m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height(), TRUE);
if (clipToZeroRect) {
auto rgn = adoptGDIObject(::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.maxX(), m_clipRect.maxY()));
::SetWindowRgn(m_window, rgn.leak(), TRUE);
}
}
void WebViewPrivate::onKeyDown(BalEventKey eventKey)
{
using namespace EA::WebKit;
// 7/20/09 CSidhall -Added for crash fix
if(!m_webView || !m_webView->page() || !m_webView->page()->focusController() )
return;
Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();
if (!frame)
return;
PlatformKeyboardEvent keyboardEvent(&eventKey);
if (frame->eventHandler()->keyEvent(keyboardEvent))
return;
FrameView* view = frame->view();
SelectionController::EAlteration alteration;
if (eventKey.mId == kShift)
alteration = SelectionController::EXTEND;
else
alteration = SelectionController::MOVE;
switch (eventKey.mId) {
case kArrowDown:
view->scrollBy(0, LINE_STEP);
break;
case kArrowUp:
view->scrollBy(0, -LINE_STEP);
break;
case kArrowRight:
view->scrollBy(LINE_STEP, 0);
break;
case kArrowLeft:
view->scrollBy(-LINE_STEP, 0);
break;
case kHome:
frame->selection()->modify(alteration, SelectionController::BACKWARD, DocumentBoundary, true);
break;
case kEnd:
frame->selection()->modify(alteration, SelectionController::FORWARD, DocumentBoundary, true);
break;
case kEscape:
// On FireFox, esc causes animations to stop.
break;
case kF1:
m_webView->goBack();
view->update();
break;
case kF2:
m_webView->goForward();
view->update();
break;
default:
break;
}
}
void WebFrameLoaderClient::transitionToCommittedForNewPage()
{
Frame* frame = core(m_webFrame);
ASSERT(frame);
Page* page = frame->page();
ASSERT(page);
bool isMainFrame = frame == page->mainFrame();
/* if (isMainFrame && frame->view())
frame->view()->detachFromWindow();*/
frame->setView(0);
m_webFrame->updateBackground();
WebView* webView = m_webFrame->webView();
FrameView* frameView;
if (isMainFrame) {
IntRect rect = webView->frameRect();
frameView = new FrameView(frame, rect.size());
} else
frameView = new FrameView(frame);
frame->setView(frameView);
frameView->deref(); // FrameViews are created with a ref count of 1. Release this ref since we've assigned it to frame.
BalWidget* viewWindow = webView->viewWindow();
if (viewWindow)
frameView->setContainingWindow(viewWindow);
/*if (isMainFrame)
frameView->attachToWindow();*/
if (frame->ownerRenderer())
frame->ownerRenderer()->setWidget(frameView);
if (HTMLFrameOwnerElement* owner = frame->ownerElement())
frame->view()->setScrollbarsMode(owner->scrollingMode());
}
void PluginView::updatePluginWidget()
{
FrameView* frameView = static_cast<FrameView*>(parent());
PLUGIN_LOG("--%p UpdatePluginWidget frame=[%p] \n", instance(), frameView);
if (frameView) {
m_windowRect = frameView->contentsToWindow(frameRect());
IntRect oldPageRect = m_pageRect;
// only the top ScrollView can have the offset
m_pageRect = m_windowRect;
ScrollView* top = parent();
while (top->parent())
top = top->parent();
m_pageRect.move(top->scrollOffset());
if (m_pageRect != oldPageRect)
setNPWindowIfNeeded();
}
}
// Manual drag caret manipulation
void DragController::placeDragCaret(const IntPoint& windowPoint)
{
Frame* mainFrame = m_page->mainFrame();
Document* newDraggingDoc = mainFrame->documentAtPoint(windowPoint);
if (m_document != newDraggingDoc) {
if (m_document)
cancelDrag();
m_document = newDraggingDoc;
}
if (!m_document)
return;
Frame* frame = m_document->frame();
ASSERT(frame);
FrameView* frameView = frame->view();
if (!frameView)
return;
IntPoint framePoint = frameView->windowToContents(windowPoint);
Selection dragCaret(frame->visiblePositionForPoint(framePoint));
m_page->dragCaretController()->setSelection(dragCaret);
}
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 InspectorEmulationAgent::viewportChanged()
{
if (!m_webViewImpl->devToolsEmulator()->deviceEmulationEnabled() || !frontend())
return;
FrameView* view = m_webViewImpl->mainFrameImpl()->frameView();
IntSize contentsSize = view->contentsSize();
FloatPoint scrollOffset;
scrollOffset = FloatPoint(view->scrollableArea()->visibleContentRectDouble().location());
RefPtr<TypeBuilder::Emulation::Viewport> viewport = TypeBuilder::Emulation::Viewport::create()
.setScrollX(scrollOffset.x())
.setScrollY(scrollOffset.y())
.setContentsWidth(contentsSize.width())
.setContentsHeight(contentsSize.height())
.setPageScaleFactor(m_webViewImpl->page()->pageScaleFactor())
.setMinimumPageScaleFactor(m_webViewImpl->minimumPageScaleFactor())
.setMaximumPageScaleFactor(m_webViewImpl->maximumPageScaleFactor());
frontend()->viewportChanged(viewport);
}
TEST_F(PaintPropertyTreeBuilderTest, FrameScrollingTraditional)
{
setBodyInnerHTML("<style> body { height: 10000px; } </style>");
document().domWindow()->scrollTo(0, 100);
FrameView* frameView = document().view();
frameView->updateAllLifecyclePhases();
EXPECT_EQ(TransformationMatrix(), frameView->preTranslation()->matrix());
EXPECT_EQ(nullptr, frameView->preTranslation()->parent());
EXPECT_EQ(TransformationMatrix().translate(0, -100), frameView->scrollTranslation()->matrix());
EXPECT_EQ(frameView->preTranslation(), frameView->scrollTranslation()->parent());
EXPECT_EQ(frameView->preTranslation(), frameView->contentClip()->localTransformSpace());
EXPECT_EQ(FloatRoundedRect(0, 0, 800, 600), frameView->contentClip()->clipRect());
EXPECT_EQ(nullptr, frameView->contentClip()->parent());
LayoutView* layoutView = document().layoutView();
ObjectPaintProperties* layoutViewProperties = layoutView->objectPaintProperties();
EXPECT_EQ(nullptr, layoutViewProperties);
}
static bool pointWithScrollAndZoomIfPossible(const Document& document, IntPoint& point)
{
LocalFrame* frame = document.frame();
if (!frame)
return false;
FrameView* frameView = frame->view();
if (!frameView)
return false;
FloatPoint pointInDocument(point);
pointInDocument.scale(frame->pageZoomFactor(), frame->pageZoomFactor());
pointInDocument.moveBy(frameView->scrollPosition());
IntPoint roundedPointInDocument = roundedIntPoint(pointInDocument);
if (!frameView->visibleContentRect().contains(roundedPointInDocument))
return false;
point = roundedPointInDocument;
return true;
}
/**
* webkit_web_inspector_inspect_coordinates:
* @web_inspector: the #WebKitWebInspector that will do the inspection
* @x: the X coordinate of the node to be inspected
* @y: the Y coordinate of the node to be inspected
*
* Causes the Web Inspector to inspect the node that is located at the
* given coordinates of the widget. The coordinates should be relative
* to the #WebKitWebView widget, not to the scrollable content, and
* may be obtained from a #GdkEvent directly.
*
* This means @x, and @y being zero doesn't guarantee you will hit the
* left-most top corner of the content, since the contents may have
* been scrolled.
*
* Since: 1.1.17
*/
void webkit_web_inspector_inspect_coordinates(WebKitWebInspector* webInspector, gdouble x, gdouble y)
{
g_return_if_fail(WEBKIT_IS_WEB_INSPECTOR(webInspector));
g_return_if_fail(x >= 0 && y >= 0);
WebKitWebInspectorPrivate* priv = webInspector->priv;
Frame* frame = priv->page->focusController()->focusedOrMainFrame();
FrameView* view = frame->view();
if (!view)
return;
HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
IntPoint documentPoint = view->windowToContents(IntPoint(static_cast<int>(x), static_cast<int>(y)));
HitTestResult result(documentPoint);
frame->contentRenderer()->layer()->hitTest(request, result);
priv->page->inspectorController()->inspect(result.innerNonSharedNode());
}
void Page::setPageScaleFactor(float scale, const IntPoint& origin)
{
FrameView* view = mainFrame()->view();
if (scale != m_pageScaleFactor) {
m_pageScaleFactor = scale;
if (view)
view->setVisibleContentScaleFactor(scale);
mainFrame()->deviceOrPageScaleFactorChanged();
m_chrome->client().deviceOrPageScaleFactorChanged();
if (view)
view->viewportConstrainedVisibleContentSizeChanged(true, true);
}
if (view && view->scrollPosition() != origin)
view->notifyScrollPositionChanged(origin);
}
float ImageDocument::scale() const
{
// on iPhone big images are subsampled to make them smaller - don't resize them.
return 1.0f;
if (!m_imageElement)
return 1.0f;
FrameView* view = frame()->view();
if (!view)
return 1;
IntSize imageSize = m_imageElement->cachedImage()->imageSize(pageZoomFactor(this));
IntSize windowSize = IntSize(view->width(), view->height());
float widthScale = (float)windowSize.width() / imageSize.width();
float heightScale = (float)windowSize.height() / imageSize.height();
return min(widthScale, heightScale);
}
Region ScrollingCoordinator::computeNonFastScrollableRegion(Frame* frame, const IntPoint& frameLocation)
{
Region nonFastScrollableRegion;
FrameView* frameView = frame->view();
if (!frameView)
return nonFastScrollableRegion;
IntPoint offset = frameLocation;
offset.moveBy(frameView->frameRect().location());
if (const FrameView::ScrollableAreaSet* scrollableAreas = frameView->scrollableAreas()) {
for (FrameView::ScrollableAreaSet::const_iterator it = scrollableAreas->begin(), end = scrollableAreas->end(); it != end; ++it) {
ScrollableArea* scrollableArea = *it;
#if USE(ACCELERATED_COMPOSITING)
// Composited scrollable areas can be scrolled off the main thread.
if (scrollableArea->usesCompositedScrolling())
continue;
#endif
IntRect box = scrollableArea->scrollableAreaBoundingBox();
box.moveBy(offset);
nonFastScrollableRegion.unite(box);
}
}
if (const HashSet<RefPtr<Widget> >* children = frameView->children()) {
for (HashSet<RefPtr<Widget> >::const_iterator it = children->begin(), end = children->end(); it != end; ++it) {
if (!(*it)->isPluginViewBase())
continue;
PluginViewBase* pluginViewBase = static_cast<PluginViewBase*>((*it).get());
if (pluginViewBase->wantsWheelEvents())
nonFastScrollableRegion.unite(pluginViewBase->frameRect());
}
}
FrameTree* tree = frame->tree();
for (Frame* subFrame = tree->firstChild(); subFrame; subFrame = subFrame->tree()->nextSibling())
nonFastScrollableRegion.unite(computeNonFastScrollableRegion(subFrame, offset));
return nonFastScrollableRegion;
}
SynchronousScrollingReasons ScrollingCoordinator::synchronousScrollingReasons() const
{
FrameView* frameView = m_page->mainFrame().view();
if (!frameView)
return static_cast<SynchronousScrollingReasons>(0);
SynchronousScrollingReasons synchronousScrollingReasons = (SynchronousScrollingReasons)0;
if (m_forceSynchronousScrollLayerPositionUpdates)
synchronousScrollingReasons |= ForcedOnMainThread;
if (frameView->hasSlowRepaintObjects())
synchronousScrollingReasons |= HasSlowRepaintObjects;
if (!supportsFixedPositionLayers() && frameView->hasViewportConstrainedObjects())
synchronousScrollingReasons |= HasViewportConstrainedObjectsWithoutSupportingFixedLayers;
if (supportsFixedPositionLayers() && hasVisibleSlowRepaintViewportConstrainedObjects(frameView))
synchronousScrollingReasons |= HasNonLayerViewportConstrainedObjects;
if (m_page->mainFrame().document() && m_page->mainFrame().document()->isImageDocument())
synchronousScrollingReasons |= IsImageDocument;
return synchronousScrollingReasons;
}
void RenderWidget::resumeWidgetHierarchyUpdates()
{
ASSERT(widgetHierarchyUpdateSuspendCount);
if (widgetHierarchyUpdateSuspendCount == 1) {
WidgetToParentMap map = widgetNewParentMap();
widgetNewParentMap().clear();
WidgetToParentMap::iterator end = map.end();
for (WidgetToParentMap::iterator it = map.begin(); it != end; ++it) {
Widget* child = it->first.get();
ScrollView* currentParent = child->parent();
FrameView* newParent = it->second;
if (newParent != currentParent) {
if (currentParent)
currentParent->removeChild(child);
if (newParent)
newParent->addChild(child);
}
}
}
widgetHierarchyUpdateSuspendCount--;
}
GObject* webkit_gtk_frame_new(WebKitGtkPage* page)
{
WebKitGtkFrame* frame = WEBKIT_GTK_FRAME(g_object_new(WEBKIT_GTK_TYPE_FRAME, NULL));
WebKitGtkFramePrivate* frameData = WEBKIT_GTK_FRAME_GET_PRIVATE(frame);
WebKitGtkPagePrivate* pageData = WEBKIT_GTK_PAGE_GET_PRIVATE(page);
frameData->client = new WebKit::FrameLoaderClient(frame);
frameData->frame = new Frame(pageData->page, 0, frameData->client);
FrameView* frameView = new FrameView(frameData->frame);
frameView->setContainingWindow(GTK_CONTAINER(page));
frameView->setGtkAdjustments(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)),
GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
frameData->frame->setView(frameView);
frameData->frame->init();
frameData->page = page;
frameData->title = 0;
frameData->location = 0;
return G_OBJECT(frame);
}
void PageWidgetDelegate::paint(Page* page, PageOverlayList* overlays, WebCanvas* canvas, const WebRect& rect, CanvasBackground background)
{
if (rect.isEmpty())
return;
GraphicsContextBuilder builder(canvas);
GraphicsContext& gc = builder.context();
gc.platformContext()->setDrawingToImageBuffer(background == Opaque ? false : true);
gc.applyDeviceScaleFactor(page->deviceScaleFactor());
IntRect dirtyRect(rect);
gc.save();
FrameView* view = mainFrameView(page);
// FIXME: Can we remove the mainFrame()->document() check?
if (view && page->mainFrame()->document()) {
gc.clip(dirtyRect);
view->paint(&gc, dirtyRect);
if (overlays)
overlays->paintWebFrame(gc);
} else
gc.fillRect(dirtyRect, Color::white, ColorSpaceDeviceRGB);
gc.restore();
}
RenderWidget::UpdateSuspendScope::~UpdateSuspendScope()
{
ASSERT(s_updateSuspendCount > 0);
if (s_updateSuspendCount == 1) {
WidgetToParentMap map;
widgetNewParentMap().swap(map);
WidgetToParentMap::iterator end = map.end();
for (WidgetToParentMap::iterator it = map.begin(); it != end; ++it) {
Widget* child = it->key.get();
ScrollView* currentParent = toScrollView(child->parent());
FrameView* newParent = it->value;
if (newParent != currentParent) {
if (currentParent)
currentParent->removeChild(child);
if (newParent)
newParent->addChild(child);
}
}
}
--s_updateSuspendCount;
}
void CompositingCoordinator::setVisibleContentsRect(const FloatRect& rect, const FloatPoint& trajectoryVector)
{
// A zero trajectoryVector indicates that tiles all around the viewport are requested.
if (CoordinatedGraphicsLayer* contentsLayer = mainContentsLayer())
contentsLayer->setVisibleContentRectTrajectoryVector(trajectoryVector);
bool contentsRectDidChange = rect != m_visibleContentsRect;
if (contentsRectDidChange) {
m_visibleContentsRect = rect;
for (auto& registeredLayer : m_registeredLayers.values())
registeredLayer->setNeedsVisibleRectAdjustment();
}
FrameView* view = m_page->mainFrame().view();
if (view->useFixedLayout() && contentsRectDidChange) {
// Round the rect instead of enclosing it to make sure that its size stays
// the same while panning. This can have nasty effects on layout.
view->setFixedVisibleContentRect(roundedIntRect(rect));
}
}