| /** |
| * 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, false)); |
| 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, false)); |
| 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 |
