--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/rendering/RenderWidget.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,402 @@
+/*
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2000 Dirk Mueller (mueller@kde.org)
+ * Copyright (C) 2004, 2006, 2009, 2010 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "config.h"
+#include "RenderWidget.h"
+
+#include "AXObjectCache.h"
+#include "AnimationController.h"
+#include "GraphicsContext.h"
+#include "HitTestResult.h"
+#include "RenderCounter.h"
+#include "RenderLayer.h"
+#include "RenderView.h"
+#include "RenderWidgetProtector.h"
+
+#if USE(ACCELERATED_COMPOSITING)
+#include "RenderLayerBacking.h"
+#endif
+
+using namespace std;
+
+namespace WebCore {
+
+static HashMap<const Widget*, RenderWidget*>& widgetRendererMap()
+{
+ static HashMap<const Widget*, RenderWidget*>* staticWidgetRendererMap = new HashMap<const Widget*, RenderWidget*>;
+ return *staticWidgetRendererMap;
+}
+
+static size_t widgetHierarchyUpdateSuspendCount;
+
+typedef HashMap<RefPtr<Widget>, FrameView*> WidgetToParentMap;
+
+static WidgetToParentMap& widgetNewParentMap()
+{
+ DEFINE_STATIC_LOCAL(WidgetToParentMap, map, ());
+ return map;
+}
+
+void RenderWidget::suspendWidgetHierarchyUpdates()
+{
+ widgetHierarchyUpdateSuspendCount++;
+}
+
+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--;
+}
+
+static void moveWidgetToParentSoon(Widget* child, FrameView* parent)
+{
+ if (!widgetHierarchyUpdateSuspendCount) {
+ if (parent)
+ parent->addChild(child);
+ else
+ child->removeFromParent();
+ return;
+ }
+ widgetNewParentMap().set(child, parent);
+}
+
+RenderWidget::RenderWidget(Node* node)
+ : RenderReplaced(node)
+ , m_widget(0)
+ , m_frameView(node->document()->view())
+ // Reference counting is used to prevent the widget from being
+ // destroyed while inside the Widget code, which might not be
+ // able to handle that.
+ , m_refCount(1)
+{
+ view()->addWidget(this);
+}
+
+void RenderWidget::destroy()
+{
+ // We can't call the base class's destroy because we don't
+ // want to unconditionally delete ourselves (we're ref-counted).
+ // So the code below includes copied and pasted contents of
+ // both RenderBox::destroy() and RenderObject::destroy().
+ // Fix originally made for <rdar://problem/4228818>.
+
+ animation()->cancelAnimations(this);
+
+ if (RenderView* v = view())
+ v->removeWidget(this);
+
+ if (m_hasCounterNodeMap)
+ RenderCounter::destroyCounterNodes(this);
+
+ if (AXObjectCache::accessibilityEnabled()) {
+ document()->axObjectCache()->childrenChanged(this->parent());
+ document()->axObjectCache()->remove(this);
+ }
+ remove();
+
+ setWidget(0);
+
+ // removes from override size map
+ if (hasOverrideSize())
+ setOverrideSize(-1);
+
+ if (style() && (style()->height().isPercent() || style()->minHeight().isPercent() || style()->maxHeight().isPercent()))
+ RenderBlock::removePercentHeightDescendant(this);
+
+ if (hasLayer()) {
+ layer()->clearClipRects();
+ setHasLayer(false);
+ destroyLayer();
+ }
+
+ // Grab the arena from node()->document()->renderArena() before clearing the node pointer.
+ // Clear the node before deref-ing, as this may be deleted when deref is called.
+ RenderArena* arena = renderArena();
+ setNode(0);
+ deref(arena);
+}
+
+RenderWidget::~RenderWidget()
+{
+ ASSERT(m_refCount <= 0);
+ clearWidget();
+}
+
+bool RenderWidget::setWidgetGeometry(const IntRect& frame)
+{
+ ASSERT(!widgetHierarchyUpdateSuspendCount);
+ if (!node())
+ return false;
+
+ IntRect clipRect = enclosingLayer()->childrenClipRect();
+ bool clipChanged = m_clipRect != clipRect;
+ bool boundsChanged = m_widget->frameRect() != frame;
+
+ if (!boundsChanged && !clipChanged)
+ return false;
+
+ m_clipRect = clipRect;
+
+ RenderWidgetProtector protector(this);
+ RefPtr<Node> protectedNode(node());
+ m_widget->setFrameRect(frame);
+
+#if USE(ACCELERATED_COMPOSITING)
+ if (hasLayer() && layer()->isComposited())
+ layer()->backing()->updateAfterWidgetResize();
+#endif
+
+ return boundsChanged;
+}
+
+void RenderWidget::setWidget(PassRefPtr<Widget> widget)
+{
+ if (widget == m_widget)
+ return;
+
+ if (m_widget) {
+ moveWidgetToParentSoon(m_widget.get(), 0);
+ widgetRendererMap().remove(m_widget.get());
+ clearWidget();
+ }
+ m_widget = widget;
+ if (m_widget) {
+ widgetRendererMap().add(m_widget.get(), this);
+ // If we've already received a layout, apply the calculated space to the
+ // widget immediately, but we have to have really been fully constructed (with a non-null
+ // style pointer).
+ if (style()) {
+ if (!needsLayout())
+ setWidgetGeometry(absoluteContentBox());
+ if (style()->visibility() != VISIBLE)
+ m_widget->hide();
+ else
+ m_widget->show();
+ }
+ moveWidgetToParentSoon(m_widget.get(), m_frameView);
+ }
+}
+
+void RenderWidget::layout()
+{
+ ASSERT(needsLayout());
+
+ setNeedsLayout(false);
+}
+
+void RenderWidget::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
+{
+ RenderReplaced::styleDidChange(diff, oldStyle);
+ if (m_widget) {
+ if (style()->visibility() != VISIBLE)
+ m_widget->hide();
+ else
+ m_widget->show();
+ }
+}
+
+void RenderWidget::showSubstituteImage(PassRefPtr<Image> prpImage)
+{
+ m_substituteImage = prpImage;
+ repaint();
+}
+
+void RenderWidget::paint(PaintInfo& paintInfo, int tx, int ty)
+{
+ if (!shouldPaint(paintInfo, tx, ty))
+ return;
+
+ tx += x();
+ ty += y();
+
+ if (hasBoxDecorations() && (paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection))
+ paintBoxDecorations(paintInfo, tx, ty);
+
+ if (paintInfo.phase == PaintPhaseMask) {
+ paintMask(paintInfo, tx, ty);
+ return;
+ }
+
+ if (!m_frameView || paintInfo.phase != PaintPhaseForeground || style()->visibility() != VISIBLE)
+ return;
+
+#if PLATFORM(MAC)
+ if (style()->highlight() != nullAtom && !paintInfo.context->paintingDisabled())
+ paintCustomHighlight(tx - x(), ty - y(), style()->highlight(), true);
+#endif
+
+ if (style()->hasBorderRadius()) {
+ IntRect borderRect = IntRect(tx, ty, width(), height());
+
+ if (borderRect.isEmpty())
+ return;
+
+ // Push a clip if we have a border radius, since we want to round the foreground content that gets painted.
+ paintInfo.context->save();
+
+ IntSize topLeft, topRight, bottomLeft, bottomRight;
+ style()->getBorderRadiiForRect(borderRect, topLeft, topRight, bottomLeft, bottomRight);
+
+ paintInfo.context->addRoundedRectClip(borderRect, topLeft, topRight, bottomLeft, bottomRight);
+ }
+
+ if (m_widget) {
+ // Tell the widget to paint now. This is the only time the widget is allowed
+ // to paint itself. That way it will composite properly with z-indexed layers.
+ if (m_substituteImage)
+ paintInfo.context->drawImage(m_substituteImage.get(), style()->colorSpace(), m_widget->frameRect());
+ else {
+ IntPoint widgetLocation = m_widget->frameRect().location();
+ IntPoint paintLocation(tx + borderLeft() + paddingLeft(), ty + borderTop() + paddingTop());
+ IntRect paintRect = paintInfo.rect;
+
+ IntSize paintOffset = paintLocation - widgetLocation;
+ // When painting widgets into compositing layers, tx and ty are relative to the enclosing compositing layer,
+ // not the root. In this case, shift the CTM and adjust the paintRect to be root-relative to fix plug-in drawing.
+ if (!paintOffset.isZero()) {
+ paintInfo.context->translate(paintOffset);
+ paintRect.move(-paintOffset);
+ }
+ m_widget->paint(paintInfo.context, paintRect);
+
+ if (!paintOffset.isZero())
+ paintInfo.context->translate(-paintOffset);
+ }
+
+ if (m_widget->isFrameView()) {
+ FrameView* frameView = static_cast<FrameView*>(m_widget.get());
+ bool runOverlapTests = !frameView->useSlowRepaintsIfNotOverlapped() || frameView->hasCompositedContent();
+ if (paintInfo.overlapTestRequests && runOverlapTests) {
+ ASSERT(!paintInfo.overlapTestRequests->contains(this));
+ paintInfo.overlapTestRequests->set(this, m_widget->frameRect());
+ }
+ }
+ }
+
+ if (style()->hasBorderRadius())
+ paintInfo.context->restore();
+
+ // Paint a partially transparent wash over selected widgets.
+ if (isSelected() && !document()->printing()) {
+ // FIXME: selectionRect() is in absolute, not painting coordinates.
+ paintInfo.context->fillRect(selectionRect(), selectionBackgroundColor(), style()->colorSpace());
+ }
+}
+
+void RenderWidget::setOverlapTestResult(bool isOverlapped)
+{
+ ASSERT(m_widget);
+ ASSERT(m_widget->isFrameView());
+ static_cast<FrameView*>(m_widget.get())->setIsOverlapped(isOverlapped);
+}
+
+void RenderWidget::deref(RenderArena *arena)
+{
+ if (--m_refCount <= 0)
+ arenaDelete(arena, this);
+}
+
+void RenderWidget::updateWidgetPosition()
+{
+ if (!m_widget || !node()) // Check the node in case destroy() has been called.
+ return;
+
+ // FIXME: This doesn't work correctly with transforms.
+ FloatPoint absPos = localToAbsolute();
+ absPos.move(borderLeft() + paddingLeft(), borderTop() + paddingTop());
+
+ int w = width() - borderAndPaddingWidth();
+ int h = height() - borderAndPaddingHeight();
+
+ bool boundsChanged = setWidgetGeometry(IntRect(absPos.x(), absPos.y(), w, h));
+
+ // if the frame bounds 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 && m_widget->isFrameView()) {
+ FrameView* frameView = static_cast<FrameView*>(m_widget.get());
+ if (boundsChanged || frameView->needsLayout())
+ frameView->layout();
+ }
+}
+
+void RenderWidget::widgetPositionsUpdated()
+{
+ if (!m_widget)
+ return;
+ m_widget->widgetPositionsUpdated();
+}
+
+IntRect RenderWidget::windowClipRect() const
+{
+ if (!m_frameView)
+ return IntRect();
+
+ return intersection(m_frameView->contentsToWindow(m_clipRect), m_frameView->windowClipRect());
+}
+
+void RenderWidget::setSelectionState(SelectionState state)
+{
+ if (selectionState() != state) {
+ RenderReplaced::setSelectionState(state);
+ if (m_widget)
+ m_widget->setIsSelected(isSelected());
+ }
+}
+
+void RenderWidget::clearWidget()
+{
+ m_widget = 0;
+}
+
+RenderWidget* RenderWidget::find(const Widget* widget)
+{
+ return widgetRendererMap().get(widget);
+}
+
+bool RenderWidget::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, int x, int y, int tx, int ty, HitTestAction action)
+{
+ bool hadResult = result.innerNode();
+ bool inside = RenderReplaced::nodeAtPoint(request, result, x, y, tx, ty, action);
+
+ // Check to see if we are really over the widget itself (and not just in the border/padding area).
+ if ((inside || result.isRectBasedTest()) && !hadResult && result.innerNode() == node())
+ result.setIsOverWidget(contentBoxRect().contains(result.localPoint()));
+ return inside;
+}
+
+} // namespace WebCore