1/*
2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3 * Copyright (C) 2000 Dirk Mueller (mueller@kde.org)
4 * Copyright (C) 2004, 2006, 2009, 2010 Apple Inc. All rights reserved.
5 * Copyright (C) 2013 Google Inc. All rights reserved.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public License
18 * along with this library; see the file COPYING.LIB.  If not, write to
19 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 * Boston, MA 02110-1301, USA.
21 *
22 */
23
24#include "config.h"
25#include "core/rendering/RenderWidget.h"
26
27#include "core/accessibility/AXObjectCache.h"
28#include "core/frame/LocalFrame.h"
29#include "core/html/HTMLFrameOwnerElement.h"
30#include "core/html/HTMLPlugInElement.h"
31#include "core/paint/BoxPainter.h"
32#include "core/rendering/GraphicsContextAnnotator.h"
33#include "core/rendering/HitTestResult.h"
34#include "core/rendering/RenderLayer.h"
35#include "core/rendering/RenderView.h"
36#include "core/rendering/compositing/CompositedLayerMapping.h"
37#include "core/rendering/compositing/RenderLayerCompositor.h"
38#include "wtf/HashMap.h"
39
40namespace blink {
41
42RenderWidget::RenderWidget(Element* element)
43    : RenderReplaced(element)
44#if !ENABLE(OILPAN)
45    // Reference counting is used to prevent the widget from being
46    // destroyed while inside the Widget code, which might not be
47    // able to handle that.
48    , m_refCount(1)
49#endif
50{
51    ASSERT(element);
52    frameView()->addWidget(this);
53}
54
55void RenderWidget::willBeDestroyed()
56{
57    frameView()->removeWidget(this);
58
59    if (AXObjectCache* cache = document().existingAXObjectCache()) {
60        cache->childrenChanged(this->parent());
61        cache->remove(this);
62    }
63
64    Element* element = toElement(node());
65    if (element && element->isFrameOwnerElement())
66        toHTMLFrameOwnerElement(element)->setWidget(nullptr);
67
68    RenderReplaced::willBeDestroyed();
69}
70
71void RenderWidget::destroy()
72{
73#if ENABLE(ASSERT) && ENABLE(OILPAN)
74    ASSERT(!m_didCallDestroy);
75    m_didCallDestroy = true;
76#endif
77    willBeDestroyed();
78    clearNode();
79#if ENABLE(OILPAN)
80    // In Oilpan, postDestroy doesn't delete |this|. So calling it here is safe
81    // though |this| will be referred in FrameView.
82    postDestroy();
83#else
84    deref();
85#endif
86}
87
88RenderWidget::~RenderWidget()
89{
90#if !ENABLE(OILPAN)
91    ASSERT(m_refCount <= 0);
92#endif
93}
94
95Widget* RenderWidget::widget() const
96{
97    // Plugin widgets are stored in their DOM node. This includes HTMLAppletElement.
98    Element* element = toElement(node());
99
100    if (element && element->isFrameOwnerElement())
101        return toHTMLFrameOwnerElement(element)->ownedWidget();
102
103    return 0;
104}
105
106// Widgets are always placed on integer boundaries, so rounding the size is actually
107// the desired behavior. This function is here because it's otherwise seldom what we
108// want to do with a LayoutRect.
109static inline IntRect roundedIntRect(const LayoutRect& rect)
110{
111    return IntRect(roundedIntPoint(rect.location()), roundedIntSize(rect.size()));
112}
113
114bool RenderWidget::setWidgetGeometry(const LayoutRect& frame)
115{
116    if (!node())
117        return false;
118
119    Widget* widget = this->widget();
120    ASSERT(widget);
121
122    IntRect newFrame = roundedIntRect(frame);
123
124    if (widget->frameRect() == newFrame)
125        return false;
126
127    RefPtrWillBeRawPtr<RenderWidget> protector(this);
128    RefPtrWillBeRawPtr<Node> protectedNode(node());
129    widget->setFrameRect(newFrame);
130    return widget->frameRect().size() != newFrame.size();
131}
132
133bool RenderWidget::updateWidgetGeometry()
134{
135    Widget* widget = this->widget();
136    ASSERT(widget);
137
138    LayoutRect contentBox = contentBoxRect();
139    LayoutRect absoluteContentBox(localToAbsoluteQuad(FloatQuad(contentBox)).boundingBox());
140    if (widget->isFrameView()) {
141        contentBox.setLocation(absoluteContentBox.location());
142        return setWidgetGeometry(contentBox);
143    }
144
145    return setWidgetGeometry(absoluteContentBox);
146}
147
148void RenderWidget::layout()
149{
150    ASSERT(needsLayout());
151
152    clearNeedsLayout();
153}
154
155void RenderWidget::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
156{
157    RenderReplaced::styleDidChange(diff, oldStyle);
158    Widget* widget = this->widget();
159
160    if (widget) {
161        if (style()->visibility() != VISIBLE) {
162            widget->hide();
163        } else {
164            widget->show();
165        }
166    }
167}
168
169void RenderWidget::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
170{
171    LayoutPoint adjustedPaintOffset = paintOffset + location();
172
173    Widget* widget = this->widget();
174    RELEASE_ASSERT(widget);
175
176    // Tell the widget to paint now. This is the only time the widget is allowed
177    // to paint itself. That way it will composite properly with z-indexed layers.
178    IntPoint widgetLocation = widget->frameRect().location();
179    IntPoint paintLocation(roundToInt(adjustedPaintOffset.x() + borderLeft() + paddingLeft()),
180        roundToInt(adjustedPaintOffset.y() + borderTop() + paddingTop()));
181    IntRect paintRect = paintInfo.rect;
182
183    IntSize widgetPaintOffset = paintLocation - widgetLocation;
184    // When painting widgets into compositing layers, tx and ty are relative to the enclosing compositing layer,
185    // not the root. In this case, shift the CTM and adjust the paintRect to be root-relative to fix plug-in drawing.
186    if (!widgetPaintOffset.isZero()) {
187        paintInfo.context->translate(widgetPaintOffset.width(), widgetPaintOffset.height());
188        paintRect.move(-widgetPaintOffset);
189    }
190    widget->paint(paintInfo.context, paintRect);
191
192    if (!widgetPaintOffset.isZero())
193        paintInfo.context->translate(-widgetPaintOffset.width(), -widgetPaintOffset.height());
194}
195
196void RenderWidget::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
197{
198    ANNOTATE_GRAPHICS_CONTEXT(paintInfo, this);
199
200    if (!shouldPaint(paintInfo, paintOffset))
201        return;
202
203    LayoutPoint adjustedPaintOffset = paintOffset + location();
204
205    if (hasBoxDecorationBackground() && (paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection))
206        paintBoxDecorationBackground(paintInfo, adjustedPaintOffset);
207
208    if (paintInfo.phase == PaintPhaseMask) {
209        paintMask(paintInfo, adjustedPaintOffset);
210        return;
211    }
212
213    if ((paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline) && style()->hasOutline())
214        paintOutline(paintInfo, LayoutRect(adjustedPaintOffset, size()));
215
216    if (paintInfo.phase != PaintPhaseForeground)
217        return;
218
219    if (style()->hasBorderRadius()) {
220        LayoutRect borderRect = LayoutRect(adjustedPaintOffset, size());
221
222        if (borderRect.isEmpty())
223            return;
224
225        // Push a clip if we have a border radius, since we want to round the foreground content that gets painted.
226        paintInfo.context->save();
227        RoundedRect roundedInnerRect = style()->getRoundedInnerBorderFor(borderRect,
228            paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), true, true);
229        BoxPainter::clipRoundedInnerRect(paintInfo.context, borderRect, roundedInnerRect);
230    }
231
232    Widget* widget = this->widget();
233    if (widget)
234        paintContents(paintInfo, paintOffset);
235
236    if (style()->hasBorderRadius())
237        paintInfo.context->restore();
238
239    // Paint a partially transparent wash over selected widgets.
240    if (isSelected() && !document().printing()) {
241        LayoutRect rect = localSelectionRect();
242        rect.moveBy(adjustedPaintOffset);
243        paintInfo.context->fillRect(pixelSnappedIntRect(rect), selectionBackgroundColor());
244    }
245
246    if (canResize())
247        layer()->scrollableArea()->paintResizer(paintInfo.context, roundedIntPoint(adjustedPaintOffset), paintInfo.rect);
248}
249
250#if !ENABLE(OILPAN)
251void RenderWidget::deref()
252{
253    if (--m_refCount <= 0)
254        postDestroy();
255}
256#endif
257
258void RenderWidget::updateOnWidgetChange()
259{
260    Widget* widget = this->widget();
261    if (!widget)
262        return;
263
264    if (!style())
265        return;
266
267    if (!needsLayout())
268        updateWidgetGeometry();
269
270    if (style()->visibility() != VISIBLE) {
271        widget->hide();
272    } else {
273        widget->show();
274        // FIXME: Why do we issue a full paint invalidation in this case, but not the other?
275        setShouldDoFullPaintInvalidation(true);
276    }
277}
278
279void RenderWidget::updateWidgetPosition()
280{
281    Widget* widget = this->widget();
282    if (!widget || !node()) // Check the node in case destroy() has been called.
283        return;
284
285    bool boundsChanged = updateWidgetGeometry();
286
287    // if the frame bounds got changed, or if view needs layout (possibly indicating
288    // content size is wrong) we have to do a layout to set the right widget size
289    if (widget && widget->isFrameView()) {
290        FrameView* frameView = toFrameView(widget);
291        // Check the frame's page to make sure that the frame isn't in the process of being destroyed.
292        if ((boundsChanged || frameView->needsLayout()) && frameView->frame().page())
293            frameView->layout();
294    }
295}
296
297void RenderWidget::widgetPositionsUpdated()
298{
299    Widget* widget = this->widget();
300    if (!widget)
301        return;
302    widget->widgetPositionsUpdated();
303}
304
305bool RenderWidget::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction action)
306{
307    bool hadResult = result.innerNode();
308    bool inside = RenderReplaced::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, action);
309
310    // Check to see if we are really over the widget itself (and not just in the border/padding area).
311    if ((inside || result.isRectBasedTest()) && !hadResult && result.innerNode() == node())
312        result.setIsOverWidget(contentBoxRect().contains(result.localPoint()));
313    return inside;
314}
315
316CursorDirective RenderWidget::getCursor(const LayoutPoint& point, Cursor& cursor) const
317{
318    if (widget() && widget()->isPluginView()) {
319        // A plug-in is responsible for setting the cursor when the pointer is over it.
320        return DoNotSetCursor;
321    }
322    return RenderReplaced::getCursor(point, cursor);
323}
324
325} // namespace blink
326