summaryrefslogtreecommitdiffstats
path: root/khtml/rendering/render_canvas.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'khtml/rendering/render_canvas.cpp')
-rw-r--r--khtml/rendering/render_canvas.cpp780
1 files changed, 780 insertions, 0 deletions
diff --git a/khtml/rendering/render_canvas.cpp b/khtml/rendering/render_canvas.cpp
new file mode 100644
index 000000000..50cad914a
--- /dev/null
+++ b/khtml/rendering/render_canvas.cpp
@@ -0,0 +1,780 @@
+/**
+ * This file is part of the HTML widget for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ * (C) 2003 Apple Computer, Inc.
+ * (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
+ *
+ * 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 "rendering/render_canvas.h"
+#include "rendering/render_layer.h"
+#include "xml/dom_docimpl.h"
+
+#include "khtmlview.h"
+#include "khtml_part.h"
+#include <kdebug.h>
+#include <kglobal.h>
+
+using namespace khtml;
+
+//#define BOX_DEBUG
+//#define SPEED_DEBUG
+
+RenderCanvas::RenderCanvas(DOM::NodeImpl* node, KHTMLView *view)
+ : RenderBlock(node)
+{
+ // init RenderObject attributes
+ setInline(false);
+ setIsAnonymous(false);
+
+ m_view = view;
+ // try to contrain the width to the views width
+
+ m_minWidth = 0;
+ m_height = 0;
+
+ m_width = m_minWidth;
+ m_maxWidth = m_minWidth;
+
+ m_rootWidth = m_rootHeight = 0;
+ m_viewportWidth = m_viewportHeight = 0;
+ m_cachedDocWidth = m_cachedDocHeight = -1;
+
+ setPositioned(true); // to 0,0 :)
+
+ m_staticMode = false;
+ m_pagedMode = false;
+ m_printImages = true;
+
+ m_pageTop = 0;
+ m_pageBottom = 0;
+
+ m_page = 0;
+
+ m_maximalOutlineSize = 0;
+
+ m_selectionStart = 0;
+ m_selectionEnd = 0;
+ m_selectionStartPos = -1;
+ m_selectionEndPos = -1;
+
+ m_needsWidgetMasks = false;
+
+ // Create a new root layer for our layer hierarchy.
+ m_layer = new (node->getDocument()->renderArena()) RenderLayer(this);
+}
+
+RenderCanvas::~RenderCanvas()
+{
+ delete m_page;
+}
+
+void RenderCanvas::setStyle(RenderStyle* style)
+{
+ /*
+ if (m_pagedMode)
+ style->setOverflow(OHIDDEN); */
+ RenderBlock::setStyle(style);
+}
+
+void RenderCanvas::calcHeight()
+{
+ if (m_pagedMode || !m_view)
+ m_height = m_rootHeight;
+ else
+ m_height = m_view->visibleHeight();
+}
+
+void RenderCanvas::calcWidth()
+{
+ // the width gets set by KHTMLView::print when printing to a printer.
+ if(m_pagedMode || !m_view)
+ {
+ m_width = m_rootWidth;
+ return;
+ }
+
+ m_width = m_view ? m_view->frameWidth() : m_minWidth;
+
+ if (style()->marginLeft().isFixed())
+ m_marginLeft = style()->marginLeft().value();
+ else
+ m_marginLeft = 0;
+
+ if (style()->marginRight().isFixed())
+ m_marginRight = style()->marginRight().value();
+ else
+ m_marginRight = 0;
+}
+
+void RenderCanvas::calcMinMaxWidth()
+{
+ KHTMLAssert( !minMaxKnown() );
+
+ RenderBlock::calcMinMaxWidth();
+
+ m_maxWidth = m_minWidth;
+
+ setMinMaxKnown();
+}
+
+//#define SPEED_DEBUG
+
+void RenderCanvas::layout()
+{
+ if (m_pagedMode) {
+ m_minWidth = m_width;
+// m_maxWidth = m_width;
+ }
+
+ m_needsFullRepaint = markedForRepaint() || !view() || view()->needsFullRepaint() || m_pagedMode;
+
+ setChildNeedsLayout(true);
+ setMinMaxKnown(false);
+ for(RenderObject* c = firstChild(); c; c = c->nextSibling())
+ c->setChildNeedsLayout(true);
+
+ int oldWidth = m_width;
+ int oldHeight = m_height;
+
+ m_cachedDocWidth = m_cachedDocHeight = -1;
+
+ if (m_pagedMode || !m_view) {
+ m_width = m_rootWidth;
+ m_height = m_rootHeight;
+ }
+ else
+ {
+ m_viewportWidth = m_width = m_view->visibleWidth();
+ m_viewportHeight = m_height = m_view->visibleHeight();
+ }
+
+#ifdef SPEED_DEBUG
+ QTime qt;
+ qt.start();
+#endif
+
+ if ( recalcMinMax() )
+ recalcMinMaxWidths();
+
+#ifdef SPEED_DEBUG
+ kdDebug() << "RenderCanvas::calcMinMax time used=" << qt.elapsed() << endl;
+ qt.start();
+#endif
+
+ bool relayoutChildren = (oldWidth != m_width) || (oldHeight != m_height);
+
+ RenderBlock::layoutBlock( relayoutChildren );
+
+#ifdef SPEED_DEBUG
+ kdDebug() << "RenderCanvas::layout time used=" << qt.elapsed() << endl;
+ qt.start();
+#endif
+
+ updateDocumentSize();
+
+ layer()->updateLayerPositions( layer(), needsFullRepaint(), true );
+
+ if (!m_pagedMode && m_needsWidgetMasks)
+ layer()->updateWidgetMasks(layer());
+
+ scheduleDeferredRepaints();
+ setNeedsLayout(false);
+
+#ifdef SPEED_DEBUG
+ kdDebug() << "RenderCanvas::end time used=" << qt.elapsed() << endl;
+#endif
+}
+
+void RenderCanvas::updateDocumentSize()
+{
+ // update our cached document size
+ int hDocH = m_cachedDocHeight = docHeight();
+ int hDocW = m_cachedDocWidth = docWidth();
+
+ if (!m_pagedMode && m_view) {
+
+ bool vss = m_view->verticalScrollBar()->isShown();
+ bool hss = m_view->horizontalScrollBar()->isShown();
+ QSize s = m_view->viewportSize(m_cachedDocWidth, m_cachedDocHeight);
+
+ // if we are about to show a scrollbar, and the document is sized to the viewport w or h,
+ // then reserve the scrollbar space so that it doesn't trigger the _other_ scrollbar
+
+ if (!vss && m_width - m_view->verticalScrollBar()->sizeHint().width() == s.width() &&
+ m_cachedDocWidth <= m_width)
+ hDocW = kMin( m_cachedDocWidth, s.width() );
+
+ if (!hss && m_height - m_view->horizontalScrollBar()->sizeHint().height() == s.height() &&
+ m_cachedDocHeight <= m_height)
+ hDocH = kMin( m_cachedDocHeight, s.height() );
+
+ // likewise, if a scrollbar is shown, and we have a cunning plan to turn it off,
+ // think again if we are falling downright in the hysteresis zone
+
+ if (vss && s.width() > m_cachedDocWidth && m_cachedDocWidth > m_view->visibleWidth())
+ hDocW = s.width()+1;
+
+ if (hss && s.height() > m_cachedDocHeight && m_cachedDocHeight > m_view->visibleHeight())
+ hDocH = s.height()+1;
+
+ m_view->resizeContents(hDocW, hDocH);
+
+ setWidth( m_viewportWidth = s.width() );
+ setHeight( m_viewportHeight = s.height() );
+ }
+ layer()->resize( kMax( m_cachedDocWidth,int( m_width ) ), kMax( m_cachedDocHeight,m_height ) );
+}
+
+void RenderCanvas::updateDocSizeAfterLayerTranslation( RenderObject* o, bool posXOffset, bool posYOffset )
+{
+ if (needsLayout())
+ return;
+ int rightmost, lowest;
+ o->absolutePosition( rightmost, lowest );
+ if (posXOffset) {
+ rightmost += o->rightmostPosition(false, true);
+ setCachedDocWidth( kMax(docWidth(), rightmost) );
+ } else {
+ setCachedDocWidth( -1 );
+ }
+ if (posYOffset) {
+ lowest += o->lowestPosition(false, true);
+ setCachedDocHeight( kMax(docHeight(), lowest) );
+ } else {
+ setCachedDocHeight( -1 );
+ }
+// kdDebug() << " posXOffset: " << posXOffset << " posYOffset " << posYOffset << " m_cachedDocWidth " << m_cachedDocWidth << " m_cachedDocHeight " << m_cachedDocHeight << endl;
+ updateDocumentSize();
+}
+
+bool RenderCanvas::needsFullRepaint() const
+{
+ return m_needsFullRepaint || m_pagedMode;
+}
+
+void RenderCanvas::repaintViewRectangle(int x, int y, int w, int h, bool asap)
+{
+ KHTMLAssert( view() );
+ view()->scheduleRepaint( x, y, w, h, asap );
+}
+
+bool RenderCanvas::absolutePosition(int &xPos, int &yPos, bool f) const
+{
+ if ( f && m_pagedMode) {
+ xPos = 0;
+ yPos = m_pageTop;
+ }
+ else if ( f && m_view) {
+ xPos = m_view->contentsX();
+ yPos = m_view->contentsY();
+ }
+ else {
+ xPos = yPos = 0;
+ }
+ return true;
+}
+
+void RenderCanvas::paint(PaintInfo& paintInfo, int _tx, int _ty)
+{
+#ifdef DEBUG_LAYOUT
+ kdDebug( 6040 ) << renderName() << this << " ::paintObject() w/h = (" << width() << "/" << height() << ")" << endl;
+#endif
+
+ // 1. paint background, borders etc
+ if(paintInfo.phase == PaintActionElementBackground) {
+ paintBoxDecorations(paintInfo, _tx, _ty);
+ return;
+ }
+
+ // 2. paint contents
+ for( RenderObject *child = firstChild(); child; child=child->nextSibling())
+ if(!child->layer() && !child->isFloating())
+ child->paint(paintInfo, _tx, _ty);
+
+ // 3. paint floats.
+ if (paintInfo.phase == PaintActionFloat)
+ paintFloats(paintInfo, _tx, _ty);
+
+#ifdef BOX_DEBUG
+ if (m_view)
+ {
+ _tx += m_view->contentsX();
+ _ty += m_view->contentsY();
+ }
+
+ outlineBox(p, _tx, _ty);
+#endif
+
+}
+
+void RenderCanvas::paintBoxDecorations(PaintInfo& paintInfo, int /*_tx*/, int /*_ty*/)
+{
+ if ((firstChild() && firstChild()->style()->visibility() == VISIBLE) || !view())
+ return;
+
+ paintInfo.p->fillRect(paintInfo.r, view()->palette().active().color(QColorGroup::Base));
+}
+
+void RenderCanvas::repaintRectangle(int x, int y, int w, int h, Priority p, bool f)
+{
+ if (m_staticMode) return;
+// kdDebug( 6040 ) << "updating views contents (" << x << "/" << y << ") (" << w << "/" << h << ")" << endl;
+
+ if (f && m_pagedMode) {
+ y += m_pageTop;
+ } else
+ if ( f && m_view ) {
+ x += m_view->contentsX();
+ y += m_view->contentsY();
+ }
+
+ QRect vr = viewRect();
+ QRect ur(x, y, w, h);
+
+ if (m_view && ur.intersects(vr)) {
+
+ if (p == RealtimePriority)
+ // ### KWQ's updateContents has an additional parameter "now".
+ // It's not clear what the difference between updateContents(...,true)
+ // and repaintContents(...) is. As Qt doesn't have this, I'm leaving it out. (LS)
+ m_view->updateContents(ur/*, true*/);
+ else if (p == HighPriority)
+ m_view->scheduleRepaint(x, y, w, h, true /*asap*/);
+ else
+ m_view->scheduleRepaint(x, y, w, h);
+ }
+}
+
+void RenderCanvas::deferredRepaint( RenderObject* o )
+{
+ m_dirtyChildren.append( o );
+}
+
+void RenderCanvas::scheduleDeferredRepaints()
+{
+ if (!needsFullRepaint()) {
+ QValueList<RenderObject*>::const_iterator it;
+ for ( it = m_dirtyChildren.begin(); it != m_dirtyChildren.end(); ++it )
+ (*it)->repaint();
+ }
+ //kdDebug(6040) << "scheduled deferred repaints: " << m_dirtyChildren.count() << " needed full repaint: " << needsFullRepaint() << endl;
+ m_dirtyChildren.clear();
+}
+
+void RenderCanvas::repaint(Priority p)
+{
+ if (m_view && !m_staticMode) {
+ if (p == RealtimePriority) {
+ //m_view->resizeContents(docWidth(), docHeight());
+ m_view->unscheduleRepaint();
+ if (needsLayout()) {
+ m_view->scheduleRelayout();
+ return;
+ }
+ // ### same as in repaintRectangle
+ m_view->updateContents(m_view->contentsX(), m_view->contentsY(),
+ m_view->visibleWidth(), m_view->visibleHeight()/*, true*/);
+ }
+ else if (p == HighPriority)
+ m_view->scheduleRepaint(m_view->contentsX(), m_view->contentsY(),
+ m_view->visibleWidth(), m_view->visibleHeight(), true /*asap*/);
+ else
+ m_view->scheduleRepaint(m_view->contentsX(), m_view->contentsY(),
+ m_view->visibleWidth(), m_view->visibleHeight());
+ }
+}
+
+static QRect enclosingPositionedRect (RenderObject *n)
+{
+ RenderObject *enclosingParent = n->containingBlock();
+ QRect rect(0,0,0,0);
+ if (enclosingParent) {
+ int ox, oy;
+ enclosingParent->absolutePosition(ox, oy);
+ int off = 0;
+ if (!enclosingParent->hasOverflowClip()) {
+ ox += enclosingParent->overflowLeft();
+ oy += enclosingParent->overflowTop();
+ }
+ rect.setX(ox);
+ rect.setY(oy);
+ rect.setWidth(enclosingParent->effectiveWidth());
+ rect.setHeight(enclosingParent->effectiveHeight());
+ }
+ return rect;
+}
+
+QRect RenderCanvas::selectionRect() const
+{
+ RenderObject *r = m_selectionStart;
+ if (!r)
+ return QRect();
+
+ QRect selectionRect = enclosingPositionedRect(r);
+
+ while (r && r != m_selectionEnd)
+ {
+ RenderObject* n;
+ if ( !(n = r->firstChild()) ){
+ if ( !(n = r->nextSibling()) )
+ {
+ n = r->parent();
+ while (n && !n->nextSibling())
+ n = n->parent();
+ if (n)
+ n = n->nextSibling();
+ }
+ }
+ r = n;
+ if (r) {
+ selectionRect = selectionRect.unite(enclosingPositionedRect(r));
+ }
+ }
+
+ return selectionRect;
+}
+
+void RenderCanvas::setSelection(RenderObject *s, int sp, RenderObject *e, int ep)
+{
+ // Check we got valid renderobjects. www.msnbc.com and clicking
+ // around, to find the case where this happened.
+ if ( !s || !e )
+ {
+ kdWarning(6040) << "RenderCanvas::setSelection() called with start=" << s << " end=" << e << endl;
+ return;
+ }
+// kdDebug( 6040 ) << "RenderCanvas::setSelection(" << s << "," << sp << "," << e << "," << ep << ")" << endl;
+
+ bool changedSelectionBorder = ( s != m_selectionStart || e != m_selectionEnd );
+
+ // Cut out early if the selection hasn't changed.
+ if ( !changedSelectionBorder && m_selectionStartPos == sp && m_selectionEndPos == ep )
+ return;
+
+ // Record the old selected objects. Will be used later
+ // to delta against the selected objects.
+
+ RenderObject *oldStart = m_selectionStart;
+ int oldStartPos = m_selectionStartPos;
+ RenderObject *oldEnd = m_selectionEnd;
+ int oldEndPos = m_selectionEndPos;
+ QPtrList<RenderObject> oldSelectedInside;
+ QPtrList<RenderObject> newSelectedInside;
+ RenderObject *os = oldStart;
+
+ while (os && os != oldEnd)
+ {
+ RenderObject* no;
+ if ( !(no = os->firstChild()) ){
+ if ( !(no = os->nextSibling()) )
+ {
+ no = os->parent();
+ while (no && !no->nextSibling())
+ no = no->parent();
+ if (no)
+ no = no->nextSibling();
+ }
+ }
+ if (os->selectionState() == SelectionInside && !oldSelectedInside.containsRef(os))
+ oldSelectedInside.append(os);
+
+ os = no;
+ }
+ if (changedSelectionBorder)
+ clearSelection(false);
+
+ while (s->firstChild())
+ s = s->firstChild();
+ while (e->lastChild())
+ e = e->lastChild();
+
+#if 0
+ bool changedSelectionBorder = ( s != m_selectionStart || e != m_selectionEnd );
+
+ if ( !changedSelectionBorder && m_selectionStartPos == sp && m_selectionEndPos = ep )
+ return;
+#endif
+
+ // set selection start
+ if (m_selectionStart)
+ m_selectionStart->setIsSelectionBorder(false);
+ m_selectionStart = s;
+ if (m_selectionStart)
+ m_selectionStart->setIsSelectionBorder(true);
+ m_selectionStartPos = sp;
+
+ // set selection end
+ if (m_selectionEnd)
+ m_selectionEnd->setIsSelectionBorder(false);
+ m_selectionEnd = e;
+ if (m_selectionEnd)
+ m_selectionEnd->setIsSelectionBorder(true);
+ m_selectionEndPos = ep;
+
+#if 0
+ kdDebug( 6040 ) << "old selection (" << oldStart << "," << oldStartPos << "," << oldEnd << "," << oldEndPos << ")" << endl;
+ kdDebug( 6040 ) << "new selection (" << s << "," << sp << "," << e << "," << ep << ")" << endl;
+#endif
+
+ // update selection status of all objects between m_selectionStart and m_selectionEnd
+ RenderObject* o = s;
+
+ while (o && o!=e)
+ {
+ o->setSelectionState(SelectionInside);
+// kdDebug( 6040 ) << "setting selected " << o << ", " << o->isText() << endl;
+ RenderObject* no;
+ if ( !(no = o->firstChild()) )
+ if ( !(no = o->nextSibling()) )
+ {
+ no = o->parent();
+ while (no && !no->nextSibling())
+ no = no->parent();
+ if (no)
+ no = no->nextSibling();
+ }
+ if (o->selectionState() == SelectionInside && !newSelectedInside.containsRef(o))
+ newSelectedInside.append(o);
+
+ o=no;
+ }
+ s->setSelectionState(SelectionStart);
+ e->setSelectionState(SelectionEnd);
+ if(s == e) s->setSelectionState(SelectionBoth);
+
+ if (!m_view)
+ return;
+
+ newSelectedInside.removeRef(s);
+ newSelectedInside.removeRef(e);
+
+ QRect updateRect;
+
+ // Don't use repaint() because it will cause all rects to
+ // be united (see khtmlview::scheduleRepaint()). Instead
+ // just draw damage rects for objects that have a change
+ // in selection state.
+ // ### for Qt, updateContents will unite them, too. This has to be
+ // circumvented somehow (LS)
+
+ // Are any of the old fully selected objects not in the new selection?
+ // If so we have to draw them.
+ // Could be faster by building list of non-intersecting rectangles rather
+ // than unioning rectangles.
+ QPtrListIterator<RenderObject> oldIterator(oldSelectedInside);
+ bool firstRect = true;
+ for (; oldIterator.current(); ++oldIterator){
+ if (!newSelectedInside.containsRef(oldIterator.current())){
+ if (firstRect){
+ updateRect = enclosingPositionedRect(oldIterator.current());
+ firstRect = false;
+ }
+ else
+ updateRect = updateRect.unite(enclosingPositionedRect(oldIterator.current()));
+ }
+ }
+ if (!firstRect){
+ m_view->updateContents( updateRect );
+ }
+
+ // Are any of the new fully selected objects not in the previous selection?
+ // If so we have to draw them.
+ // Could be faster by building list of non-intersecting rectangles rather
+ // than unioning rectangles.
+ QPtrListIterator<RenderObject> newIterator(newSelectedInside);
+ firstRect = true;
+ for (; newIterator.current(); ++newIterator){
+ if (!oldSelectedInside.containsRef(newIterator.current())){
+ if (firstRect){
+ updateRect = enclosingPositionedRect(newIterator.current());
+ firstRect = false;
+ }
+ else
+ updateRect = updateRect.unite(enclosingPositionedRect(newIterator.current()));
+ }
+ }
+ if (!firstRect) {
+ m_view->updateContents( updateRect );
+ }
+
+ // Is the new starting object different, or did the position in the starting
+ // element change? If so we have to draw it.
+ if (oldStart != m_selectionStart ||
+ (oldStart == oldEnd && (oldStartPos != m_selectionStartPos || oldEndPos != m_selectionEndPos)) ||
+ (oldStart == m_selectionStart && oldStartPos != m_selectionStartPos)){
+ m_view->updateContents( enclosingPositionedRect(m_selectionStart) );
+ }
+
+ // Draw the old selection start object if it's different than the new selection
+ // start object.
+ if (oldStart && oldStart != m_selectionStart){
+ m_view->updateContents( enclosingPositionedRect(oldStart) );
+ }
+
+ // Does the selection span objects and is the new end object different, or did the position
+ // in the end element change? If so we have to draw it.
+ if (/*(oldStart != oldEnd || !oldEnd) &&*/
+ (oldEnd != m_selectionEnd ||
+ (oldEnd == m_selectionEnd && oldEndPos != m_selectionEndPos))){
+ m_view->updateContents( enclosingPositionedRect(m_selectionEnd) );
+ }
+
+ // Draw the old selection end object if it's different than the new selection
+ // end object.
+ if (oldEnd && oldEnd != m_selectionEnd){
+ m_view->updateContents( enclosingPositionedRect(oldEnd) );
+ }
+}
+
+void RenderCanvas::clearSelection(bool doRepaint)
+{
+ // update selection status of all objects between m_selectionStart and m_selectionEnd
+ RenderObject* o = m_selectionStart;
+ while (o && o!=m_selectionEnd)
+ {
+ if (o->selectionState()!=SelectionNone)
+ if (doRepaint)
+ o->repaint();
+ o->setSelectionState(SelectionNone);
+ o->repaint();
+ RenderObject* no;
+ if ( !(no = o->firstChild()) )
+ if ( !(no = o->nextSibling()) )
+ {
+ no = o->parent();
+ while (no && !no->nextSibling())
+ no = no->parent();
+ if (no)
+ no = no->nextSibling();
+ }
+ o=no;
+ }
+ if (m_selectionEnd) {
+ m_selectionEnd->setSelectionState(SelectionNone);
+ if (doRepaint)
+ m_selectionEnd->repaint();
+ }
+
+ // set selection start & end to 0
+ if (m_selectionStart)
+ m_selectionStart->setIsSelectionBorder(false);
+ m_selectionStart = 0;
+ m_selectionStartPos = -1;
+
+ if (m_selectionEnd)
+ m_selectionEnd->setIsSelectionBorder(false);
+ m_selectionEnd = 0;
+ m_selectionEndPos = -1;
+}
+
+void RenderCanvas::selectionStartEnd(int& spos, int& epos)
+{
+ spos = m_selectionStartPos;
+ epos = m_selectionEndPos;
+}
+
+QRect RenderCanvas::viewRect() const
+{
+ if (m_pagedMode)
+ if (m_pageTop == m_pageBottom) {
+ kdDebug(6040) << "viewRect: " << QRect(0, m_pageTop, m_width, m_height) << endl;
+ return QRect(0, m_pageTop, m_width, m_height);
+ }
+ else {
+ kdDebug(6040) << "viewRect: " << QRect(0, m_pageTop, m_width, m_pageBottom - m_pageTop) << endl;
+ return QRect(0, m_pageTop, m_width, m_pageBottom - m_pageTop);
+ }
+ else if (m_view)
+ return QRect(m_view->contentsX(),
+ m_view->contentsY(),
+ m_view->visibleWidth(),
+ m_view->visibleHeight());
+ else
+ return QRect(0,0,m_rootWidth,m_rootHeight);
+}
+
+int RenderCanvas::docHeight() const
+{
+ if (m_cachedDocHeight != -1)
+ return m_cachedDocHeight;
+
+ int h;
+ if (m_pagedMode || !m_view)
+ h = m_height;
+ else
+ h = 0;
+
+ RenderObject *fc = firstChild();
+ if(fc) {
+ int dh = fc->overflowHeight() + fc->marginTop() + fc->marginBottom();
+ int lowestPos = fc->lowestPosition(false);
+// kdDebug(6040) << "h " << h << " lowestPos " << lowestPos << " dh " << dh << " fc->rh " << fc->effectiveHeight() << " fc->height() " << fc->height() << endl;
+ if( lowestPos > dh )
+ dh = lowestPos;
+ lowestPos = lowestAbsolutePosition();
+ if( lowestPos > dh )
+ dh = lowestPos;
+ if( dh > h )
+ h = dh;
+ }
+
+ RenderLayer *layer = m_layer;
+ h = kMax( h, layer->yPos() + layer->height() );
+// kdDebug(6040) << "h " << h << " layer(" << layer->renderer()->renderName() << "@" << layer->renderer() << ")->height " << layer->height() << " lp " << (layer->yPos() + layer->height()) << " height() " << layer->renderer()->height() << " rh " << layer->renderer()->effectiveHeight() << endl;
+ return h;
+}
+
+int RenderCanvas::docWidth() const
+{
+ if (m_cachedDocWidth != -1)
+ return m_cachedDocWidth;
+
+ int w;
+ if (m_pagedMode || !m_view)
+ w = m_width;
+ else
+ w = 0;
+
+ RenderObject *fc = firstChild();
+ if(fc) {
+ // ow: like effectiveWidth() but without the negative
+ const int ow = fc->hasOverflowClip() ? fc->width() : fc->overflowWidth();
+ int dw = ow + fc->marginLeft() + fc->marginRight();
+ int rightmostPos = fc->rightmostPosition(false);
+// kdDebug(6040) << "w " << w << " rightmostPos " << rightmostPos << " dw " << dw << " fc->rw " << fc->effectiveWidth() << " fc->width() " << fc->width() << endl;
+ if( rightmostPos > dw )
+ dw = rightmostPos;
+ rightmostPos = rightmostAbsolutePosition();
+ if ( rightmostPos > dw )
+ dw = rightmostPos;
+ if( dw > w )
+ w = dw;
+ }
+
+ RenderLayer *layer = m_layer;
+ w = kMax( w, layer->xPos() + layer->width() );
+// kdDebug(6040) << "w " << w << " layer(" << layer->renderer()->renderName() << ")->width " << layer->width() << " rm " << (layer->xPos() + layer->width()) << " width() " << layer->renderer()->width() << " rw " << layer->renderer()->effectiveWidth() << endl;
+ return w;
+}
+
+RenderPage* RenderCanvas::page() {
+ if (!m_page) m_page = new RenderPage(this);
+ return m_page;
+}