WebCore/khtml/rendering/render_flow.cpp

   1 /**
   2  * This file is part of the html renderer for KDE.
   3  *
   4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   6  * Copyright (C) 2003 Apple Computer, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23 // -------------------------------------------------------------------------
  24
  25 #include <kdebug.h>
  26 #include <assert.h>
  27 #include <qpainter.h>
  28 #include <kglobal.h>
  29
  30 #include "rendering/render_flow.h"
  31 #include "rendering/render_text.h"
  32 #include "rendering/render_table.h"
  33 #include "rendering/render_canvas.h"
  34 #include "xml/dom_nodeimpl.h"
  35 #include "xml/dom_docimpl.h"
  36 #include "html/html_formimpl.h"
  37 #include "render_inline.h"
  38 #include "render_block.h"
  39 #include "render_arena.h"
  40 #include "render_line.h"
  41
  42 #include "khtmlview.h"
  43 #include "htmltags.h"
  44
  45 using namespace DOM;
  46 using namespace khtml;
  47
  48 RenderFlow* RenderFlow::createAnonymousFlow(DOM::DocumentImpl* doc, RenderStyle* style)
  49 {
  50     RenderFlow* result;
  51     if (style->display() == INLINE)
  52         result = new (doc->renderArena()) RenderInline(doc);
  53     else
  54         result = new (doc->renderArena()) RenderBlock(doc);
  55     result->setStyle(style);
  56     return result;
  57 }
  58
  59 RenderFlow* RenderFlow::continuationBefore(RenderObject* beforeChild)
  60 {
  61     if (beforeChild && beforeChild->parent() == this)
  62         return this;
  63
  64     RenderFlow* curr = continuation();
  65     RenderFlow* nextToLast = this;
  66     RenderFlow* last = this;
  67     while (curr) {
  68         if (beforeChild && beforeChild->parent() == curr) {
  69             if (curr->firstChild() == beforeChild)
  70                 return last;
  71             return curr;
  72         }
  73
  74         nextToLast = last;
  75         last = curr;
  76         curr = curr->continuation();
  77     }
  78
  79     if (!beforeChild && !last->firstChild())
  80         return nextToLast;
  81     return last;
  82 }
  83
  84 void RenderFlow::addChildWithContinuation(RenderObject* newChild, RenderObject* beforeChild)
  85 {
  86     RenderFlow* flow = continuationBefore(beforeChild);
  87     KHTMLAssert(!beforeChild || beforeChild->parent()->isRenderBlock() ||
  88                 beforeChild->parent()->isRenderInline());
  89     RenderFlow* beforeChildParent = beforeChild ? static_cast<RenderFlow*>(beforeChild->parent()) :
  90                                     (flow->continuation() ? flow->continuation() : flow);
  91
  92     if (newChild->isFloatingOrPositioned())
  93         return beforeChildParent->addChildToFlow(newChild, beforeChild);
  94
  95     // A continuation always consists of two potential candidates: an inline or an anonymous
  96     // block box holding block children.
  97     bool childInline = newChild->isInline();
  98     bool bcpInline = beforeChildParent->isInline();
  99     bool flowInline = flow->isInline();
 100
 101     if (flow == beforeChildParent)
 102         return flow->addChildToFlow(newChild, beforeChild);
 103     else {
 104         // The goal here is to match up if we can, so that we can coalesce and create the
 105         // minimal # of continuations needed for the inline.
 106         if (childInline == bcpInline)
 107             return beforeChildParent->addChildToFlow(newChild, beforeChild);
 108         else if (flowInline == childInline)
 109             return flow->addChildToFlow(newChild, 0); // Just treat like an append.
 110         else
 111             return beforeChildParent->addChildToFlow(newChild, beforeChild);
 112     }
 113 }
 114
 115 void RenderFlow::addChild(RenderObject *newChild, RenderObject *beforeChild)
 116 {
 117 #ifdef DEBUG_LAYOUT
 118     kdDebug( 6040 ) << renderName() << "(RenderFlow)::addChild( " << newChild->renderName() <<
 119                        ", " << (beforeChild ? beforeChild->renderName() : "0") << " )" << endl;
 120     kdDebug( 6040 ) << "current height = " << m_height << endl;
 121 #endif
 122
 123     if (continuation())
 124         return addChildWithContinuation(newChild, beforeChild);
 125     return addChildToFlow(newChild, beforeChild);
 126 }
 127
 128 void RenderFlow::extractLineBox(InlineFlowBox* box)
 129 {
 130     m_lastLineBox = box->prevFlowBox();
 131     if (box == m_firstLineBox)
 132         m_firstLineBox = 0;
 133     if (box->prevLineBox())
 134         box->prevLineBox()->setNextLineBox(0);
 135     box->setPreviousLineBox(0);
 136     for (InlineRunBox* curr = box; curr; curr = curr->nextLineBox())
 137         curr->setExtracted();
 138 }
 139
 140 void RenderFlow::attachLineBox(InlineFlowBox* box)
 141 {
 142     if (m_lastLineBox) {
 143         m_lastLineBox->setNextLineBox(box);
 144         box->setPreviousLineBox(m_lastLineBox);
 145     }
 146     else
 147         m_firstLineBox = box;
 148     InlineFlowBox* last = box;
 149     for (InlineFlowBox* curr = box; curr; curr = curr->nextFlowBox()) {
 150         curr->setExtracted(false);
 151         last = curr;
 152     }
 153     m_lastLineBox = last;
 154 }
 155
 156 void RenderFlow::removeLineBox(InlineFlowBox* box)
 157 {
 158     if (box == m_firstLineBox)
 159         m_firstLineBox = box->nextFlowBox();
 160     if (box == m_lastLineBox)
 161         m_lastLineBox = box->prevFlowBox();
 162     if (box->nextLineBox())
 163         box->nextLineBox()->setPreviousLineBox(box->prevLineBox());
 164     if (box->prevLineBox())
 165         box->prevLineBox()->setNextLineBox(box->nextLineBox());
 166 }
 167
 168 void RenderFlow::deleteLineBoxes()
 169 {
 170     if (m_firstLineBox) {
 171         RenderArena* arena = renderArena();
 172         InlineRunBox *curr=m_firstLineBox, *next=0;
 173         while (curr) {
 174             next = curr->nextLineBox();
 175             curr->detach(arena);
 176             curr = next;
 177         }
 178         m_firstLineBox = 0;
 179         m_lastLineBox = 0;
 180     }
 181 }
 182
 183 void RenderFlow::detach()
 184 {
 185     if (!documentBeingDestroyed()) {
 186         if (m_firstLineBox) {
 187             // We can't wait for RenderContainer::detach to clear the selection,
 188             // because by then we will have nuked the line boxes.
 189             if (isSelectionBorder())
 190                 canvas()->clearSelection();
 191
 192             // If line boxes are contained inside a root, that means we're an inline.
 193             // In that case, we need to remove all the line boxes so that the parent
 194             // lines aren't pointing to deleted children. If the first line box does
 195             // not have a parent that means they are either already disconnected or
 196             // root lines that can just be destroyed without disconnecting.
 197             if (m_firstLineBox->parent()) {
 198                 for (InlineRunBox* box = m_firstLineBox; box; box = box->nextLineBox())
 199                     box->remove();
 200             }
 201
 202             // If we are an anonymous block, then our line boxes might have children
 203             // that will outlast this block. In the non-anonymous block case those
 204             // children will be destroyed by the time we return from this function.
 205             if (isAnonymousBlock()) {
 206                 for (InlineFlowBox* box = m_firstLineBox; box; box = box->nextFlowBox()) {
 207                     while (InlineBox *childBox = box->firstChild()) {
 208                         childBox->remove();
 209                     }
 210                 }
 211             }
 212         }
 213         else if (isInline() && parent())
 214             parent()->dirtyLinesFromChangedChild(this, false);
 215     }
 216
 217     deleteLineBoxes();
 218
 219     RenderContainer::detach();
 220 }
 221
 222 void RenderFlow::dirtyLinesFromChangedChild(RenderObject* child, bool adding)
 223 {
 224     if (!parent() || selfNeedsLayout() || isTable())
 225         return;
 226
 227     if (adding && !isInline() && (!child->nextSibling() || !firstLineBox())) {
 228         // An append onto the end of a block or we don't have any lines anyway.
 229         // In this case we don't have to dirty any specific lines.
 230         static_cast<RenderBlock*>(this)->setLinesAppended();
 231         return;
 232     }
 233
 234     // For an empty inline, go ahead and propagate the check up to our parent.
 235     if (isInline() && !firstLineBox())
 236         return parent()->dirtyLinesFromChangedChild(this);
 237
 238     // Try to figure out which line box we belong in.  First try to find a previous
 239     // line box by examining our siblings.  If we didn't find a line box, then use our
 240     // parent's first line box.
 241     RootInlineBox* box = 0;
 242     for (RenderObject* curr = child->previousSibling(); curr; curr = curr->previousSibling()) {
 243         if (curr->isFloatingOrPositioned())
 244             continue;
 245
 246         if (curr->isReplaced()) {
 247             InlineBox* wrapper = curr->inlineBoxWrapper();
 248             if (wrapper)
 249                 box = wrapper->root();
 250         }
 251         else if (curr->isText()) {
 252             InlineTextBox* textBox = static_cast<RenderText*>(curr)->lastTextBox();
 253             if (textBox)
 254                 box = textBox->root();
 255         }
 256         else if (curr->isInlineFlow()) {
 257             InlineRunBox* runBox = static_cast<RenderFlow*>(curr)->lastLineBox();
 258             if (runBox)
 259                 box = runBox->root();
 260         }
 261
 262         if (box)
 263             break;
 264     }
 265     if (!box && firstLineBox())
 266         box = firstLineBox()->root();
 267
 268     // If we found a line box, then dirty it.
 269     if (box) {
 270         box->markDirty();
 271         if (child->isBR()) {
 272             RootInlineBox* next = box->nextRootBox();
 273             if (next)
 274                 next->markDirty();
 275         }
 276     }
 277 }
 278
 279 short RenderFlow::lineHeight(bool firstLine, bool isRootLineBox) const
 280 {
 281     if (firstLine) {
 282         RenderStyle* s = style(firstLine);
 283         Length lh = s->lineHeight();
 284         if (lh.value < 0) {
 285             if (s == style()) {
 286                 if (m_lineHeight == -1)
 287                     m_lineHeight = RenderObject::lineHeight(false);
 288                 return m_lineHeight;
 289             }
 290             return s->fontMetrics().lineSpacing();
 291         }
 292         if (lh.isPercent())
 293             return lh.minWidth(s->font().pixelSize());
 294         return lh.value;
 295     }
 296
 297     if (m_lineHeight == -1)
 298         m_lineHeight = RenderObject::lineHeight(false);
 299     return m_lineHeight;
 300 }
 301
 302 void RenderFlow::dirtyLineBoxes(bool fullLayout, bool isRootLineBox)
 303 {
 304     if (!isRootLineBox && isReplaced())
 305         return RenderContainer::dirtyLineBoxes(isRootLineBox);
 306
 307     if (fullLayout)
 308         deleteLineBoxes();
 309     else {
 310         for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox())
 311             curr->dirtyLineBoxes();
 312     }
 313 }
 314
 315 InlineBox* RenderFlow::createInlineBox(bool makePlaceHolderBox, bool isRootLineBox, bool isOnlyRun)
 316 {
 317     if (!isRootLineBox &&
 318         (isReplaced() || makePlaceHolderBox))                     // Inline tables and inline blocks
 319         return RenderContainer::createInlineBox(false, isRootLineBox);  // (or positioned element placeholders).
 320
 321     InlineFlowBox* flowBox = 0;
 322     if (isInlineFlow())
 323         flowBox = new (renderArena()) InlineFlowBox(this);
 324     else
 325         flowBox = new (renderArena()) RootInlineBox(this);
 326
 327     if (!m_firstLineBox)
 328         m_firstLineBox = m_lastLineBox = flowBox;
 329     else {
 330         m_lastLineBox->setNextLineBox(flowBox);
 331         flowBox->setPreviousLineBox(m_lastLineBox);
 332         m_lastLineBox = flowBox;
 333     }
 334
 335     return flowBox;
 336 }
 337
 338 void RenderFlow::paintLineBoxBackgroundBorder(PaintInfo& i, int _tx, int _ty)
 339 {
 340     if (!shouldPaintWithinRoot(i))
 341         return;
 342
 343     if (!firstLineBox())
 344         return;
 345
 346     if (style()->visibility() == VISIBLE && i.phase == PaintActionForeground) {
 347         // We can check the first box and last box and avoid painting if we don't
 348         // intersect.
 349         int yPos = _ty + firstLineBox()->yPos();
 350         int h = lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos();
 351         if( (yPos >= i.r.y() + i.r.height()) || (yPos + h <= i.r.y()))
 352             return;
 353
 354         // See if our boxes intersect with the dirty rect.  If so, then we paint
 355         // them.  Note that boxes can easily overlap, so we can't make any assumptions
 356         // based off positions of our first line box or our last line box.
 357         int xOffsetWithinLineBoxes = 0;
 358         for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
 359             yPos = _ty + curr->yPos();
 360             h = curr->height();
 361             if ((yPos < i.r.y() + i.r.height()) && (yPos + h > i.r.y()))
 362                 curr->paintBackgroundAndBorder(i, _tx, _ty, xOffsetWithinLineBoxes);
 363             xOffsetWithinLineBoxes += curr->width();
 364         }
 365     }
 366 }
 367
 368 void RenderFlow::paintLineBoxDecorations(PaintInfo& i, int _tx, int _ty, bool paintedChildren)
 369 {
 370     if (!shouldPaintWithinRoot(i))
 371         return;
 372
 373     // We only paint line box decorations in strict or almost strict mode.
 374     // Otherwise we let the InlineTextBoxes paint their own decorations.
 375     if (style()->htmlHacks() || !firstLineBox())
 376         return;
 377
 378     if (style()->visibility() == VISIBLE && i.phase == PaintActionForeground) {
 379         // We can check the first box and last box and avoid painting if we don't
 380         // intersect.
 381         int yPos = _ty + firstLineBox()->yPos();;
 382         int h = lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos();
 383         if( (yPos >= i.r.y() + i.r.height()) || (yPos + h <= i.r.y()))
 384             return;
 385
 386         // See if our boxes intersect with the dirty rect.  If so, then we paint
 387         // them.  Note that boxes can easily overlap, so we can't make any assumptions
 388         // based off positions of our first line box or our last line box.
 389         for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
 390             yPos = _ty + curr->yPos();
 391             h = curr->height();
 392             if ((yPos < i.r.y() + i.r.height()) && (yPos + h > i.r.y()))
 393                 curr->paintDecorations(i, _tx, _ty, paintedChildren);
 394         }
 395     }
 396 }
 397
 398 QRect RenderFlow::getAbsoluteRepaintRect()
 399 {
 400     if (isInlineFlow()) {
 401         // Find our leftmost position.
 402         int left = 0;
 403         int top = firstLineBox() ? firstLineBox()->yPos() : 0;
 404         for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox())
 405             if (curr == firstLineBox() || curr->xPos() < left)
 406                 left = curr->xPos();
 407
 408         // Now invalidate a rectangle.
 409         int ow = style() ? style()->outlineSize() : 0;
 410         if (isCompact())
 411             left -= m_x;
 412         if (style()->position() == RELATIVE && m_layer)
 413             m_layer->relativePositionOffset(left, top);
 414
 415         QRect r(-ow+left, -ow+top, width()+ow*2, height()+ow*2);
 416         RenderBlock* cb = containingBlock();
 417         if (cb->hasOverflowClip()) {
 418             // cb->height() is inaccurate if we're in the middle of a layout of |cb|, so use the
 419             // layer's size instead.  Even if the layer's size is wrong, the layer itself will repaint
 420             // anyway if its size does change.
 421             int x = r.left();
 422             int y = r.top();
 423             QRect boxRect(0, 0, cb->layer()->width(), cb->layer()->height());
 424             cb->layer()->subtractScrollOffset(x,y); // For overflow:auto/scroll/hidden.
 425             QRect repaintRect(x, y, r.width(), r.height());
 426             r = repaintRect.intersect(boxRect);
 427         }
 428
 429         cb->computeAbsoluteRepaintRect(r);
 430
 431         if (ow) {
 432             for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
 433                 if (!curr->isText()) {
 434                     QRect childRect = curr->getAbsoluteRepaintRectWithOutline(ow);
 435                     r = r.unite(childRect);
 436                 }
 437             }
 438
 439             if (continuation() && !continuation()->isInline()) {
 440                 QRect contRect = continuation()->getAbsoluteRepaintRectWithOutline(ow);
 441                 r = r.unite(contRect);
 442             }
 443         }
 444
 445         return r;
 446     }
 447     else {
 448         if (firstLineBox() && firstLineBox()->topOverflow() < 0) {
 449             int ow = style() ? style()->outlineSize() : 0;
 450             QRect r(-ow, -ow+firstLineBox()->topOverflow(),
 451                     overflowWidth(false)+ow*2,
 452                     overflowHeight(false)+ow*2-firstLineBox()->topOverflow());
 453             computeAbsoluteRepaintRect(r);
 454             return r;
 455         }
 456     }
 457
 458     return RenderContainer::getAbsoluteRepaintRect();
 459 }
 460
 461 int
 462 RenderFlow::lowestPosition(bool includeOverflowInterior, bool includeSelf) const
 463 {
 464     int bottom = RenderContainer::lowestPosition(includeOverflowInterior, includeSelf);
 465     if (!includeOverflowInterior && hasOverflowClip())
 466         return bottom;
 467
 468     // FIXME: Come up with a way to use the layer tree to avoid visiting all the kids.
 469     // For now, we have to descend into all the children, since we may have a huge abs div inside
 470     // a tiny rel div buried somewhere deep in our child tree.  In this case we have to get to
 471     // the abs div.
 472     for (RenderObject *c = firstChild(); c; c = c->nextSibling()) {
 473         if (!c->isFloatingOrPositioned() && !c->isText()) {
 474             int lp = c->yPos() + c->lowestPosition(false);
 475             bottom = kMax(bottom, lp);
 476         }
 477     }
 478
 479     return bottom;
 480 }
 481
 482 int RenderFlow::rightmostPosition(bool includeOverflowInterior, bool includeSelf) const
 483 {
 484     int right = RenderContainer::rightmostPosition(includeOverflowInterior, includeSelf);
 485     if (!includeOverflowInterior && hasOverflowClip())
 486         return right;
 487
 488     // FIXME: Come up with a way to use the layer tree to avoid visiting all the kids.
 489     // For now, we have to descend into all the children, since we may have a huge abs div inside
 490     // a tiny rel div buried somewhere deep in our child tree.  In this case we have to get to
 491     // the abs div.
 492     for (RenderObject *c = firstChild(); c; c = c->nextSibling()) {
 493         if (!c->isFloatingOrPositioned() && !c->isText()) {
 494             int rp = c->xPos() + c->rightmostPosition(false);
 495             right = kMax(right, rp);
 496         }
 497     }
 498
 499     return right;
 500 }
 501
 502 int RenderFlow::leftmostPosition(bool includeOverflowInterior, bool includeSelf) const
 503 {
 504     int left = RenderContainer::leftmostPosition(includeOverflowInterior, includeSelf);
 505     if (!includeOverflowInterior && hasOverflowClip())
 506         return left;
 507
 508     // FIXME: Come up with a way to use the layer tree to avoid visiting all the kids.
 509     // For now, we have to descend into all the children, since we may have a huge abs div inside
 510     // a tiny rel div buried somewhere deep in our child tree.  In this case we have to get to
 511     // the abs div.
 512     for (RenderObject *c = firstChild(); c; c = c->nextSibling()) {
 513         if (!c->isFloatingOrPositioned() && !c->isText()) {
 514             int lp = c->xPos() + c->leftmostPosition(false);
 515             left = kMin(left, lp);
 516         }
 517     }
 518
 519     return left;
 520 }
 521
 522 QRect RenderFlow::caretRect(int offset, EAffinity affinity)
 523 {
 524     if (firstChild() || style()->display() == INLINE) {
 525         // Do the normal calculation
 526         return RenderContainer::caretRect(offset, affinity);
 527     }
 528
 529     // This is a special case:
 530     // The element is not an inline element, and it's empty. So we have to
 531     // calculate a fake position to indicate where objects are to be inserted.
 532
 533     int _x, _y, width, height;
 534
 535     // EDIT FIXME: this does neither take into regard :first-line nor :first-letter
 536     // However, as soon as some content is entered, the line boxes will be
 537     // constructed properly and this kludge is not called any more. So only
 538     // the caret size of an empty :first-line'd block is wrong, but I think we
 539     // can live with that.
 540     RenderStyle *currentStyle = style(true);
 541     //height = currentStyle->fontMetrics().height();
 542     height = lineHeight(true);
 543     width = 1;
 544
 545     // EDIT FIXME: This needs to account for text direction
 546     int w = this->width();
 547     switch (currentStyle->textAlign()) {
 548         case LEFT:
 549         case KHTML_LEFT:
 550         case TAAUTO:
 551         case JUSTIFY:
 552         default:
 553             _x = 0;
 554             break;
 555         case CENTER:
 556         case KHTML_CENTER:
 557             _x = w / 2;
 558         break;
 559         case RIGHT:
 560         case KHTML_RIGHT:
 561             _x = w;
 562         break;
 563     }
 564
 565     _y = 0;
 566
 567     int absx, absy;
 568     absolutePosition(absx, absy, false);
 569     _x += absx + paddingLeft() + borderLeft();
 570     _y += absy + paddingTop() + borderTop();
 571
 572     return QRect(_x, _y, width, height);
 573 }