/** * 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., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, 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 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& 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 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 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 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