external/webkit r30707

1 files changed, 547 insertions, 0 deletions

diff --git a/WebCore/rendering/RenderView.cpp b/WebCore/rendering/RenderView.cpp
new file mode 100644
index 0000000..bd9c500
--- /dev/null
+++ b/WebCore/rendering/RenderView.cpp
@@ -0,0 +1,547 @@
+/**
+ * This file is part of the HTML widget for KDE.
+ *
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+ *
+ * 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 "RenderView.h"
+
+#include "Document.h"
+#include "Element.h"
+#include "FrameView.h"
+#include "GraphicsContext.h"
+#include "RenderLayer.h"
+
+namespace WebCore {
+
+RenderView::RenderView(Node* node, FrameView* view)
+    : RenderBlock(node)
+    , m_frameView(view)
+    , m_selectionStart(0)
+    , m_selectionEnd(0)
+    , m_selectionStartPos(-1)
+    , m_selectionEndPos(-1)
+    , m_printImages(true)
+    , m_maximalOutlineSize(0)
+    , m_layoutState(0)
+    , m_layoutStateDisableCount(0)
+{
+    // Clear our anonymous bit, set because RenderObject assumes
+    // any renderer with document as the node is anonymous.
+    setIsAnonymous(false);
+
+    // init RenderObject attributes
+    setInline(false);
+
+    // try to contrain the width to the views width
+    m_width = 0;
+    m_height = 0;
+    m_minPrefWidth = 0;
+    m_maxPrefWidth = 0;
+
+    setPrefWidthsDirty(true, false);
+    
+    setPositioned(true); // to 0,0 :)
+
+    // Create a new root layer for our layer hierarchy.
+    m_layer = new (node->document()->renderArena()) RenderLayer(this);
+    setHasLayer(true);
+}
+
+RenderView::~RenderView()
+{
+}
+
+void RenderView::calcHeight()
+{
+    if (!printing() && m_frameView)
+        m_height = m_frameView->visibleHeight();
+}
+
+void RenderView::calcWidth()
+{
+    if (!printing() && m_frameView)
+        m_width = m_frameView->visibleWidth();
+    m_marginLeft = 0;
+    m_marginRight = 0;
+}
+
+void RenderView::calcPrefWidths()
+{
+    ASSERT(prefWidthsDirty());
+
+    RenderBlock::calcPrefWidths();
+
+    m_maxPrefWidth = m_minPrefWidth;
+}
+
+void RenderView::layout()
+{
+    if (printing())
+        m_minPrefWidth = m_maxPrefWidth = m_width;
+
+    bool relayoutChildren = !printing() && (!m_frameView || m_width != m_frameView->visibleWidth() || m_height != m_frameView->visibleHeight());
+    if (relayoutChildren)
+        setChildNeedsLayout(true, false);
+    
+    ASSERT(!m_layoutState);
+    LayoutState state;
+    // FIXME: May be better to push a clip and avoid issuing offscreen repaints.
+    state.m_clipped = false;
+    m_layoutState = &state;
+
+    if (needsLayout())
+        RenderBlock::layout();
+
+    // Ensure that docWidth() >= width() and docHeight() >= height().
+    setOverflowWidth(m_width);
+    setOverflowHeight(m_height);
+
+    setOverflowWidth(docWidth());
+    setOverflowHeight(docHeight());
+
+    ASSERT(m_layoutStateDisableCount == 0);
+    ASSERT(m_layoutState == &state);
+    m_layoutState = 0;
+    setNeedsLayout(false);
+}
+
+bool RenderView::absolutePosition(int& xPos, int& yPos, bool fixed) const
+{
+    if (fixed && m_frameView) {
+        xPos = m_frameView->contentsX();
+        yPos = m_frameView->contentsY();
+    } else
+        xPos = yPos = 0;
+    return true;
+}
+
+void RenderView::paint(PaintInfo& paintInfo, int tx, int ty)
+{
+    // If we ever require layout but receive a paint anyway, something has gone horribly wrong.
+    ASSERT(!needsLayout());
+
+    // Cache the print rect because the dirty rect could get changed during painting.
+    if (printing())
+        setPrintRect(paintInfo.rect);
+    else
+        setPrintRect(IntRect());
+    paintObject(paintInfo, tx, ty);
+}
+
+void RenderView::paintBoxDecorations(PaintInfo& paintInfo, int tx, int ty)
+{
+    // Check to see if we are enclosed by a transparent layer.  If so, we cannot blit
+    // when scrolling, and we need to use slow repaints.
+    Element* elt = document()->ownerElement();
+    if (view() && elt && elt->renderer()) {
+        RenderLayer* layer = elt->renderer()->enclosingLayer();
+        if (layer->isTransparent() || layer->transparentAncestor())
+            frameView()->setUseSlowRepaints();
+    }
+
+    if (elt || (firstChild() && firstChild()->style()->visibility() == VISIBLE) || !view())
+        return;
+
+    // This code typically only executes if the root element's visibility has been set to hidden.
+    // Only fill with the base background color (typically white) if we're the root document, 
+    // since iframes/frames with no background in the child document should show the parent's background.
+    if (view()->isTransparent())
+        frameView()->setUseSlowRepaints(); // The parent must show behind the child.
+    else {
+        Color baseColor = frameView()->baseBackgroundColor();
+        if (baseColor.alpha() > 0) {
+            paintInfo.context->save();
+            paintInfo.context->setCompositeOperation(CompositeCopy);
+            paintInfo.context->fillRect(paintInfo.rect, baseColor);
+            paintInfo.context->restore();
+        } else
+            paintInfo.context->clearRect(paintInfo.rect);
+    }
+}
+
+void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)
+{
+    if (printing() || ur.width() == 0 || ur.height() == 0)
+        return;
+
+    if (!m_frameView)
+        return;
+
+    // We always just invalidate the root view, since we could be an iframe that is clipped out
+    // or even invisible.
+    Element* elt = document()->ownerElement();
+    if (!elt)
+        m_frameView->repaintRectangle(ur, immediate);
+    else if (RenderObject* obj = elt->renderer()) {
+        IntRect vr = viewRect();
+        IntRect r = intersection(ur, vr);
+        
+        // Subtract out the contentsX and contentsY offsets to get our coords within the viewing
+        // rectangle.
+        r.move(-vr.x(), -vr.y());
+        
+        // FIXME: Hardcoded offsets here are not good.
+        r.move(obj->borderLeft() + obj->paddingLeft(),
+               obj->borderTop() + obj->paddingTop());
+        obj->repaintRectangle(r, immediate);
+    }
+}
+
+void RenderView::computeAbsoluteRepaintRect(IntRect& rect, bool fixed)
+{
+    if (printing())
+        return;
+
+    if (fixed && m_frameView)
+        rect.move(m_frameView->contentsX(), m_frameView->contentsY());
+}
+
+void RenderView::absoluteRects(Vector<IntRect>& rects, int tx, int ty, bool)
+{
+    rects.append(IntRect(tx, ty, m_layer->width(), m_layer->height()));
+}
+
+RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset)
+{
+    if (!object)
+        return 0;
+
+    RenderObject* child = object->childAt(offset);
+    return child ? child : object->nextInPreOrderAfterChildren();
+}
+
+IntRect RenderView::selectionRect(bool clipToVisibleContent) const
+{
+    document()->updateRendering();
+
+    typedef HashMap<RenderObject*, SelectionInfo*> SelectionMap;
+    SelectionMap selectedObjects;
+
+    RenderObject* os = m_selectionStart;
+    RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+    while (os && os != stop) {
+        if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
+            // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
+            selectedObjects.set(os, new SelectionInfo(os, clipToVisibleContent));
+            RenderBlock* cb = os->containingBlock();
+            while (cb && !cb->isRenderView()) {
+                SelectionInfo* blockInfo = selectedObjects.get(cb);
+                if (blockInfo)
+                    break;
+                selectedObjects.set(cb, new SelectionInfo(cb, clipToVisibleContent));
+                cb = cb->containingBlock();
+            }
+        }
+
+        os = os->nextInPreOrder();
+    }
+
+    // Now create a single bounding box rect that encloses the whole selection.
+    IntRect selRect;
+    SelectionMap::iterator end = selectedObjects.end();
+    for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
+        SelectionInfo* info = i->second;
+        selRect.unite(info->rect());
+        delete info;
+    }
+    return selRect;
+}
+
+void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos)
+{
+    // Make sure both our start and end objects are defined.
+    // Check www.msnbc.com and try clicking around to find the case where this happened.
+    if ((start && !end) || (end && !start))
+        return;
+
+    // Just return if the selection hasn't changed.
+    if (m_selectionStart == start && m_selectionStartPos == startPos &&
+        m_selectionEnd == end && m_selectionEndPos == endPos)
+        return;
+
+    // Record the old selected objects.  These will be used later
+    // when we compare against the new selected objects.
+    int oldStartPos = m_selectionStartPos;
+    int oldEndPos = m_selectionEndPos;
+
+    // Objects each have a single selection rect to examine.
+    typedef HashMap<RenderObject*, SelectionInfo*> SelectedObjectMap;
+    SelectedObjectMap oldSelectedObjects;
+    SelectedObjectMap newSelectedObjects;
+
+    // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
+    // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
+    // the union of those rects might remain the same even when changes have occurred.
+    typedef HashMap<RenderBlock*, BlockSelectionInfo*> SelectedBlockMap;
+    SelectedBlockMap oldSelectedBlocks;
+    SelectedBlockMap newSelectedBlocks;
+
+    RenderObject* os = m_selectionStart;
+    RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+    while (os && os != stop) {
+        if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
+            // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
+            oldSelectedObjects.set(os, new SelectionInfo(os, true));
+            RenderBlock* cb = os->containingBlock();
+            while (cb && !cb->isRenderView()) {
+                BlockSelectionInfo* blockInfo = oldSelectedBlocks.get(cb);
+                if (blockInfo)
+                    break;
+                oldSelectedBlocks.set(cb, new BlockSelectionInfo(cb));
+                cb = cb->containingBlock();
+            }
+        }
+
+        os = os->nextInPreOrder();
+    }
+
+    // Now clear the selection.
+    SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
+    for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
+        i->first->setSelectionState(SelectionNone);
+
+    // set selection start and end
+    m_selectionStart = start;
+    m_selectionStartPos = startPos;
+    m_selectionEnd = end;
+    m_selectionEndPos = endPos;
+
+    // Update the selection status of all objects between m_selectionStart and m_selectionEnd
+    if (start && start == end)
+        start->setSelectionState(SelectionBoth);
+    else {
+        if (start)
+            start->setSelectionState(SelectionStart);
+        if (end)
+            end->setSelectionState(SelectionEnd);
+    }
+
+    RenderObject* o = start;
+    stop = rendererAfterPosition(end, endPos);
+
+    while (o && o != stop) {
+        if (o != start && o != end && o->canBeSelectionLeaf())
+            o->setSelectionState(SelectionInside);
+        o = o->nextInPreOrder();
+    }
+
+    // Now that the selection state has been updated for the new objects, walk them again and
+    // put them in the new objects list.
+    o = start;
+    while (o && o != stop) {
+        if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
+            newSelectedObjects.set(o, new SelectionInfo(o, true));
+            RenderBlock* cb = o->containingBlock();
+            while (cb && !cb->isRenderView()) {
+                BlockSelectionInfo* blockInfo = newSelectedBlocks.get(cb);
+                if (blockInfo)
+                    break;
+                newSelectedBlocks.set(cb, new BlockSelectionInfo(cb));
+                cb = cb->containingBlock();
+            }
+        }
+
+        o = o->nextInPreOrder();
+    }
+
+    if (!m_frameView) {
+        // We built the maps, but we aren't going to use them.
+        // We need to delete the values, otherwise they'll all leak!
+        deleteAllValues(oldSelectedObjects);
+        deleteAllValues(newSelectedObjects);
+        deleteAllValues(oldSelectedBlocks);
+        deleteAllValues(newSelectedBlocks);
+        return;
+    }
+
+    // Have any of the old selected objects changed compared to the new selection?
+    for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
+        RenderObject* obj = i->first;
+        SelectionInfo* newInfo = newSelectedObjects.get(obj);
+        SelectionInfo* oldInfo = i->second;
+        if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
+            (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
+            (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
+            m_frameView->updateContents(oldInfo->rect());
+            if (newInfo) {
+                m_frameView->updateContents(newInfo->rect());
+                newSelectedObjects.remove(obj);
+                delete newInfo;
+            }
+        }
+        delete oldInfo;
+    }
+
+    // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
+    SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
+    for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i) {
+        SelectionInfo* newInfo = i->second;
+        m_frameView->updateContents(newInfo->rect());
+        delete newInfo;
+    }
+
+    // Have any of the old blocks changed?
+    SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
+    for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
+        RenderBlock* block = i->first;
+        BlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
+        BlockSelectionInfo* oldInfo = i->second;
+        if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
+            m_frameView->updateContents(oldInfo->rects());
+            if (newInfo) {
+                m_frameView->updateContents(newInfo->rects());
+                newSelectedBlocks.remove(block);
+                delete newInfo;
+            }
+        }
+        delete oldInfo;
+    }
+
+    // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
+    SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
+    for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i) {
+        BlockSelectionInfo* newInfo = i->second;
+        m_frameView->updateContents(newInfo->rects());
+        delete newInfo;
+    }
+}
+
+void RenderView::clearSelection()
+{
+    setSelection(0, -1, 0, -1);
+}
+
+void RenderView::selectionStartEnd(int& startPos, int& endPos) const
+{
+    startPos = m_selectionStartPos;
+    endPos = m_selectionEndPos;
+}
+
+bool RenderView::printing() const
+{
+    return document()->printing();
+}
+
+void RenderView::updateWidgetPositions()
+{
+    RenderObjectSet::iterator end = m_widgets.end();
+    for (RenderObjectSet::iterator it = m_widgets.begin(); it != end; ++it)
+        (*it)->updateWidgetPosition();
+}
+
+void RenderView::addWidget(RenderObject* o)
+{
+    m_widgets.add(o);
+}
+
+void RenderView::removeWidget(RenderObject* o)
+{
+    m_widgets.remove(o);
+}
+
+IntRect RenderView::viewRect() const
+{
+    if (printing())
+        return IntRect(0, 0, m_width, m_height);
+    if (m_frameView)
+        return enclosingIntRect(m_frameView->visibleContentRect());
+    return IntRect();
+}
+
+int RenderView::docHeight() const
+{
+    int h;
+    if (printing() || !m_frameView)
+        h = m_height;
+    else
+        h = m_frameView->visibleHeight();
+
+    int lowestPos = lowestPosition();
+    if (lowestPos > h)
+        h = lowestPos;
+
+    // FIXME: This doesn't do any margin collapsing.
+    // Instead of this dh computation we should keep the result
+    // when we call RenderBlock::layout.
+    int dh = 0;
+    for (RenderObject* c = firstChild(); c; c = c->nextSibling())
+        dh += c->height() + c->marginTop() + c->marginBottom();
+
+    if (dh > h)
+        h = dh;
+
+    return h;
+}
+
+int RenderView::docWidth() const
+{
+    int w;
+    if (printing() || !m_frameView)
+        w = m_width;
+    else
+        w = m_frameView->visibleWidth();
+
+    int rightmostPos = rightmostPosition();
+    if (rightmostPos > w)
+        w = rightmostPos;
+
+    for (RenderObject *c = firstChild(); c; c = c->nextSibling()) {
+        int dw = c->width() + c->marginLeft() + c->marginRight();
+        if (dw > w)
+            w = dw;
+    }
+
+    return w;
+}
+
+// The idea here is to take into account what object is moving the pagination point, and
+// thus choose the best place to chop it.
+void RenderView::setBestTruncatedAt(int y, RenderObject* forRenderer, bool forcedBreak)
+{
+    // Nobody else can set a page break once we have a forced break.
+    if (m_forcedPageBreak)
+        return;
+
+    // Forced breaks always win over unforced breaks.
+    if (forcedBreak) {
+        m_forcedPageBreak = true;
+        m_bestTruncatedAt = y;
+        return;
+    }
+
+    // prefer the widest object who tries to move the pagination point
+    int width = forRenderer->width();
+    if (width > m_truncatorWidth) {
+        m_truncatorWidth = width;
+        m_bestTruncatedAt = y;
+    }
+}
+
+void RenderView::pushLayoutState(RenderObject* root)
+{
+    ASSERT(!m_frameView->needsFullRepaint());
+    ASSERT(m_layoutStateDisableCount == 0);
+    ASSERT(m_layoutState == 0);
+
+    m_layoutState = new (renderArena()) LayoutState(root);
+}
+
+} // namespace WebCore