WebCore/khtml/rendering/render_table.cpp

   1 /**
   2  * This file is part of the DOM implementation for KDE.
   3  *
   4  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
   5  *           (C) 1997 Torben Weis (weis@kde.org)
   6  *           (C) 1998 Waldo Bastian (bastian@kde.org)
   7  *           (C) 1999 Lars Knoll (knoll@kde.org)
   8  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   9  * Copyright (C) 2003 Apple Computer, Inc.
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Library General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Library General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Library General Public License
  22  * along with this library; see the file COPYING.LIB.  If not, write to
  23  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24  * Boston, MA 02111-1307, USA.
  25  */
  26
  27 //#define TABLE_DEBUG
  28 //#define TABLE_PRINT
  29 //#define DEBUG_LAYOUT
  30 //#define BOX_DEBUG
  31 #include "rendering/render_table.h"
  32 #include "rendering/table_layout.h"
  33 #include "html/html_tableimpl.h"
  34 #include "misc/htmltags.h"
  35 #include "misc/htmlattrs.h"
  36 #include "xml/dom_docimpl.h"
  37
  38 #include <kglobal.h>
  39
  40 #include <qapplication.h>
  41 #include <qstyle.h>
  42
  43 #include <kdebug.h>
  44 #include <assert.h>
  45
  46 #include "khtmlview.h"
  47
  48 using namespace khtml;
  49 using namespace DOM;
  50
  51 RenderTable::RenderTable(DOM::NodeImpl* node)
  52     : RenderBlock(node)
  53 {
  54
  55     tCaption = 0;
  56     head = foot = firstBody = 0;
  57     tableLayout = 0;
  58     m_currentBorder = 0;
  59
  60     rules = None;
  61     frame = Void;
  62     has_col_elems = false;
  63     hspacing = 0;
  64     vspacing = 0;
  65     padding = 0;
  66     needSectionRecalc = false;
  67     padding = 0;
  68
  69     columnPos.resize( 2 );
  70     columnPos.fill( 0 );
  71     columns.resize( 1 );
  72     columns.fill( ColumnStruct() );
  73
  74     columnPos[0] = 0;
  75 }
  76
  77 RenderTable::~RenderTable()
  78 {
  79     delete tableLayout;
  80 }
  81
  82 void RenderTable::setStyle(RenderStyle *_style)
  83 {
  84     ETableLayout oldTableLayout = style() ? style()->tableLayout() : TAUTO;
  85     RenderBlock::setStyle(_style);
  86
  87     // In the collapsed border model, there is no cell spacing.
  88     hspacing = collapseBorders() ? 0 : style()->horizontalBorderSpacing();
  89     vspacing = collapseBorders() ? 0 : style()->verticalBorderSpacing();
  90     columnPos[0] = hspacing;
  91
  92     if ( !tableLayout || style()->tableLayout() != oldTableLayout ) {
  93         delete tableLayout;
  94
  95         // According to the CSS2 spec, you only use fixed table layout if an
  96         // explicit width is specified on the table.  Auto width implies auto table layout.
  97         if (style()->tableLayout() == TFIXED && !style()->width().isVariable()) {
  98             tableLayout = new FixedTableLayout(this);
  99 #ifdef DEBUG_LAYOUT
 100             kdDebug( 6040 ) << "using fixed table layout" << endl;
 101 #endif
 102         } else
 103             tableLayout = new AutoTableLayout(this);
 104     }
 105 }
 106
 107 void RenderTable::addChild(RenderObject *child, RenderObject *beforeChild)
 108 {
 109 #ifdef DEBUG_LAYOUT
 110     kdDebug( 6040 ) << renderName() << "(Table)::addChild( " << child->renderName() << ", " <<
 111                        (beforeChild ? beforeChild->renderName() : "0") << " )" << endl;
 112 #endif
 113     RenderObject *o = child;
 114
 115     if (child->element() && child->element()->id() == ID_FORM) {
 116         RenderContainer::addChild(child,beforeChild);
 117         return;
 118     }
 119
 120     switch(child->style()->display())
 121     {
 122     case TABLE_CAPTION:
 123         tCaption = static_cast<RenderBlock *>(child);
 124         break;
 125     case TABLE_COLUMN:
 126     case TABLE_COLUMN_GROUP:
 127         has_col_elems = true;
 128         break;
 129     case TABLE_HEADER_GROUP:
 130         if ( !head )
 131             head = static_cast<RenderTableSection *>(child);
 132         else if ( !firstBody )
 133             firstBody = static_cast<RenderTableSection *>(child);
 134         break;
 135     case TABLE_FOOTER_GROUP:
 136         if ( !foot ) {
 137             foot = static_cast<RenderTableSection *>(child);
 138             break;
 139         }
 140         // fall through
 141     case TABLE_ROW_GROUP:
 142         if(!firstBody)
 143             firstBody = static_cast<RenderTableSection *>(child);
 144         break;
 145     default:
 146         if ( !beforeChild && lastChild() &&
 147              lastChild()->isTableSection() && lastChild()->isAnonymous() ) {
 148             o = lastChild();
 149         } else {
 150             RenderObject *lastBox = beforeChild;
 151             while ( lastBox && lastBox->parent()->isAnonymous() &&
 152                     !lastBox->isTableSection() && lastBox->style()->display() != TABLE_CAPTION )
 153                 lastBox = lastBox->parent();
 154             if ( lastBox && lastBox->isAnonymous() ) {
 155                 lastBox->addChild( child, beforeChild );
 156                 return;
 157             } else {
 158                 if ( beforeChild && !beforeChild->isTableSection() )
 159                     beforeChild = 0;
 160                 //kdDebug( 6040 ) << this <<" creating anonymous table section beforeChild="<< beforeChild << endl;
 161                 o = new (renderArena()) RenderTableSection(document() /* anonymous */);
 162                 RenderStyle *newStyle = new (renderArena()) RenderStyle();
 163                 newStyle->inheritFrom(style());
 164                 newStyle->setDisplay(TABLE_ROW_GROUP);
 165                 o->setStyle(newStyle);
 166                 addChild(o, beforeChild);
 167             }
 168         }
 169         o->addChild(child);
 170         child->setNeedsLayoutAndMinMaxRecalc();
 171         return;
 172     }
 173     RenderContainer::addChild(child,beforeChild);
 174 }
 175
 176
 177
 178 void RenderTable::calcWidth()
 179 {
 180     if ( isPositioned() ) {
 181         calcAbsoluteHorizontal();
 182     }
 183
 184     RenderBlock *cb = containingBlock();
 185     int availableWidth = cb->contentWidth();
 186
 187     LengthType widthType = style()->width().type;
 188     if (widthType > Relative && style()->width().value > 0) {
 189         // Percent or fixed table
 190         m_width = style()->width().minWidth( availableWidth );
 191         if(m_minWidth > m_width) m_width = m_minWidth;
 192     }
 193     else {
 194         // An auto width table should shrink to fit within the line width if necessary in order to
 195         // avoid overlapping floats.
 196         availableWidth = cb->lineWidth( m_y );
 197
 198         // Subtract out any fixed margins from our available width for auto width tables.
 199         int marginTotal = 0;
 200         if (style()->marginLeft().type != Variable)
 201             marginTotal += style()->marginLeft().width(availableWidth);
 202         if (style()->marginRight().type != Variable)
 203             marginTotal += style()->marginRight().width(availableWidth);
 204
 205         // Subtract out our margins to get the available content width.
 206         int availContentWidth = kMax(0, availableWidth - marginTotal);
 207
 208         // Ensure we aren't bigger than our max width or smaller than our min width.
 209         m_width = kMin(availContentWidth, m_maxWidth);
 210     }
 211
 212     m_width = kMax(m_width, m_minWidth);
 213
 214     // Finally, with our true width determined, compute our margins for real.
 215     m_marginRight = 0;
 216     m_marginLeft = 0;
 217     calcHorizontalMargins(style()->marginLeft(),style()->marginRight(),availableWidth);
 218 }
 219
 220 void RenderTable::layout()
 221 {
 222     KHTMLAssert( needsLayout() );
 223     KHTMLAssert( minMaxKnown() );
 224     KHTMLAssert( !needSectionRecalc );
 225
 226     if (posChildNeedsLayout() && !normalChildNeedsLayout() && !selfNeedsLayout()) {
 227         // All we have to is lay out our positioned objects.
 228         layoutPositionedObjects(true);
 229         setNeedsLayout(false);
 230         return;
 231     }
 232
 233     QRect oldBounds, oldFullBounds;
 234     bool checkForRepaint = checkForRepaintDuringLayout();
 235     if (checkForRepaint)
 236         getAbsoluteRepaintRectIncludingFloats(oldBounds, oldFullBounds);
 237
 238     //kdDebug( 6040 ) << renderName() << "(Table)"<< this << " ::layout0() width=" << width() << ", needsLayout=" << needsLayout() << endl;
 239
 240     m_height = 0;
 241     initMaxMarginValues();
 242
 243     //int oldWidth = m_width;
 244     calcWidth();
 245
 246     // the optimisation below doesn't work since the internal table
 247     // layout could have changed.  we need to add a flag to the table
 248     // layout that tells us if something has changed in the min max
 249     // calculations to do it correctly.
 250 //     if ( oldWidth != m_width || columns.size() + 1 != columnPos.size() )
 251     tableLayout->layout();
 252
 253 #ifdef DEBUG_LAYOUT
 254     kdDebug( 6040 ) << renderName() << "(Table)::layout1() width=" << width() << ", marginLeft=" << marginLeft() << " marginRight=" << marginRight() << endl;
 255 #endif
 256
 257     setCellWidths();
 258
 259     // layout child objects
 260     int calculatedHeight = 0;
 261
 262     RenderObject *child = firstChild();
 263     while( child ) {
 264         if ( child->needsLayout() && !(child->element() && child->element()->id() == ID_FORM))
 265             child->layout();
 266         if ( child->isTableSection() ) {
 267             static_cast<RenderTableSection *>(child)->calcRowHeight();
 268             calculatedHeight += static_cast<RenderTableSection *>(child)->layoutRows( 0 );
 269         }
 270         child = child->nextSibling();
 271     }
 272
 273     // ### collapse caption margin
 274     if(tCaption && tCaption->style()->captionSide() != CAPBOTTOM) {
 275         tCaption->setPos(tCaption->marginLeft(), m_height);
 276         m_height += tCaption->height() + tCaption->marginTop() + tCaption->marginBottom();
 277     }
 278
 279     int bpTop = borderTop() + (collapseBorders() ? 0 : paddingTop());
 280     int bpBottom = borderBottom() + (collapseBorders() ? 0 : paddingBottom());
 281
 282     m_height += bpTop;
 283
 284     int oldHeight = m_height;
 285     calcHeight();
 286     int newHeight = m_height;
 287     m_height = oldHeight;
 288
 289     Length h = style()->height();
 290     int th = 0;
 291     if (isPositioned())
 292         th = newHeight; // FIXME: Leave this alone for now but investigate later.
 293     else if (h.isFixed())
 294         th = h.value - (bpTop + bpBottom);  // Tables size as though CSS height includes border/padding.
 295     else if (h.isPercent())
 296         th = calcPercentageHeight(h);
 297     th = kMax(0, th);
 298
 299     // layout rows
 300     if ( th > calculatedHeight ) {
 301         // we have to redistribute that height to get the constraint correctly
 302         // just force the first body to the height needed
 303         // ### FIXME This should take height constraints on all table sections into account and distribute
 304         // accordingly. For now this should be good enough
 305         if (firstBody) {
 306             firstBody->calcRowHeight();
 307             firstBody->layoutRows( th - calculatedHeight );
 308         }
 309     }
 310
 311     int bl = borderLeft();
 312     if (!collapseBorders())
 313         bl += paddingLeft();
 314
 315     // position the table sections
 316     if ( head ) {
 317         head->setPos(bl, m_height);
 318         m_height += head->height();
 319     }
 320     RenderObject *body = firstBody;
 321     while ( body ) {
 322         if ( body != head && body != foot && body->isTableSection() ) {
 323             body->setPos(bl, m_height);
 324             m_height += body->height();
 325         }
 326         body = body->nextSibling();
 327     }
 328     if ( foot ) {
 329         foot->setPos(bl, m_height);
 330         m_height += foot->height();
 331     }
 332
 333     m_height += bpBottom;
 334
 335     if(tCaption && tCaption->style()->captionSide()==CAPBOTTOM) {
 336         tCaption->setPos(tCaption->marginLeft(), m_height);
 337         m_height += tCaption->height() + tCaption->marginTop() + tCaption->marginBottom();
 338     }
 339
 340     //kdDebug(0) << "table height: " << m_height << endl;
 341
 342     // table can be containing block of positioned elements.
 343     // ### only pass true if width or height changed.
 344     layoutPositionedObjects( true );
 345
 346     // Repaint with our new bounds if they are different from our old bounds.
 347     if (checkForRepaint)
 348         repaintAfterLayoutIfNeeded(oldBounds, oldFullBounds);
 349
 350     m_overflowHeight = kMax(m_overflowHeight, m_height);
 351     m_overflowWidth = kMax(m_overflowWidth, m_width);
 352
 353     setNeedsLayout(false);
 354 }
 355
 356 void RenderTable::setCellWidths()
 357 {
 358 #ifdef DEBUG_LAYOUT
 359     kdDebug( 6040 ) << renderName() << "(Table, this=0x" << this << ")::setCellWidths()" << endl;
 360 #endif
 361
 362     RenderObject *child = firstChild();
 363     while( child ) {
 364         if ( child->isTableSection() )
 365             static_cast<RenderTableSection *>(child)->setCellWidths();
 366         child = child->nextSibling();
 367     }
 368 }
 369
 370 void RenderTable::paint(PaintInfo& i, int _tx, int _ty)
 371 {
 372     _tx += xPos();
 373     _ty += yPos();
 374
 375     PaintAction paintAction = i.phase;
 376
 377 #ifdef TABLE_PRINT
 378     kdDebug( 6040 ) << "RenderTable::paint() w/h = (" << width() << "/" << height() << ")" << endl;
 379 #endif
 380
 381     int os = 2*maximalOutlineSize(paintAction);
 382     if ((_ty >= i.r.y() + i.r.height() + os) || (_ty + height() <= i.r.y() - os)) return;
 383     if ((_tx >= i.r.x() + i.r.width() + os) || (_tx + width() <= i.r.x() - os)) return;
 384
 385 #ifdef TABLE_PRINT
 386     kdDebug( 6040 ) << "RenderTable::paint(2) " << _tx << "/" << _ty << " (" << _y << "/" << _h << ")" << endl;
 387 #endif
 388
 389     if ((paintAction == PaintActionBlockBackground || paintAction == PaintActionChildBlockBackground)
 390         && shouldPaintBackgroundOrBorder() && style()->visibility() == VISIBLE)
 391         paintBoxDecorations(i, _tx, _ty);
 392
 393     // We're done.  We don't bother painting any children.
 394     if (paintAction == PaintActionBlockBackground)
 395         return;
 396     // We don't paint our own background, but we do let the kids paint their backgrounds.
 397     if (paintAction == PaintActionChildBlockBackgrounds)
 398         paintAction = PaintActionChildBlockBackground;
 399     PaintInfo paintInfo(i.p, i.r, paintAction, paintingRootForChildren(i));
 400
 401     for (RenderObject *child = firstChild(); child; child = child->nextSibling())
 402         if (child->isTableSection() || child == tCaption)
 403             child->paint(paintInfo, _tx, _ty);
 404
 405     if (collapseBorders() && paintAction == PaintActionChildBlockBackground && style()->visibility() == VISIBLE) {
 406         // Collect all the unique border styles that we want to paint in a sorted list.  Once we
 407         // have all the styles sorted, we then do individual passes, painting each style of border
 408         // from lowest precedence to highest precedence.
 409         paintInfo.phase = PaintActionCollapsedTableBorders;
 410         QValueList<CollapsedBorderValue> borderStyles;
 411         collectBorders(borderStyles);
 412         QValueListIterator<CollapsedBorderValue> it = borderStyles.begin();
 413         QValueListIterator<CollapsedBorderValue> end = borderStyles.end();
 414         for (; it != end; ++it) {
 415             m_currentBorder = &(*it);
 416             for (RenderObject* child = firstChild(); child; child = child->nextSibling())
 417                 if (child->isTableSection())
 418                     child->paint(paintInfo, _tx, _ty);
 419         }
 420     }
 421
 422 #ifdef BOX_DEBUG
 423     outlineBox(i.p, _tx, _ty, "blue");
 424 #endif
 425 }
 426
 427 void RenderTable::paintBoxDecorations(PaintInfo& i, int _tx, int _ty)
 428 {
 429     int w = width();
 430     int h = height();
 431
 432     // Account for the caption.
 433     if (tCaption) {
 434         int captionHeight = (tCaption->height() + tCaption->marginBottom() +  tCaption->marginTop());
 435         h -= captionHeight;
 436         if (tCaption->style()->captionSide() != CAPBOTTOM)
 437             _ty += captionHeight;
 438     }
 439
 440     int my = kMax(_ty, i.r.y());
 441     int mh;
 442     if (_ty < i.r.y())
 443         mh= kMax(0, h - (i.r.y() - _ty));
 444     else
 445         mh = kMin(i.r.height(), h);
 446
 447     paintBackground(i.p, style()->backgroundColor(), style()->backgroundLayers(), my, mh, _tx, _ty, w, h);
 448
 449     if (style()->hasBorder() && !collapseBorders())
 450         paintBorder(i.p, _tx, _ty, w, h, style());
 451 }
 452
 453 void RenderTable::calcMinMaxWidth()
 454 {
 455     KHTMLAssert( !minMaxKnown() );
 456
 457     if ( needSectionRecalc )
 458         recalcSections();
 459
 460 #ifdef DEBUG_LAYOUT
 461     kdDebug( 6040 ) << renderName() << "(Table " << this << ")::calcMinMaxWidth()" <<  endl;
 462 #endif
 463
 464     tableLayout->calcMinMaxWidth();
 465
 466     if (tCaption && tCaption->minWidth() > m_minWidth)
 467         m_minWidth = tCaption->minWidth();
 468
 469     setMinMaxKnown();
 470 #ifdef DEBUG_LAYOUT
 471     kdDebug( 6040 ) << renderName() << " END: (Table " << this << ")::calcMinMaxWidth() min = " << m_minWidth << " max = " << m_maxWidth <<  endl;
 472 #endif
 473 }
 474
 475 void RenderTable::splitColumn( int pos, int firstSpan )
 476 {
 477     // we need to add a new columnStruct
 478     int oldSize = columns.size();
 479     columns.resize( oldSize + 1 );
 480     int oldSpan = columns[pos].span;
 481 //     qDebug("splitColumn( %d,%d ), oldSize=%d, oldSpan=%d", pos, firstSpan, oldSize, oldSpan );
 482     KHTMLAssert( oldSpan > firstSpan );
 483     columns[pos].span = firstSpan;
 484     memmove( columns.data()+pos+1, columns.data()+pos, (oldSize-pos)*sizeof(ColumnStruct) );
 485     columns[pos+1].span = oldSpan - firstSpan;
 486
 487     // change width of all rows.
 488     RenderObject *child = firstChild();
 489     while ( child ) {
 490         if ( child->isTableSection() ) {
 491             RenderTableSection *section = static_cast<RenderTableSection *>(child);
 492             int size = section->numRows();
 493             int row = 0;
 494             if ( section->cCol > pos )
 495                 section->cCol++;
 496             while ( row < size ) {
 497                 section->grid[row].row->resize( oldSize+1 );
 498                 RenderTableSection::Row &r = *section->grid[row].row;
 499                 memmove( r.data()+pos+1, r.data()+pos, (oldSize-pos)*sizeof( RenderTableCell * ) );
 500 //              qDebug("moving from %d to %d, num=%d", pos, pos+1, (oldSize-pos-1) );
 501                 r[pos+1] = r[pos] ? (RenderTableCell *)-1 : 0;
 502                 row++;
 503             }
 504         }
 505         child = child->nextSibling();
 506     }
 507     columnPos.resize( numEffCols()+1 );
 508     setNeedsLayoutAndMinMaxRecalc();
 509 }
 510
 511 void RenderTable::appendColumn( int span )
 512 {
 513     // easy case.
 514     int pos = columns.size();
 515 //     qDebug("appendColumn( %d ), size=%d", span, pos );
 516     int newSize = pos + 1;
 517     columns.resize( newSize );
 518     columns[pos].span = span;
 519     //qDebug("appending column at %d, span %d", pos,  span );
 520
 521     // change width of all rows.
 522     RenderObject *child = firstChild();
 523     while ( child ) {
 524         if ( child->isTableSection() ) {
 525             RenderTableSection *section = static_cast<RenderTableSection *>(child);
 526             int size = section->numRows();
 527             int row = 0;
 528             while ( row < size ) {
 529                 section->grid[row].row->resize( newSize );
 530                 section->cellAt( row, pos ) = 0;
 531                 row++;
 532             }
 533
 534         }
 535         child = child->nextSibling();
 536     }
 537     columnPos.resize( numEffCols()+1 );
 538     setNeedsLayoutAndMinMaxRecalc();
 539 }
 540
 541 RenderTableCol *RenderTable::colElement( int col ) {
 542     if ( !has_col_elems )
 543         return 0;
 544     RenderObject *child = firstChild();
 545     int cCol = 0;
 546     while ( child ) {
 547         if ( child->isTableCol() ) {
 548             RenderTableCol *colElem = static_cast<RenderTableCol *>(child);
 549             int span = colElem->span();
 550             if ( !colElem->firstChild() ) {
 551                 cCol += span;
 552                 if ( cCol > col )
 553                     return colElem;
 554             }
 555
 556             RenderObject *next = child->firstChild();
 557             if ( !next )
 558                 next = child->nextSibling();
 559             if ( !next && child->parent()->isTableCol() )
 560                 next = child->parent()->nextSibling();
 561             child = next;
 562         } else
 563             break;
 564     }
 565     return 0;
 566 }
 567
 568 void RenderTable::recalcSections()
 569 {
 570     tCaption = 0;
 571     head = foot = firstBody = 0;
 572     has_col_elems = false;
 573
 574     RenderObject *child = firstChild();
 575     // We need to get valid pointers to caption, head, foot and firstbody again
 576     while (child) {
 577         switch (child->style()->display()) {
 578         case TABLE_CAPTION:
 579             if (!tCaption) {
 580                 tCaption = static_cast<RenderBlock*>(child);
 581                 tCaption->setNeedsLayout(true);
 582             }
 583             break;
 584         case TABLE_COLUMN:
 585         case TABLE_COLUMN_GROUP:
 586             has_col_elems = true;
 587             break;
 588         case TABLE_HEADER_GROUP: {
 589             RenderTableSection *section = static_cast<RenderTableSection *>(child);
 590             if ( !head )
 591                 head = section;
 592             else if ( !firstBody )
 593                 firstBody = section;
 594             if ( section->needCellRecalc )
 595                 section->recalcCells();
 596             break;
 597         }
 598         case TABLE_FOOTER_GROUP: {
 599             RenderTableSection *section = static_cast<RenderTableSection *>(child);
 600             if ( !foot )
 601                 foot = section;
 602             else if ( !firstBody )
 603                 firstBody = section;
 604             if ( section->needCellRecalc )
 605                 section->recalcCells();
 606             break;
 607         }
 608         case TABLE_ROW_GROUP: {
 609             RenderTableSection *section = static_cast<RenderTableSection *>(child);
 610             if ( !firstBody )
 611                 firstBody = section;
 612             if ( section->needCellRecalc )
 613                 section->recalcCells();
 614         }
 615         default:
 616             break;
 617         }
 618         child = child->nextSibling();
 619     }
 620     needSectionRecalc = false;
 621     setNeedsLayout(true);
 622 }
 623
 624 RenderObject* RenderTable::removeChildNode(RenderObject* child)
 625 {
 626     setNeedSectionRecalc();
 627     return RenderContainer::removeChildNode( child );
 628 }
 629
 630 int RenderTable::borderLeft() const
 631 {
 632     if (collapseBorders()) {
 633         // FIXME: For strict mode, returning 0 is correct, since the table border half spills into the margin,
 634         // but I'm working to get this changed.  For now, follow the spec.
 635         return 0;
 636     }
 637     return RenderBlock::borderLeft();
 638 }
 639
 640 int RenderTable::borderRight() const
 641 {
 642     if (collapseBorders()) {
 643         // FIXME: For strict mode, returning 0 is correct, since the table border half spills into the margin,
 644         // but I'm working to get this changed.  For now, follow the spec.
 645         return 0;
 646     }
 647     return RenderBlock::borderRight();
 648 }
 649
 650 int RenderTable::borderTop() const
 651 {
 652     if (collapseBorders()) {
 653         // FIXME: For strict mode, returning 0 is correct, since the table border half spills into the margin,
 654         // but I'm working to get this changed.  For now, follow the spec.
 655         return 0;
 656     }
 657     return RenderBlock::borderTop();
 658 }
 659
 660 int RenderTable::borderBottom() const
 661 {
 662     if (collapseBorders()) {
 663         // FIXME: For strict mode, returning 0 is correct, since the table border half spills into the margin,
 664         // but I'm working to get this changed.  For now, follow the spec.
 665         return 0;
 666     }
 667     return RenderBlock::borderBottom();
 668 }
 669
 670 RenderTableCell* RenderTable::cellAbove(const RenderTableCell* cell) const
 671 {
 672     // Find the section and row to look in
 673     int r = cell->row();
 674     RenderTableSection* section = 0;
 675     int rAbove = -1;
 676     if (r > 0) {
 677         // cell is not in the first row, so use the above row in its own section
 678         section = cell->section();
 679         rAbove = r-1;
 680     } else {
 681         // cell is at top of a section, use last row in previous section
 682         for (RenderObject *prevSection = cell->section()->previousSibling();
 683              prevSection && rAbove < 0;
 684              prevSection = prevSection->previousSibling()) {
 685             if (prevSection->isTableSection()) {
 686                 section = static_cast<RenderTableSection *>(prevSection);
 687                 if (section->numRows() > 0)
 688                     rAbove = section->numRows()-1;
 689             }
 690         }
 691     }
 692
 693     // Look up the cell in the section's grid, which requires effective col index
 694     if (section && rAbove >= 0) {
 695         int effCol = colToEffCol(cell->col());
 696         RenderTableCell* aboveCell;
 697         // If we hit a span back up to a real cell.
 698         do {
 699             aboveCell = section->cellAt(rAbove, effCol);
 700             effCol--;
 701         } while (aboveCell == (RenderTableCell *)-1 && effCol >=0);
 702         return (aboveCell == (RenderTableCell *)-1) ? 0 : aboveCell;
 703     } else {
 704         return 0;
 705     }
 706 }
 707
 708 RenderTableCell* RenderTable::cellBelow(const RenderTableCell* cell) const
 709 {
 710     // Find the section and row to look in
 711     int r = cell->row() + cell->rowSpan() - 1;
 712     RenderTableSection* section = 0;
 713     int rBelow = -1;
 714     if (r < cell->section()->numRows()-1) {
 715         // The cell is not in the last row, so use the next row in the section.
 716         section = cell->section();
 717         rBelow= r+1;
 718     } else {
 719         // The cell is at the bottom of a section. Use the first row in the next section.
 720         for (RenderObject* nextSection = cell->section()->nextSibling();
 721              nextSection && rBelow < 0;
 722              nextSection = nextSection->nextSibling())
 723         {
 724             if (nextSection->isTableSection()) {
 725                 section = static_cast<RenderTableSection *>(nextSection);
 726                 if (section->numRows() > 0)
 727                     rBelow = 0;
 728             }
 729         }
 730     }
 731
 732     // Look up the cell in the section's grid, which requires effective col index
 733     if (section && rBelow >= 0) {
 734         int effCol = colToEffCol(cell->col());
 735         RenderTableCell* belowCell;
 736         // If we hit a colspan back up to a real cell.
 737         do {
 738             belowCell = section->cellAt(rBelow, effCol);
 739             effCol--;
 740         } while (belowCell == (RenderTableCell *)-1 && effCol >=0);
 741         return (belowCell == (RenderTableCell *)-1) ? 0 : belowCell;
 742     } else {
 743         return 0;
 744     }
 745 }
 746
 747 RenderTableCell* RenderTable::cellLeft(const RenderTableCell* cell) const
 748 {
 749     RenderTableSection* section = cell->section();
 750     int effCol = colToEffCol(cell->col());
 751     if (effCol == 0)
 752         return 0;
 753
 754     // If we hit a colspan back up to a real cell.
 755     RenderTableCell* prevCell;
 756     do {
 757         prevCell = section->cellAt(cell->row(), effCol-1);
 758         effCol--;
 759     } while (prevCell == (RenderTableCell *)-1 && effCol >=0);
 760     return (prevCell == (RenderTableCell *)-1) ? 0 : prevCell;
 761 }
 762
 763 RenderTableCell* RenderTable::cellRight(const RenderTableCell* cell) const
 764 {
 765     int effCol = colToEffCol(cell->col()+cell->colSpan());
 766     if (effCol >= numEffCols())
 767         return 0;
 768     RenderTableCell* result = cell->section()->cellAt(cell->row(), effCol);
 769     return (result == (RenderTableCell*)-1) ? 0 : result;
 770 }
 771
 772 RenderBlock* RenderTable::firstLineBlock() const
 773 {
 774     return 0;
 775 }
 776
 777 void RenderTable::updateFirstLetter()
 778 {}
 779
 780 #ifndef NDEBUG
 781 void RenderTable::dump(QTextStream *stream, QString ind) const
 782 {
 783     if (tCaption)
 784         *stream << " tCaption";
 785     if (head)
 786         *stream << " head";
 787     if (foot)
 788         *stream << " foot";
 789
 790     *stream << endl << ind << "cspans:";
 791     for ( unsigned int i = 0; i < columns.size(); i++ )
 792         *stream << " " << columns[i].span;
 793     *stream << endl << ind;
 794
 795     RenderBlock::dump(stream,ind);
 796 }
 797 #endif
 798
 799 // --------------------------------------------------------------------------
 800
 801 RenderTableSection::RenderTableSection(DOM::NodeImpl* node)
 802     : RenderContainer(node)
 803 {
 804     // init RenderObject attributes
 805     setInline(false);   // our object is not Inline
 806     gridRows = 0;
 807     cCol = 0;
 808     cRow = -1;
 809     needCellRecalc = false;
 810 }
 811
 812 RenderTableSection::~RenderTableSection()
 813 {
 814     clearGrid();
 815 }
 816
 817 void RenderTableSection::detach()
 818 {
 819     // recalc cell info because RenderTable has unguarded pointers
 820     // stored that point to this RenderTableSection.
 821     if (table())
 822         table()->setNeedSectionRecalc();
 823
 824     RenderContainer::detach();
 825 }
 826
 827 void RenderTableSection::setStyle(RenderStyle* _style)
 828 {
 829     // we don't allow changing this one
 830     if (style())
 831         _style->setDisplay(style()->display());
 832     else if (_style->display() != TABLE_FOOTER_GROUP && _style->display() != TABLE_HEADER_GROUP)
 833         _style->setDisplay(TABLE_ROW_GROUP);
 834
 835     RenderContainer::setStyle(_style);
 836 }
 837
 838 void RenderTableSection::addChild(RenderObject *child, RenderObject *beforeChild)
 839 {
 840 #ifdef DEBUG_LAYOUT
 841     kdDebug( 6040 ) << renderName() << "(TableSection)::addChild( " << child->renderName()  << ", beforeChild=" <<
 842                        (beforeChild ? beforeChild->renderName() : "0") << " )" << endl;
 843 #endif
 844     RenderObject *row = child;
 845
 846     if (child->element() && child->element()->id() == ID_FORM) {
 847         RenderContainer::addChild(child,beforeChild);
 848         return;
 849     }
 850
 851     if ( !child->isTableRow() ) {
 852
 853         if( !beforeChild )
 854             beforeChild = lastChild();
 855
 856         if( beforeChild && beforeChild->isAnonymous() )
 857             row = beforeChild;
 858         else {
 859             RenderObject *lastBox = beforeChild;
 860             while ( lastBox && lastBox->parent()->isAnonymous() && !lastBox->isTableRow() )
 861                 lastBox = lastBox->parent();
 862             if ( lastBox && lastBox->isAnonymous() ) {
 863                 lastBox->addChild( child, beforeChild );
 864                 return;
 865             } else {
 866                 //kdDebug( 6040 ) << "creating anonymous table row" << endl;
 867                 row = new (renderArena()) RenderTableRow(document() /* anonymous table */);
 868                 RenderStyle *newStyle = new (renderArena()) RenderStyle();
 869                 newStyle->inheritFrom(style());
 870                 newStyle->setDisplay( TABLE_ROW );
 871                 row->setStyle(newStyle);
 872                 addChild(row, beforeChild);
 873             }
 874         }
 875         row->addChild(child);
 876         child->setNeedsLayoutAndMinMaxRecalc();
 877         return;
 878     }
 879
 880     if (beforeChild)
 881         setNeedCellRecalc();
 882
 883     cRow++;
 884     cCol = 0;
 885
 886     ensureRows( cRow+1 );
 887
 888     if (!beforeChild) {
 889         grid[cRow].height = child->style()->height();
 890         if ( grid[cRow].height.type == Relative )
 891             grid[cRow].height = Length();
 892     }
 893
 894
 895     RenderContainer::addChild(child,beforeChild);
 896 }
 897
 898 void RenderTableSection::ensureRows(int numRows)
 899 {
 900     int nRows = gridRows;
 901     if (numRows > nRows) {
 902         if (numRows > static_cast<int>(grid.size()))
 903             grid.resize(numRows*2+1);
 904
 905         gridRows = numRows;
 906         int nCols = table()->numEffCols();
 907         for (int r = nRows; r < numRows; r++ ) {
 908             grid[r].row = new Row(nCols);
 909             grid[r].row->fill(0);
 910             grid[r].baseLine = 0;
 911             grid[r].height = Length();
 912         }
 913     }
 914
 915 }
 916
 917 void RenderTableSection::addCell( RenderTableCell *cell )
 918 {
 919     int rSpan = cell->rowSpan();
 920     int cSpan = cell->colSpan();
 921     QMemArray<RenderTable::ColumnStruct> &columns = table()->columns;
 922     int nCols = columns.size();
 923
 924     // ### mozilla still seems to do the old HTML way, even for strict DTD
 925     // (see the annotation on table cell layouting in the CSS specs and the testcase below:
 926     // <TABLE border>
 927     // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4
 928     // <TR><TD colspan="2">5
 929     // </TABLE>
 930 #if 0
 931     // find empty space for the cell
 932     bool found = false;
 933     while ( !found ) {
 934         found = true;
 935         while ( cCol < nCols && cellAt( cRow, cCol ) )
 936             cCol++;
 937         int pos = cCol;
 938         int span = 0;
 939         while ( pos < nCols && span < cSpan ) {
 940             if ( cellAt( cRow, pos ) ) {
 941                 found = false;
 942                 cCol = pos;
 943                 break;
 944             }
 945             span += columns[pos].span;
 946             pos++;
 947         }
 948     }
 949 #else
 950     while ( cCol < nCols && cellAt( cRow, cCol ) )
 951         cCol++;
 952 #endif
 953
 954 //       qDebug("adding cell at %d/%d span=(%d/%d)",  cRow, cCol, rSpan, cSpan );
 955
 956     if ( rSpan == 1 ) {
 957         // we ignore height settings on rowspan cells
 958         Length height = cell->style()->height();
 959         if ( height.value > 0 || (height.type == Relative && height.value >= 0) ) {
 960             Length cRowHeight = grid[cRow].height;
 961             switch( height.type ) {
 962             case Percent:
 963                 if ( !(cRowHeight.type == Percent) ||
 964                      ( cRowHeight.type == Percent && cRowHeight.value < height.value ) )
 965                     grid[cRow].height = height;
 966                      break;
 967             case Fixed:
 968                 if ( cRowHeight.type < Percent ||
 969                      ( cRowHeight.type == Fixed && cRowHeight.value < height.value ) )
 970                     grid[cRow].height = height;
 971                 break;
 972             case Relative:
 973 #if 0
 974                 // we treat this as variable. This is correct according to HTML4, as it only specifies length for the height.
 975                 if ( cRowHeight.type == Variable ||
 976                      ( cRowHeight.type == Relative && cRowHeight.value < height.value ) )
 977                      grid[cRow].height = height;
 978                      break;
 979 #endif
 980             default:
 981                 break;
 982             }
 983         }
 984     }
 985
 986     // make sure we have enough rows
 987     ensureRows( cRow + rSpan );
 988
 989     int col = cCol;
 990     // tell the cell where it is
 991     RenderTableCell *set = cell;
 992     while ( cSpan ) {
 993         int currentSpan;
 994         if ( cCol >= nCols ) {
 995             table()->appendColumn( cSpan );
 996             currentSpan = cSpan;
 997         } else {
 998             if ( cSpan < columns[cCol].span )
 999                 table()->splitColumn( cCol, cSpan );
1000             currentSpan = columns[cCol].span;
1001         }
1002         int r = 0;
1003         while ( r < rSpan ) {
1004             if ( !cellAt( cRow + r, cCol ) ) {
1005 //              qDebug("    adding cell at %d, %d",  cRow + r, cCol );
1006                 cellAt( cRow + r, cCol ) = set;
1007             }
1008             r++;
1009         }
1010         cCol++;
1011         cSpan -= currentSpan;
1012         set = (RenderTableCell *)-1;
1013     }
1014     if ( cell ) {
1015         cell->setRow( cRow );
1016         cell->setCol( table()->effColToCol( col ) );
1017     }
1018 }
1019
1020
1021
1022 void RenderTableSection::setCellWidths()
1023 {
1024 #ifdef DEBUG_LAYOUT
1025     kdDebug( 6040 ) << renderName() << "(Table, this=0x" << this << ")::setCellWidths()" << endl;
1026 #endif
1027     QMemArray<int> &columnPos = table()->columnPos;
1028
1029     int rows = gridRows;
1030     for ( int i = 0; i < rows; i++ ) {
1031         Row &row = *grid[i].row;
1032         int cols = row.size();
1033         for ( int j = 0; j < cols; j++ ) {
1034             RenderTableCell *cell = row[j];
1035 //          qDebug("cell[%d,%d] = %p", i, j, cell );
1036             if ( !cell || cell == (RenderTableCell *)-1 )
1037                 continue;
1038             int endCol = j;
1039             int cspan = cell->colSpan();
1040             while ( cspan && endCol < cols ) {
1041                 cspan -= table()->columns[endCol].span;
1042                 endCol++;
1043             }
1044             int w = columnPos[endCol] - columnPos[j] - table()->hBorderSpacing();
1045 #ifdef DEBUG_LAYOUT
1046             kdDebug( 6040 ) << "setting width of cell " << cell << " " << cell->row() << "/" << cell->col() << " to " << w << " colspan=" << cell->colSpan() << " start=" << j << " end=" << endCol << endl;
1047 #endif
1048             int oldWidth = cell->width();
1049             if ( w != oldWidth ) {
1050                 cell->setNeedsLayout(true);
1051                 cell->setWidth( w );
1052             }
1053         }
1054     }
1055 }
1056
1057
1058 void RenderTableSection::calcRowHeight()
1059 {
1060     int indx;
1061     RenderTableCell *cell;
1062
1063     int totalRows = gridRows;
1064     int spacing = table()->vBorderSpacing();
1065
1066     rowPos.resize( totalRows + 1 );
1067     rowPos[0] = spacing;
1068
1069     for ( int r = 0; r < totalRows; r++ ) {
1070         rowPos[r+1] = 0;
1071
1072         int baseline=0;
1073         int bdesc = 0;
1074 //      qDebug("height of row %d is %d/%d", r, grid[r].height.value, grid[r].height.type );
1075         int ch = grid[r].height.minWidth( 0 );
1076         int pos = rowPos[ r+1 ] + ch + spacing;
1077
1078         if ( pos > rowPos[r+1] )
1079             rowPos[r+1] = pos;
1080
1081         Row *row = grid[r].row;
1082         int totalCols = row->size();
1083         int totalRows = gridRows;
1084
1085         for ( int c = 0; c < totalCols; c++ ) {
1086             cell = cellAt(r, c);
1087             if ( !cell || cell == (RenderTableCell *)-1 )
1088                 continue;
1089             if ( r < totalRows - 1 && cellAt(r+1, c) == cell )
1090                 continue;
1091
1092             if ( ( indx = r - cell->rowSpan() + 1 ) < 0 )
1093                 indx = 0;
1094
1095             if (cell->overrideSize() != -1) {
1096                 cell->setOverrideSize(-1);
1097                 cell->setChildNeedsLayout(true, false);
1098                 cell->layoutIfNeeded();
1099             }
1100
1101             // Explicit heights use the border box in quirks mode.  In strict mode do the right
1102             // thing and actually add in the border and padding.
1103             ch = cell->style()->height().width(0) +
1104                 (cell->style()->htmlHacks() ? 0 : (cell->paddingTop() + cell->paddingBottom() +
1105                                                    cell->borderTop() + cell->borderBottom()));
1106             if (cell->height() > ch)
1107                 ch = cell->height();
1108
1109             pos = rowPos[ indx ] + ch + spacing;
1110
1111             if ( pos > rowPos[r+1] )
1112                 rowPos[r+1] = pos;
1113
1114             // find out the baseline
1115             EVerticalAlign va = cell->style()->verticalAlign();
1116             if (va == BASELINE || va == TEXT_BOTTOM || va == TEXT_TOP
1117                 || va == SUPER || va == SUB)
1118             {
1119                 int b=cell->baselinePosition();
1120
1121                 if (b>baseline)
1122                     baseline=b;
1123
1124                 int td = rowPos[ indx ] + ch - b;
1125                 if (td>bdesc)
1126                     bdesc = td;
1127             }
1128         }
1129
1130         //do we have baseline aligned elements?
1131         if (baseline) {
1132             // increase rowheight if baseline requires
1133             int bRowPos = baseline + bdesc  + spacing ; // + 2*padding
1134             if (rowPos[r+1]<bRowPos)
1135                 rowPos[r+1]=bRowPos;
1136
1137             grid[r].baseLine = baseline;
1138         }
1139
1140         if ( rowPos[r+1] < rowPos[r] )
1141             rowPos[r+1] = rowPos[r];
1142 //      qDebug("rowpos(%d)=%d",  r, rowPos[r] );
1143     }
1144 }
1145
1146 int RenderTableSection::layoutRows( int toAdd )
1147 {
1148     int rHeight;
1149     int rindx;
1150     int totalRows = gridRows;
1151     int hspacing = table()->hBorderSpacing();
1152     int vspacing = table()->vBorderSpacing();
1153
1154     if (toAdd && totalRows && (rowPos[totalRows] || !nextSibling())) {
1155
1156         int totalHeight = rowPos[totalRows] + toAdd;
1157 //      qDebug("layoutRows: totalHeight = %d",  totalHeight );
1158
1159         int dh = toAdd;
1160         int totalPercent = 0;
1161         int numVariable = 0;
1162         for ( int r = 0; r < totalRows; r++ ) {
1163             if ( grid[r].height.type == Variable )
1164                 numVariable++;
1165             else if ( grid[r].height.type == Percent )
1166                 totalPercent += grid[r].height.value;
1167         }
1168         if ( totalPercent ) {
1169 //          qDebug("distributing %d over percent rows totalPercent=%d", dh,  totalPercent );
1170             // try to satisfy percent
1171             int add = 0;
1172             if ( totalPercent > 100 )
1173                 totalPercent = 100;
1174             int rh = rowPos[1]-rowPos[0];
1175             for ( int r = 0; r < totalRows; r++ ) {
1176                 if ( totalPercent > 0 && grid[r].height.type == Percent ) {
1177                     int toAdd = kMin(dh, (totalHeight * grid[r].height.value / 100)-rh);
1178                     // If toAdd is negative, then we don't want to shrink the row (this bug
1179                     // affected Outlook Web Access).
1180                     toAdd = QMAX(0, toAdd);
1181                     add += toAdd;
1182                     dh -= toAdd;
1183                     totalPercent -= grid[r].height.value;
1184 //                  qDebug( "adding %d to row %d", toAdd, r );
1185                 }
1186                 if ( r < totalRows-1 )
1187                     rh = rowPos[r+2] - rowPos[r+1];
1188                 rowPos[r+1] += add;
1189             }
1190         }
1191         if ( numVariable ) {
1192             // distribute over variable cols
1193 //          qDebug("distributing %d over variable rows numVariable=%d", dh,  numVariable );
1194             int add = 0;
1195             for ( int r = 0; r < totalRows; r++ ) {
1196                 if ( numVariable > 0 && grid[r].height.type == Variable ) {
1197                     int toAdd = dh/numVariable;
1198                     add += toAdd;
1199                     dh -= toAdd;
1200                     numVariable--;
1201                 }
1202                 rowPos[r+1] += add;
1203             }
1204         }
1205         if (dh>0 && rowPos[totalRows]) {
1206             // if some left overs, distribute equally.
1207             int tot=rowPos[totalRows];
1208             int add=0;
1209             int prev=rowPos[0];
1210             for ( int r = 0; r < totalRows; r++ ) {
1211                 //weight with the original height
1212                 add+=dh*(rowPos[r+1]-prev)/tot;
1213                 prev=rowPos[r+1];
1214                 rowPos[r+1]+=add;
1215             }
1216         }
1217     }
1218
1219     int leftOffset = hspacing;
1220
1221     int nEffCols = table()->numEffCols();
1222     for ( int r = 0; r < totalRows; r++ )
1223     {
1224         Row *row = grid[r].row;
1225         int totalCols = row->size();
1226         for ( int c = 0; c < nEffCols; c++ )
1227         {
1228             RenderTableCell *cell = cellAt(r, c);
1229             if (!cell || cell == (RenderTableCell *)-1 )
1230                 continue;
1231             if ( r < totalRows - 1 && cell == cellAt(r+1, c) )
1232                 continue;
1233
1234             if ( ( rindx = r-cell->rowSpan()+1 ) < 0 )
1235                 rindx = 0;
1236
1237             rHeight = rowPos[r+1] - rowPos[rindx] - vspacing;
1238
1239             // Force percent height children to lay themselves out again.
1240             // This will cause these children to grow to fill the cell.
1241             // FIXME: There is still more work to do here to fully match WinIE (should
1242             // it become necessary to do so).  In quirks mode, WinIE behaves like we
1243             // do, but it will clip the cells that spill out of the table section.  In
1244             // strict mode, Mozilla and WinIE both regrow the table to accommodate the
1245             // new height of the cell (thus letting the percentages cause growth one
1246             // time only).  We may also not be handling row-spanning cells correctly.
1247             //
1248             // Note also the oddity where replaced elements always flex, and yet blocks/tables do
1249             // not necessarily flex.  WinIE is crazy and inconsistent, and we can't hope to
1250             // match the behavior perfectly, but we'll continue to refine it as we discover new
1251             // bugs. :)
1252             bool cellChildrenFlex = false;
1253             bool flexAllChildren = cell->style()->height().isFixed() ||
1254                 (!table()->style()->height().isVariable() && rHeight != cell->height());
1255             RenderObject* o = cell->firstChild();
1256             while (o) {
1257                 if (!o->isText() && o->style()->height().isPercent() && (o->isReplaced() || flexAllChildren)) {
1258                     // Tables with no sections do not flex.
1259                     if (!o->isTable() || static_cast<RenderTable*>(o)->hasSections()) {
1260                         o->setNeedsLayout(true, false);
1261                         cell->setChildNeedsLayout(true, false);
1262                         cellChildrenFlex = true;
1263                     }
1264                 }
1265                 o = o->nextSibling();
1266             }
1267             if (cellChildrenFlex) {
1268                 cell->setOverrideSize(kMax(0,
1269                                            rHeight - cell->borderTop() - cell->paddingTop() -
1270                                                      cell->borderBottom() - cell->paddingBottom()));
1271                 cell->layoutIfNeeded();
1272
1273                 // Alignment within a cell is based off the calculated
1274                 // height, which becomes irrelevant once the cell has
1275                 // been resized based off its percentage. -dwh
1276                 cell->setCellTopExtra(0);
1277                 cell->setCellBottomExtra(0);
1278             }
1279             else {
1280 #ifdef DEBUG_LAYOUT
1281             kdDebug( 6040 ) << "setting position " << r << "/" << c << ": "
1282                             << table()->columnPos[c] /*+ padding */ << "/" << rowPos[rindx] << " height=" << rHeight<< endl;
1283 #endif
1284
1285             EVerticalAlign va = cell->style()->verticalAlign();
1286             int te=0;
1287             switch (va)
1288             {
1289             case SUB:
1290             case SUPER:
1291             case TEXT_TOP:
1292             case TEXT_BOTTOM:
1293             case BASELINE:
1294                 te = getBaseline(r) - cell->baselinePosition() ;
1295                 break;
1296             case TOP:
1297                 te = 0;
1298                 break;
1299             case MIDDLE:
1300                 te = (rHeight - cell->height())/2;
1301                 break;
1302             case BOTTOM:
1303                 te = rHeight - cell->height();
1304                 break;
1305             default:
1306                 break;
1307             }
1308 #ifdef DEBUG_LAYOUT
1309             //            kdDebug( 6040 ) << "CELL " << cell << " te=" << te << ", be=" << rHeight - cell->height() - te << ", rHeight=" << rHeight << ", valign=" << va << endl;
1310 #endif
1311             cell->setCellTopExtra( te );
1312             cell->setCellBottomExtra( rHeight - cell->height() - te);
1313             }
1314
1315             int oldCellX = cell->xPos();
1316             int oldCellY = cell->yPos();
1317
1318             if (style()->direction()==RTL) {
1319                 cell->setPos(
1320                     table()->columnPos[(int)totalCols] -
1321                     table()->columnPos[table()->colToEffCol(cell->col()+cell->colSpan())] +
1322                     leftOffset,
1323                     rowPos[rindx] );
1324             } else {
1325                 cell->setPos( table()->columnPos[c] + leftOffset, rowPos[rindx] );
1326             }
1327
1328             // If the cell moved, we have to repaint it as well as any floating/positioned
1329             // descendants.  An exception is if we need a layout.  In this case, we know we're going to
1330             // repaint ourselves (and the cell) anyway.
1331             if (!table()->selfNeedsLayout() && cell->checkForRepaintDuringLayout())
1332                 cell->repaintDuringLayoutIfMoved(oldCellX, oldCellY);
1333         }
1334     }
1335
1336     m_height = rowPos[totalRows];
1337     return m_height;
1338 }
1339
1340
1341 void RenderTableSection::paint(PaintInfo& i, int tx, int ty)
1342 {
1343     unsigned int totalRows = gridRows;
1344     unsigned int totalCols = table()->columns.size();
1345
1346     tx += m_x;
1347     ty += m_y;
1348
1349     // check which rows and cols are visible and only paint these
1350     // ### fixme: could use a binary search here
1351     PaintAction paintAction = i.phase;
1352     int x = i.r.x(); int y = i.r.y(); int w = i.r.width(); int h = i.r.height();
1353
1354     int os = 2*maximalOutlineSize(paintAction);
1355     unsigned int startrow = 0;
1356     unsigned int endrow = totalRows;
1357     for ( ; startrow < totalRows; startrow++ ) {
1358         if ( ty + rowPos[startrow+1] >= y - os)
1359             break;
1360     }
1361     for ( ; endrow > 0; endrow-- ) {
1362         if ( ty + rowPos[endrow-1] <= y + h + os)
1363             break;
1364     }
1365     unsigned int startcol = 0;
1366     unsigned int endcol = totalCols;
1367     if ( style()->direction() == LTR ) {
1368         for ( ; startcol < totalCols; startcol++ ) {
1369             if ( tx + table()->columnPos[startcol+1] >= x - os)
1370                 break;
1371         }
1372         for ( ; endcol > 0; endcol-- ) {
1373             if ( tx + table()->columnPos[endcol-1] <= x + w + os)
1374                 break;
1375         }
1376     }
1377
1378     if ( startcol < endcol ) {
1379         // draw the cells
1380         for ( unsigned int r = startrow; r < endrow; r++ ) {
1381             unsigned int c = startcol;
1382             // since a cell can be -1 (indicating a colspan) we might have to search backwards to include it
1383             while ( c && cellAt( r, c ) == (RenderTableCell *)-1 )
1384                 c--;
1385             for ( ; c < endcol; c++ ) {
1386                 RenderTableCell *cell = cellAt(r, c);
1387                 if (!cell || cell == (RenderTableCell *)-1 )
1388                     continue;
1389
1390                 // Cells must always paint in the order in which they appear taking into account
1391                 // their upper left originating row/column.  For cells with rowspans, avoid repainting
1392                 // if we've already seen the cell.
1393                 if (r > startrow && (cellAt(r-1, c) == cell))
1394                     continue;
1395
1396 #ifdef TABLE_PRINT
1397                 kdDebug( 6040 ) << "painting cell " << r << "/" << c << endl;
1398 #endif
1399                 cell->paint(i, tx, ty);
1400             }
1401         }
1402     }
1403 }
1404
1405 void RenderTableSection::recalcCells()
1406 {
1407     cCol = 0;
1408     cRow = -1;
1409     clearGrid();
1410     gridRows = 0;
1411
1412     RenderObject *row = firstChild();
1413     while ( row ) {
1414         cRow++;
1415         cCol = 0;
1416         ensureRows( cRow+1 );
1417         RenderObject *cell = row->firstChild();
1418         while ( cell ) {
1419             if ( cell->isTableCell() )
1420                 addCell( static_cast<RenderTableCell *>(cell) );
1421             cell = cell->nextSibling();
1422         }
1423         row = row->nextSibling();
1424     }
1425     needCellRecalc = false;
1426     setNeedsLayout(true);
1427 }
1428
1429 void RenderTableSection::clearGrid()
1430 {
1431     int rows = gridRows;
1432     while ( rows-- ) {
1433         delete grid[rows].row;
1434     }
1435 }
1436
1437 RenderObject* RenderTableSection::removeChildNode(RenderObject* child)
1438 {
1439     setNeedCellRecalc();
1440     return RenderContainer::removeChildNode( child );
1441 }
1442
1443 #ifndef NDEBUG
1444 void RenderTableSection::dump(QTextStream *stream, QString ind) const
1445 {
1446     *stream << endl << ind << "grid=(" << grid.size() << "," << table()->numEffCols() << ")" << endl << ind;
1447     for ( unsigned int r = 0; r < grid.size(); r++ ) {
1448         for ( int c = 0; c < table()->numEffCols(); c++ ) {
1449             if ( cellAt( r,  c ) && cellAt( r, c ) != (RenderTableCell *)-1 )
1450                 *stream << "(" << cellAt( r, c )->row() << "," << cellAt( r, c )->col() << ","
1451                         << cellAt(r, c)->rowSpan() << "," << cellAt(r, c)->colSpan() << ") ";
1452             else
1453                 *stream << cellAt( r, c ) << "null cell ";
1454         }
1455         *stream << endl << ind;
1456     }
1457     RenderContainer::dump(stream,ind);
1458 }
1459 #endif
1460
1461 // -------------------------------------------------------------------------
1462
1463 RenderTableRow::RenderTableRow(DOM::NodeImpl* node)
1464     : RenderContainer(node)
1465 {
1466     // init RenderObject attributes
1467     setInline(false);   // our object is not Inline
1468 }
1469
1470 void RenderTableRow::detach()
1471 {
1472     RenderTableSection *s = section();
1473     if (s) {
1474         s->setNeedCellRecalc();
1475     }
1476     RenderContainer::detach();
1477 }
1478
1479 void RenderTableRow::setStyle(RenderStyle* style)
1480 {
1481     style->setDisplay(TABLE_ROW);
1482     RenderContainer::setStyle(style);
1483 }
1484
1485 void RenderTableRow::addChild(RenderObject *child, RenderObject *beforeChild)
1486 {
1487 #ifdef DEBUG_LAYOUT
1488     kdDebug( 6040 ) << renderName() << "(TableRow)::addChild( " << child->renderName() << " )"  << ", " <<
1489                        (beforeChild ? beforeChild->renderName() : "0") << " )" << endl;
1490 #endif
1491     if (child->element() && child->element()->id() == ID_FORM) {
1492         RenderContainer::addChild(child,beforeChild);
1493         return;
1494     }
1495
1496     RenderTableCell *cell;
1497
1498     if ( !child->isTableCell() ) {
1499         RenderObject *last = beforeChild;
1500         if ( !last )
1501             last = lastChild();
1502         RenderTableCell *cell = 0;
1503         if( last && last->isAnonymous() && last->isTableCell() )
1504             cell = static_cast<RenderTableCell *>(last);
1505         else {
1506             cell = new (renderArena()) RenderTableCell(document() /* anonymous object */);
1507             RenderStyle *newStyle = new (renderArena()) RenderStyle();
1508             newStyle->inheritFrom(style());
1509             newStyle->setDisplay( TABLE_CELL );
1510             cell->setStyle(newStyle);
1511             addChild(cell, beforeChild);
1512         }
1513         cell->addChild(child);
1514         child->setNeedsLayoutAndMinMaxRecalc();
1515         return;
1516     } else
1517         cell = static_cast<RenderTableCell *>(child);
1518
1519     static_cast<RenderTableSection *>(parent())->addCell( cell );
1520
1521     RenderContainer::addChild(cell,beforeChild);
1522
1523     if ( ( beforeChild || nextSibling()) && section() )
1524         section()->setNeedCellRecalc();
1525 }
1526
1527 RenderObject* RenderTableRow::removeChildNode(RenderObject* child)
1528 {
1529 // RenderTableCell detach should do it
1530 //     if ( section() )
1531 //      section()->setNeedCellRecalc();
1532     return RenderContainer::removeChildNode( child );
1533 }
1534
1535 #ifndef NDEBUG
1536 void RenderTableRow::dump(QTextStream *stream, QString ind) const
1537 {
1538     RenderContainer::dump(stream,ind);
1539 }
1540 #endif
1541
1542 void RenderTableRow::layout()
1543 {
1544     KHTMLAssert( needsLayout() );
1545     KHTMLAssert( minMaxKnown() );
1546
1547     RenderObject *child = firstChild();
1548     while( child ) {
1549         if (child->isTableCell()) {
1550             RenderTableCell *cell = static_cast<RenderTableCell *>(child);
1551             if (child->needsLayout()) {
1552                 cell->calcVerticalMargins();
1553                 cell->layout();
1554                 cell->setCellTopExtra(0);
1555                 cell->setCellBottomExtra(0);
1556             }
1557         }
1558         child = child->nextSibling();
1559     }
1560     setNeedsLayout(false);
1561 }
1562
1563 QRect RenderTableRow::getAbsoluteRepaintRect()
1564 {
1565     // For now, just repaint the whole table.
1566     // FIXME: Find a better way to do this.
1567     RenderTable* parentTable = table();
1568     if (parentTable)
1569         return parentTable->getAbsoluteRepaintRect();
1570     else
1571         return QRect();
1572 }
1573
1574 // -------------------------------------------------------------------------
1575
1576 RenderTableCell::RenderTableCell(DOM::NodeImpl* _node)
1577   : RenderBlock(_node)
1578 {
1579   _col = -1;
1580   _row = -1;
1581   updateFromElement();
1582   setShouldPaintBackgroundOrBorder(true);
1583   _topExtra = 0;
1584   _bottomExtra = 0;
1585   m_percentageHeight = 0;
1586 }
1587
1588 void RenderTableCell::detach()
1589 {
1590     if (parent() && section())
1591         section()->setNeedCellRecalc();
1592
1593     RenderBlock::detach();
1594 }
1595
1596 void RenderTableCell::updateFromElement()
1597 {
1598   DOM::NodeImpl *node = element();
1599   if ( node && (node->id() == ID_TD || node->id() == ID_TH) ) {
1600       DOM::HTMLTableCellElementImpl *tc = static_cast<DOM::HTMLTableCellElementImpl *>(node);
1601       cSpan = tc->colSpan();
1602       rSpan = tc->rowSpan();
1603   } else {
1604       cSpan = rSpan = 1;
1605   }
1606 }
1607
1608 void RenderTableCell::calcMinMaxWidth()
1609 {
1610     RenderBlock::calcMinMaxWidth();
1611     if (element() && style()->whiteSpace() == NORMAL) {
1612         // See if nowrap was set.
1613         DOMString nowrap = static_cast<ElementImpl*>(element())->getAttribute(ATTR_NOWRAP);
1614         if (!nowrap.isNull() && style()->width().isFixed())
1615             // Nowrap is set, but we didn't actually use it because of the
1616             // fixed width set on the cell.  Even so, it is a WinIE/Moz trait
1617             // to make the minwidth of the cell into the fixed width.  They do this
1618             // even in strict mode, so do not make this a quirk.  Affected the top
1619             // of hiptop.com.
1620             if (m_minWidth < style()->width().value)
1621                 m_minWidth = style()->width().value;
1622     }
1623 }
1624
1625 void RenderTableCell::calcWidth()
1626 {
1627 }
1628
1629 void RenderTableCell::setWidth( int width )
1630 {
1631     if ( width != m_width ) {
1632         m_width = width;
1633         m_widthChanged = true;
1634     }
1635 }
1636
1637 void RenderTableCell::layout()
1638 {
1639     layoutBlock(m_widthChanged);
1640     m_widthChanged = false;
1641 }
1642
1643 void RenderTableCell::computeAbsoluteRepaintRect(QRect& r, bool f)
1644 {
1645     r.setY(r.y() + _topExtra);
1646     RenderBlock::computeAbsoluteRepaintRect(r, f);
1647 }
1648
1649 bool RenderTableCell::absolutePosition(int &xPos, int &yPos, bool f)
1650 {
1651     bool ret = RenderBlock::absolutePosition(xPos, yPos, f);
1652     if (ret)
1653       yPos += _topExtra;
1654     return ret;
1655 }
1656
1657 short RenderTableCell::baselinePosition( bool ) const
1658 {
1659     RenderObject *o = firstChild();
1660     int offset = paddingTop() + borderTop();
1661     if ( !o ) return offset;
1662     while ( o->firstChild() ) {
1663         if ( !o->isInline() )
1664             offset += o->paddingTop() + o->borderTop();
1665         o = o->firstChild();
1666     }
1667     offset += o->baselinePosition( true );
1668     return offset;
1669 }
1670
1671
1672 void RenderTableCell::setStyle( RenderStyle *style )
1673 {
1674     style->setDisplay(TABLE_CELL);
1675
1676     if (style->whiteSpace() == KHTML_NOWRAP) {
1677         // Figure out if we are really nowrapping or if we should just
1678         // use normal instead.  If the width of the cell is fixed, then
1679         // we don't actually use NOWRAP.
1680         if (style->width().isFixed())
1681             style->setWhiteSpace(NORMAL);
1682         else
1683             style->setWhiteSpace(NOWRAP);
1684     }
1685
1686     RenderBlock::setStyle( style );
1687     setShouldPaintBackgroundOrBorder(true);
1688 }
1689
1690 bool RenderTableCell::requiresLayer() {
1691     // FIXME: This is only here until we figure out how to position
1692     // table cells properly when they have layers.
1693     return false;
1694 }
1695
1696 // The following rules apply for resolving conflicts and figuring out which border
1697 // to use.
1698 // (1) Borders with the 'border-style' of 'hidden' take precedence over all other conflicting
1699 // borders. Any border with this value suppresses all borders at this location.
1700 // (2) Borders with a style of 'none' have the lowest priority. Only if the border properties of all
1701 // the elements meeting at this edge are 'none' will the border be omitted (but note that 'none' is
1702 // the default value for the border style.)
1703 // (3) If none of the styles are 'hidden' and at least one of them is not 'none', then narrow borders
1704 // are discarded in favor of wider ones. If several have the same 'border-width' then styles are preferred
1705 // in this order: 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset', 'groove', and the lowest: 'inset'.
1706 // (4) If border styles differ only in color, then a style set on a cell wins over one on a row,
1707 // which wins over a row group, column, column group and, lastly, table. It is undefined which color
1708 // is used when two elements of the same type disagree.
1709 static CollapsedBorderValue compareBorders(const CollapsedBorderValue& border1,
1710                                            const CollapsedBorderValue& border2)
1711 {
1712     // Sanity check the values passed in.  If either is null, return the other.
1713     if (!border2.exists()) return border1;
1714     if (!border1.exists()) return border2;
1715
1716     // Rule #1 above.
1717     if (border1.style() == BHIDDEN || border2.style() == BHIDDEN)
1718         return CollapsedBorderValue(); // No border should exist at this location.
1719
1720     // Rule #2 above.  A style of 'none' has lowest priority and always loses to any other border.
1721     if (border2.style() == BNONE) return border1;
1722     if (border1.style() == BNONE) return border2;
1723
1724     // The first part of rule #3 above. Wider borders win.
1725     if (border1.width() != border2.width())
1726         return border1.width() > border2.width() ? border1 : border2;
1727
1728     // The borders have equal width.  Sort by border style.
1729     if (border1.style() != border2.style())
1730         return border1.style() > border2.style() ? border1 : border2;
1731
1732     // The border have the same width and style.  Rely on precedence (cell over row over row group, etc.)
1733     return border1.precedence >= border2.precedence ? border1 : border2;
1734 }
1735
1736 CollapsedBorderValue RenderTableCell::collapsedLeftBorder() const
1737 {
1738     // For border left, we need to check, in order of precedence:
1739     // (1) Our left border.
1740     CollapsedBorderValue result(&style()->borderLeft(), BCELL);
1741
1742     // (2) The previous cell's right border.
1743     RenderTableCell* prevCell = table()->cellLeft(this);
1744     if (prevCell) {
1745         result = compareBorders(result, CollapsedBorderValue(&prevCell->style()->borderRight(), BCELL));
1746         if (!result.exists()) return result;
1747     }
1748     else if (col() == 0) {
1749         // (3) Our row's left border.
1750         result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderLeft(), BROW));
1751         if (!result.exists()) return result;
1752
1753         // (4) Our row group's left border.
1754         result = compareBorders(result, CollapsedBorderValue(&section()->style()->borderLeft(), BROWGROUP));
1755         if (!result.exists()) return result;
1756     }
1757
1758     // (5) Our column's left border.
1759     RenderTableCol* colElt = table()->colElement(col());
1760     if (colElt) {
1761         result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderLeft(), BCOL));
1762         if (!result.exists()) return result;
1763     }
1764
1765     // (6) The previous column's right border.
1766     if (col() > 0) {
1767         colElt = table()->colElement(col()-1);
1768         if (colElt) {
1769             result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderRight(), BCOL));
1770             if (!result.exists()) return result;
1771         }
1772     }
1773
1774     if (col() == 0) {
1775         // (7) The table's left border.
1776         result = compareBorders(result, CollapsedBorderValue(&table()->style()->borderLeft(), BTABLE));
1777         if (!result.exists()) return result;
1778     }
1779
1780     return result;
1781 }
1782
1783 CollapsedBorderValue RenderTableCell::collapsedRightBorder() const
1784 {
1785     RenderTable* tableElt = table();
1786     bool inLastColumn = false;
1787     int effCol = tableElt->colToEffCol(col()+colSpan()-1);
1788     if (effCol == tableElt->numEffCols()-1)
1789         inLastColumn = true;
1790
1791     // For border right, we need to check, in order of precedence:
1792     // (1) Our right border.
1793     CollapsedBorderValue result = CollapsedBorderValue(&style()->borderRight(), BCELL);
1794
1795     // (2) The next cell's left border.
1796     if (!inLastColumn) {
1797         RenderTableCell* nextCell = tableElt->cellRight(this);
1798         if (nextCell) {
1799             result = compareBorders(result, CollapsedBorderValue(&nextCell->style()->borderLeft(), BCELL));
1800             if (!result.exists()) return result;
1801         }
1802     }
1803     else {
1804         // (3) Our row's right border.
1805         result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderRight(), BROW));
1806         if (!result.exists()) return result;
1807
1808         // (4) Our row group's right border.
1809         result = compareBorders(result, CollapsedBorderValue(&section()->style()->borderRight(), BROWGROUP));
1810         if (!result.exists()) return result;
1811     }
1812
1813     // (5) Our column's right border.
1814     RenderTableCol* colElt = table()->colElement(col()+colSpan()-1);
1815     if (colElt) {
1816         result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderRight(), BCOL));
1817         if (!result.exists()) return result;
1818     }
1819
1820     // (6) The next column's left border.
1821     if (!inLastColumn) {
1822         colElt = tableElt->colElement(col()+colSpan());
1823         if (colElt) {
1824             result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderLeft(), BCOL));
1825             if (!result.exists()) return result;
1826         }
1827     }
1828     else {
1829         // (7) The table's right border.
1830         result = compareBorders(result, CollapsedBorderValue(&tableElt->style()->borderRight(), BTABLE));
1831         if (!result.exists()) return result;
1832     }
1833
1834     return result;
1835 }
1836
1837 CollapsedBorderValue RenderTableCell::collapsedTopBorder() const
1838 {
1839     // For border top, we need to check, in order of precedence:
1840     // (1) Our top border.
1841     CollapsedBorderValue result = CollapsedBorderValue(&style()->borderTop(), BCELL);
1842
1843     RenderTableCell* prevCell = table()->cellAbove(this);
1844     if (prevCell) {
1845         // (2) A previous cell's bottom border.
1846         result = compareBorders(result, CollapsedBorderValue(&prevCell->style()->borderBottom(), BCELL));
1847         if (!result.exists()) return result;
1848     }
1849
1850     // (3) Our row's top border.
1851     result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderTop(), BROW));
1852     if (!result.exists()) return result;
1853
1854     // (4) The previous row's bottom border.
1855     if (prevCell) {
1856         RenderObject* prevRow = 0;
1857         if (prevCell->section() == section())
1858             prevRow = parent()->previousSibling();
1859         else
1860             prevRow = prevCell->section()->lastChild();
1861
1862         if (prevRow) {
1863             result = compareBorders(result, CollapsedBorderValue(&prevRow->style()->borderBottom(), BROW));
1864             if (!result.exists()) return result;
1865         }
1866     }
1867
1868     // Now check row groups.
1869     RenderObject* currSection = parent()->parent();
1870     if (row() == 0) {
1871         // (5) Our row group's top border.
1872         result = compareBorders(result, CollapsedBorderValue(&currSection->style()->borderTop(), BROWGROUP));
1873         if (!result.exists()) return result;
1874
1875         // (6) Previous row group's bottom border.
1876         for (currSection = currSection->previousSibling(); currSection;
1877              currSection = currSection->previousSibling()) {
1878             if (currSection->isTableSection()) {
1879                 RenderTableSection* section = static_cast<RenderTableSection*>(currSection);
1880                 result = compareBorders(result, CollapsedBorderValue(&section->style()->borderBottom(), BROWGROUP));
1881                 if (!result.exists()) return result;
1882             }
1883         }
1884     }
1885
1886     if (!currSection) {
1887         // (8) Our column's top border.
1888         RenderTableCol* colElt = table()->colElement(col());
1889         if (colElt) {
1890             result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderTop(), BCOL));
1891             if (!result.exists()) return result;
1892         }
1893
1894         // (9) The table's top border.
1895         result = compareBorders(result, CollapsedBorderValue(&table()->style()->borderTop(), BTABLE));
1896         if (!result.exists()) return result;
1897     }
1898
1899     return result;
1900 }
1901
1902 CollapsedBorderValue RenderTableCell::collapsedBottomBorder() const
1903 {
1904     // For border top, we need to check, in order of precedence:
1905     // (1) Our bottom border.
1906     CollapsedBorderValue result = CollapsedBorderValue(&style()->borderBottom(), BCELL);
1907
1908     RenderTableCell* nextCell = table()->cellBelow(this);
1909     if (nextCell) {
1910         // (2) A following cell's top border.
1911         result = compareBorders(result, CollapsedBorderValue(&nextCell->style()->borderTop(), BCELL));
1912         if (!result.exists()) return result;
1913     }
1914
1915     // (3) Our row's bottom border. (FIXME: Deal with rowspan!)
1916     result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderBottom(), BROW));
1917     if (!result.exists()) return result;
1918
1919     // (4) The next row's top border.
1920     if (nextCell) {
1921         result = compareBorders(result, CollapsedBorderValue(&nextCell->parent()->style()->borderTop(), BROW));
1922         if (!result.exists()) return result;
1923     }
1924
1925     // Now check row groups.
1926     RenderObject* currSection = parent()->parent();
1927     if (row()+rowSpan() >= static_cast<RenderTableSection*>(currSection)->numRows()) {
1928         // (5) Our row group's bottom border.
1929         result = compareBorders(result, CollapsedBorderValue(&currSection->style()->borderBottom(), BROWGROUP));
1930         if (!result.exists()) return result;
1931
1932         // (6) Following row group's top border.
1933         for (currSection = currSection->nextSibling(); currSection;
1934              currSection = currSection->nextSibling()) {
1935             if (currSection->isTableSection()) {
1936                 RenderTableSection* section = static_cast<RenderTableSection*>(currSection);
1937                 result = compareBorders(result, CollapsedBorderValue(&section->style()->borderTop(), BROWGROUP));
1938                 if (!result.exists()) return result;
1939             }
1940         }
1941     }
1942
1943     if (!currSection) {
1944         // (8) Our column's bottom border.
1945         RenderTableCol* colElt = table()->colElement(col());
1946         if (colElt) {
1947             result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderBottom(), BCOL));
1948             if (!result.exists()) return result;
1949         }
1950
1951         // (9) The table's bottom border.
1952         result = compareBorders(result, CollapsedBorderValue(&table()->style()->borderBottom(), BTABLE));
1953         if (!result.exists()) return result;
1954     }
1955
1956     return result;
1957 }
1958
1959 int RenderTableCell::borderLeft() const
1960 {
1961     if (table()->collapseBorders()) {
1962         CollapsedBorderValue border = collapsedLeftBorder();
1963         if (border.exists())
1964             return int(border.width()/2.0+0.5); // Give the extra pixel to top and left.
1965         return 0;
1966     }
1967     return RenderBlock::borderLeft();
1968 }
1969
1970 int RenderTableCell::borderRight() const
1971 {
1972     if (table()->collapseBorders()) {
1973         CollapsedBorderValue border = collapsedRightBorder();
1974         if (border.exists())
1975             return border.width()/2;
1976         return 0;
1977     }
1978     return RenderBlock::borderRight();
1979 }
1980
1981 int RenderTableCell::borderTop() const
1982 {
1983     if (table()->collapseBorders()) {
1984         CollapsedBorderValue border = collapsedTopBorder();
1985         if (border.exists())
1986             return int(border.width()/2.0+0.5); // Give the extra pixel to top and left.
1987         return 0;
1988     }
1989     return RenderBlock::borderTop();
1990 }
1991
1992 int RenderTableCell::borderBottom() const
1993 {
1994     if (table()->collapseBorders()) {
1995         CollapsedBorderValue border = collapsedBottomBorder();
1996         if (border.exists())
1997             return border.width()/2;
1998         return 0;
1999     }
2000     return RenderBlock::borderBottom();
2001 }
2002
2003 #ifdef BOX_DEBUG
2004 #include <qpainter.h>
2005
2006 static void outlineBox(QPainter *p, int _tx, int _ty, int w, int h)
2007 {
2008     p->setPen(QPen(QColor("yellow"), 3, Qt::DotLine));
2009     p->setBrush( Qt::NoBrush );
2010     p->drawRect(_tx, _ty, w, h );
2011 }
2012 #endif
2013
2014 void RenderTableCell::paint(PaintInfo& i, int _tx, int _ty)
2015 {
2016
2017 #ifdef TABLE_PRINT
2018     kdDebug( 6040 ) << renderName() << "(RenderTableCell)::paint() w/h = (" << width() << "/" << height() << ")" << " _y/_h=" << _y << "/" << _h << endl;
2019 #endif
2020
2021     _tx += m_x;
2022     _ty += m_y;
2023
2024     // check if we need to do anything at all...
2025     int os = 2*maximalOutlineSize(i.phase);
2026     if ((_ty >= i.r.y() + i.r.height() + os) || (_ty + _topExtra + m_height + _bottomExtra <= i.r.y() - os))
2027         return;
2028
2029     if (i.phase == PaintActionCollapsedTableBorders && style()->visibility() == VISIBLE) {
2030         int w = width();
2031         int h = height() + borderTopExtra() + borderBottomExtra();
2032         paintCollapsedBorder(i.p, _tx, _ty, w, h);
2033     }
2034     else
2035         RenderBlock::paintObject(i, _tx, _ty + _topExtra);
2036
2037 #ifdef BOX_DEBUG
2038     ::outlineBox( i.p, _tx, _ty, width(), height() + borderTopExtra() + borderBottomExtra());
2039 #endif
2040 }
2041
2042 static EBorderStyle collapsedBorderStyle(EBorderStyle style)
2043 {
2044     if (style == OUTSET)
2045         style = GROOVE;
2046     else if (style == INSET)
2047         style = RIDGE;
2048     return style;
2049 }
2050
2051 struct CollapsedBorder {
2052     CollapsedBorder(){}
2053
2054     CollapsedBorderValue border;
2055     RenderObject::BorderSide side;
2056     bool shouldPaint;
2057     int x1;
2058     int y1;
2059     int x2;
2060     int y2;
2061     EBorderStyle style;
2062 };
2063
2064 class CollapsedBorders
2065 {
2066 public:
2067     CollapsedBorders(int i) :count(0) {}
2068
2069     void addBorder(const CollapsedBorderValue& b, RenderObject::BorderSide s, bool paint,
2070                    int _x1, int _y1, int _x2, int _y2,
2071                    EBorderStyle _style)
2072     {
2073         if (b.exists() && paint) {
2074             borders[count].border = b;
2075             borders[count].side = s;
2076             borders[count].shouldPaint = paint;
2077             borders[count].x1 = _x1;
2078             borders[count].x2 = _x2;
2079             borders[count].y1 = _y1;
2080             borders[count].y2 = _y2;
2081             borders[count].style = _style;
2082             count++;
2083         }
2084     }
2085
2086     CollapsedBorder* nextBorder() {
2087         for (int i = 0; i < count; i++) {
2088             if (borders[i].border.exists() && borders[i].shouldPaint) {
2089                 borders[i].shouldPaint = false;
2090                 return &borders[i];
2091             }
2092         }
2093
2094         return 0;
2095     }
2096
2097     CollapsedBorder borders[4];
2098     int count;
2099 };
2100
2101 static void addBorderStyle(QValueList<CollapsedBorderValue>& borderStyles, CollapsedBorderValue borderValue)
2102 {
2103     if (!borderValue.exists() || borderStyles.contains(borderValue))
2104         return;
2105
2106     QValueListIterator<CollapsedBorderValue> it = borderStyles.begin();
2107     QValueListIterator<CollapsedBorderValue> end = borderStyles.end();
2108     for (; it != end; ++it) {
2109         CollapsedBorderValue result = compareBorders(*it, borderValue);
2110         if (result == *it) {
2111             borderStyles.insert(it, borderValue);
2112             return;
2113         }
2114     }
2115
2116     borderStyles.append(borderValue);
2117 }
2118
2119 void RenderTableCell::collectBorders(QValueList<CollapsedBorderValue>& borderStyles)
2120 {
2121     addBorderStyle(borderStyles, collapsedLeftBorder());
2122     addBorderStyle(borderStyles, collapsedRightBorder());
2123     addBorderStyle(borderStyles, collapsedTopBorder());
2124     addBorderStyle(borderStyles, collapsedBottomBorder());
2125 }
2126
2127 void RenderTableCell::paintCollapsedBorder(QPainter* p, int _tx, int _ty, int w, int h)
2128 {
2129     if (!table()->currentBorderStyle())
2130         return;
2131
2132     CollapsedBorderValue leftVal = collapsedLeftBorder();
2133     CollapsedBorderValue rightVal = collapsedRightBorder();
2134     CollapsedBorderValue topVal = collapsedTopBorder();
2135     CollapsedBorderValue bottomVal = collapsedBottomBorder();
2136
2137     // Adjust our x/y/width/height so that we paint the collapsed borders at the correct location.
2138     int topWidth = topVal.width();
2139     int bottomWidth = bottomVal.width();
2140     int leftWidth = leftVal.width();
2141     int rightWidth = rightVal.width();
2142
2143     _tx -= leftWidth/2;
2144     _ty -= topWidth/2;
2145     w += leftWidth/2 + int(rightWidth/2.0+0.5);
2146     h += topWidth/2 + int(bottomWidth/2.0+0.5);
2147
2148     bool tt = topVal.isTransparent();
2149     bool bt = bottomVal.isTransparent();
2150     bool rt = rightVal.isTransparent();
2151     bool lt = leftVal.isTransparent();
2152
2153     EBorderStyle ts = collapsedBorderStyle(topVal.style());
2154     EBorderStyle bs = collapsedBorderStyle(bottomVal.style());
2155     EBorderStyle ls = collapsedBorderStyle(leftVal.style());
2156     EBorderStyle rs = collapsedBorderStyle(rightVal.style());
2157
2158     bool render_t = ts > BHIDDEN && !tt;
2159     bool render_l = ls > BHIDDEN && !lt;
2160     bool render_r = rs > BHIDDEN && !rt;
2161     bool render_b = bs > BHIDDEN && !bt;
2162
2163     // We never paint diagonals at the joins.  We simply let the border with the highest
2164     // precedence paint on top of borders with lower precedence.
2165     CollapsedBorders borders(4);
2166     borders.addBorder(topVal, BSTop, render_t, _tx, _ty, _tx + w, _ty + topWidth, ts);
2167     borders.addBorder(bottomVal, BSBottom, render_b, _tx, _ty + h - bottomWidth, _tx + w, _ty + h, bs);
2168     borders.addBorder(leftVal, BSLeft, render_l, _tx, _ty, _tx + leftWidth, _ty + h, ls);
2169     borders.addBorder(rightVal, BSRight, render_r, _tx + w - rightWidth, _ty, _tx + w, _ty + h, rs);
2170
2171     for (CollapsedBorder* border = borders.nextBorder(); border; border = borders.nextBorder()) {
2172         if (border->border == *table()->currentBorderStyle())
2173             drawBorder(p, border->x1, border->y1, border->x2, border->y2, border->side,
2174                        border->border.color(), style()->color(), border->style, 0, 0);
2175     }
2176 }
2177
2178 QRect RenderTableCell::getAbsoluteRepaintRect()
2179 {
2180     int ow = style() ? style()->outlineSize() : 0;
2181     QRect r(-ow, -ow - borderTopExtra(),
2182             overflowWidth(false)+ow*2, overflowHeight(false)+borderTopExtra()+borderBottomExtra()+ow*2);
2183     computeAbsoluteRepaintRect(r);
2184     return r;
2185 }
2186
2187 void RenderTableCell::paintBoxDecorations(PaintInfo& i, int _tx, int _ty)
2188 {
2189     RenderTable* tableElt = table();
2190     if (!tableElt->collapseBorders() && style()->emptyCells() == HIDE && !firstChild())
2191         return;
2192
2193     int w = width();
2194     int h = height() + borderTopExtra() + borderBottomExtra();
2195     _ty -= borderTopExtra();
2196
2197     QColor c = style()->backgroundColor();
2198     if ( !c.isValid() && parent() ) // take from row
2199         c = parent()->style()->backgroundColor();
2200     if ( !c.isValid() && parent() && parent()->parent() ) // take from rowgroup
2201         c = parent()->parent()->style()->backgroundColor();
2202     if ( !c.isValid() ) {
2203         // see if we have a col or colgroup for this
2204         RenderTableCol *col = table()->colElement( _col );
2205         if ( col ) {
2206             c = col->style()->backgroundColor();
2207             if ( !c.isValid() ) {
2208                 // try column group
2209                 RenderStyle *style = col->parent()->style();
2210                 if ( style->display() == TABLE_COLUMN_GROUP )
2211                     c = style->backgroundColor();
2212             }
2213         }
2214     }
2215
2216     // FIXME: This code is just plain wrong.  Rows and columns should paint their backgrounds
2217     // independent from the cell.
2218     // ### get offsets right in case the bgimage is inherited.
2219     const BackgroundLayer* bgLayer = style()->backgroundLayers();
2220     if (!bgLayer->hasImage() && parent())
2221         bgLayer = parent()->style()->backgroundLayers();
2222     if (!bgLayer->hasImage() && parent() && parent()->parent())
2223         bgLayer = parent()->parent()->style()->backgroundLayers();
2224     if (!bgLayer->hasImage()) {
2225         // see if we have a col or colgroup for this
2226         RenderTableCol* col = table()->colElement(_col);
2227         if (col) {
2228             bgLayer = col->style()->backgroundLayers();
2229             if (!bgLayer->hasImage()) {
2230                 // try column group
2231                 RenderStyle *style = col->parent()->style();
2232                 if (style->display() == TABLE_COLUMN_GROUP)
2233                     bgLayer = style->backgroundLayers();
2234             }
2235         }
2236     }
2237
2238     int my = kMax(_ty, i.r.y());
2239     int end = kMin(i.r.y() + i.r.height(), _ty + h);
2240     int mh = end - my;
2241
2242     if (bgLayer->hasImage() || c.isValid())
2243         paintBackground(i.p, c, bgLayer, my, mh, _tx, _ty, w, h);
2244
2245     if (style()->hasBorder() && !tableElt->collapseBorders())
2246         paintBorder(i.p, _tx, _ty, w, h, style());
2247 }
2248
2249
2250 #ifndef NDEBUG
2251 void RenderTableCell::dump(QTextStream *stream, QString ind) const
2252 {
2253     *stream << " row=" << _row;
2254     *stream << " col=" << _col;
2255     *stream << " rSpan=" << rSpan;
2256     *stream << " cSpan=" << cSpan;
2257 //    *stream << " nWrap=" << nWrap;
2258
2259     RenderBlock::dump(stream,ind);
2260 }
2261 #endif
2262
2263 // -------------------------------------------------------------------------
2264
2265 RenderTableCol::RenderTableCol(DOM::NodeImpl* node)
2266     : RenderContainer(node)
2267 {
2268     // init RenderObject attributes
2269     setInline(true);   // our object is not Inline
2270
2271     _span = 1;
2272     updateFromElement();
2273 }
2274
2275 void RenderTableCol::updateFromElement()
2276 {
2277   DOM::NodeImpl *node = element();
2278   if ( node && (node->id() == ID_COL || node->id() == ID_COLGROUP) ) {
2279       DOM::HTMLTableColElementImpl *tc = static_cast<DOM::HTMLTableColElementImpl *>(node);
2280       _span = tc->span();
2281   } else
2282       _span = ! ( style() && style()->display() == TABLE_COLUMN_GROUP );
2283 }
2284
2285 bool RenderTableCol::canHaveChildren() const
2286 {
2287     // cols cannot have children.  This is actually necessary to fix a bug
2288     // with libraries.uc.edu, which makes a <p> be a table-column.
2289     return style()->display() == TABLE_COLUMN_GROUP;
2290 }
2291
2292 void RenderTableCol::addChild(RenderObject *child, RenderObject *beforeChild)
2293 {
2294 #ifdef DEBUG_LAYOUT
2295     //kdDebug( 6040 ) << renderName() << "(Table)::addChild( " << child->renderName() << " )"  << ", " <<
2296     //                   (beforeChild ? beforeChild->renderName() : 0) << " )" << endl;
2297 #endif
2298
2299     KHTMLAssert(child->style()->display() == TABLE_COLUMN);
2300
2301     // these have to come before the table definition!
2302     RenderContainer::addChild(child,beforeChild);
2303 }
2304
2305 #ifndef NDEBUG
2306 void RenderTableCol::dump(QTextStream *stream, QString ind) const
2307 {
2308     *stream << " _span=" << _span;
2309     RenderContainer::dump(stream,ind);
2310 }
2311 #endif
2312
2313 #undef TABLE_DEBUG
2314 #undef DEBUG_LAYOUT
2315 #undef BOX_DEBUG