WebCore/khtml/rendering/bidi.cpp

   1 /**
   2  * This file is part of the html renderer for KDE.
   3  *
   4  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
   5  * Copyright (C) 2004 Apple Computer, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public License
  18  * along with this library; see the file COPYING.LIB.  If not, write to
  19  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  */
  23 #include "bidi.h"
  24 #include "break_lines.h"
  25 #include "render_block.h"
  26 #include "render_text.h"
  27 #include "render_arena.h"
  28 #include "render_canvas.h"
  29 #include "khtmlview.h"
  30 #include "xml/dom_docimpl.h"
  31
  32 #include "kdebug.h"
  33 #include "qdatetime.h"
  34 #include "qfontmetrics.h"
  35
  36 #define BIDI_DEBUG 0
  37 //#define DEBUG_LINEBREAKS
  38
  39 using DOM::AtomicString;
  40
  41 namespace khtml {
  42
  43
  44 // an iterator which goes through a BidiParagraph
  45 struct BidiIterator
  46 {
  47     BidiIterator() : par(0), obj(0), pos(0) {}
  48     BidiIterator(RenderBlock *_par, RenderObject *_obj, unsigned int _pos) : par(_par), obj(_obj), pos(_pos) {}
  49
  50     void increment( BidiState &bidi );
  51
  52     bool atEnd() const;
  53
  54     const QChar &current() const;
  55     QChar::Direction direction() const;
  56
  57     RenderBlock *par;
  58     RenderObject *obj;
  59     unsigned int pos;
  60 };
  61
  62 struct BidiStatus {
  63     BidiStatus() : eor(QChar::DirON), lastStrong(QChar::DirON), last(QChar::DirON) {}
  64
  65     QChar::Direction eor;
  66     QChar::Direction lastStrong;
  67     QChar::Direction last;
  68 };
  69
  70 struct BidiState {
  71     BidiState() : context(0) {}
  72
  73     BidiIterator sor;
  74     BidiIterator eor;
  75     BidiIterator last;
  76     BidiIterator current;
  77     BidiContext *context;
  78     BidiStatus status;
  79 };
  80
  81 // Used to track a list of chained bidi runs.
  82 static BidiRun* sFirstBidiRun;
  83 static BidiRun* sLastBidiRun;
  84 static int sBidiRunCount;
  85 static BidiRun* sCompactFirstBidiRun;
  86 static BidiRun* sCompactLastBidiRun;
  87 static int sCompactBidiRunCount;
  88 static bool sBuildingCompactRuns;
  89
  90 // Midpoint globals.  The goal is not to do any allocation when dealing with
  91 // these midpoints, so we just keep an array around and never clear it.  We track
  92 // the number of items and position using the two other variables.
  93 static QMemArray<BidiIterator> *smidpoints;
  94 static uint sNumMidpoints;
  95 static uint sCurrMidpoint;
  96 static bool betweenMidpoints;
  97
  98 static bool isLineEmpty = true;
  99 static bool previousLineBrokeCleanly = true;
 100 static QChar::Direction dir;
 101 static bool adjustEmbedding;
 102 static bool emptyRun = true;
 103 static int numSpaces;
 104
 105 static void embed( QChar::Direction d, BidiState &bidi );
 106 static void appendRun( BidiState &bidi );
 107
 108 static int getBPMWidth(int childValue, Length cssUnit)
 109 {
 110     if (cssUnit.type != Variable)
 111         return (cssUnit.type == Fixed ? cssUnit.value : childValue);
 112     return 0;
 113 }
 114
 115 static int getBorderPaddingMargin(RenderObject* child, bool endOfInline)
 116 {
 117     RenderStyle* cstyle = child->style();
 118     int result = 0;
 119     bool leftSide = (cstyle->direction() == LTR) ? !endOfInline : endOfInline;
 120     result += getBPMWidth((leftSide ? child->marginLeft() : child->marginRight()),
 121                           (leftSide ? cstyle->marginLeft() :
 122                            cstyle->marginRight()));
 123     result += getBPMWidth((leftSide ? child->paddingLeft() : child->paddingRight()),
 124                           (leftSide ? cstyle->paddingLeft() :
 125                            cstyle->paddingRight()));
 126     result += leftSide ? child->borderLeft() : child->borderRight();
 127     return result;
 128 }
 129
 130 static int inlineWidth(RenderObject* child, bool start = true, bool end = true)
 131 {
 132     int extraWidth = 0;
 133     RenderObject* parent = child->parent();
 134     while (parent->isInline() && !parent->isInlineBlockOrInlineTable()) {
 135         if (start && parent->firstChild() == child)
 136             extraWidth += getBorderPaddingMargin(parent, false);
 137         if (end && parent->lastChild() == child)
 138             extraWidth += getBorderPaddingMargin(parent, true);
 139         child = parent;
 140         parent = child->parent();
 141     }
 142     return extraWidth;
 143 }
 144
 145 #ifndef NDEBUG
 146 static bool inBidiRunDetach;
 147 #endif
 148
 149 void BidiRun::detach(RenderArena* renderArena)
 150 {
 151 #ifndef NDEBUG
 152     inBidiRunDetach = true;
 153 #endif
 154     delete this;
 155 #ifndef NDEBUG
 156     inBidiRunDetach = false;
 157 #endif
 158
 159     // Recover the size left there for us by operator delete and free the memory.
 160     renderArena->free(*(size_t *)this, this);
 161 }
 162
 163 void* BidiRun::operator new(size_t sz, RenderArena* renderArena) throw()
 164 {
 165     return renderArena->allocate(sz);
 166 }
 167
 168 void BidiRun::operator delete(void* ptr, size_t sz)
 169 {
 170     assert(inBidiRunDetach);
 171
 172     // Stash size where detach can find it.
 173     *(size_t*)ptr = sz;
 174 }
 175
 176 static void deleteBidiRuns(RenderArena* arena)
 177 {
 178     if (!sFirstBidiRun)
 179         return;
 180
 181     BidiRun* curr = sFirstBidiRun;
 182     while (curr) {
 183         BidiRun* s = curr->nextRun;
 184         curr->detach(arena);
 185         curr = s;
 186     }
 187
 188     sFirstBidiRun = 0;
 189     sLastBidiRun = 0;
 190     sBidiRunCount = 0;
 191 }
 192
 193 // ---------------------------------------------------------------------
 194
 195 /* a small helper class used internally to resolve Bidi embedding levels.
 196    Each line of text caches the embedding level at the start of the line for faster
 197    relayouting
 198 */
 199 BidiContext::BidiContext(unsigned char l, QChar::Direction e, BidiContext *p, bool o)
 200     : level(l) , override(o), dir(e)
 201 {
 202     parent = p;
 203     if(p) {
 204         p->ref();
 205         basicDir = p->basicDir;
 206     } else
 207         basicDir = e;
 208     count = 0;
 209 }
 210
 211 BidiContext::~BidiContext()
 212 {
 213     if(parent) parent->deref();
 214 }
 215
 216 void BidiContext::ref() const
 217 {
 218     count++;
 219 }
 220
 221 void BidiContext::deref() const
 222 {
 223     count--;
 224     if(count <= 0) delete this;
 225 }
 226
 227 // ---------------------------------------------------------------------
 228
 229 inline bool operator==( const BidiIterator &it1, const BidiIterator &it2 )
 230 {
 231     if(it1.pos != it2.pos) return false;
 232     if(it1.obj != it2.obj) return false;
 233     return true;
 234 }
 235
 236 inline bool operator!=( const BidiIterator &it1, const BidiIterator &it2 )
 237 {
 238     if(it1.pos != it2.pos) return true;
 239     if(it1.obj != it2.obj) return true;
 240     return false;
 241 }
 242
 243 static inline RenderObject *Bidinext(RenderObject *par, RenderObject *current, BidiState &bidi,
 244                                      bool skipInlines = true, bool* endOfInline = 0)
 245 {
 246     RenderObject *next = 0;
 247     bool oldEndOfInline = endOfInline ? *endOfInline : false;
 248     if (endOfInline)
 249         *endOfInline = false;
 250
 251     while(current != 0)
 252     {
 253         //kdDebug( 6040 ) << "current = " << current << endl;
 254         if (!oldEndOfInline && !current->isFloating() && !current->isReplaced() && !current->isPositioned()) {
 255             next = current->firstChild();
 256             if ( next && adjustEmbedding ) {
 257                 EUnicodeBidi ub = next->style()->unicodeBidi();
 258                 if ( ub != UBNormal && !emptyRun ) {
 259                     EDirection dir = next->style()->direction();
 260 QChar::Direction d = ( ub == Embed ? ( dir == RTL ? QChar::DirRLE : QChar::DirLRE )
 261                                    : ( dir == RTL ? QChar::DirRLO : QChar::DirLRO ) );
 262                     embed( d, bidi );
 263                 }
 264             }
 265         }
 266         if (!next) {
 267             if (!skipInlines && !oldEndOfInline && current->isInlineFlow())
 268             {
 269                 next = current;
 270                 if (endOfInline)
 271                     *endOfInline = true;
 272                 break;
 273             }
 274
 275             while (current && current != par) {
 276                 next = current->nextSibling();
 277                 if (next) break;
 278                 if ( adjustEmbedding && current->style()->unicodeBidi() != UBNormal && !emptyRun ) {
 279                     embed( QChar::DirPDF, bidi );
 280                 }
 281                 current = current->parent();
 282                 if (!skipInlines && current && current != par && current->isInlineFlow()) {
 283                     next = current;
 284                     if (endOfInline)
 285                         *endOfInline = true;
 286                     break;
 287                 }
 288             }
 289         }
 290
 291         if (!next) break;
 292
 293         if (next->isText() || next->isBR() || next->isFloating() || next->isReplaced() || next->isPositioned()
 294             || ((!skipInlines || !next->firstChild()) // Always return EMPTY inlines.
 295                 && next->isInlineFlow()))
 296             break;
 297         current = next;
 298     }
 299     return next;
 300 }
 301
 302 static RenderObject *first( RenderObject *par, BidiState &bidi, bool skipInlines = true )
 303 {
 304     if(!par->firstChild()) return 0;
 305     RenderObject *o = par->firstChild();
 306
 307     if (o->isInlineFlow()) {
 308         if (skipInlines && o->firstChild())
 309             o = Bidinext( par, o, bidi, skipInlines );
 310         else
 311             return o; // Never skip empty inlines.
 312     }
 313
 314     if (o && !o->isText() && !o->isBR() && !o->isReplaced() && !o->isFloating() && !o->isPositioned())
 315         o = Bidinext( par, o, bidi, skipInlines );
 316     return o;
 317 }
 318
 319 inline void BidiIterator::increment (BidiState &bidi)
 320 {
 321     if(!obj) return;
 322     if(obj->isText()) {
 323         pos++;
 324         if(pos >= static_cast<RenderText *>(obj)->stringLength()) {
 325             obj = Bidinext( par, obj, bidi );
 326             pos = 0;
 327         }
 328     } else {
 329         obj = Bidinext( par, obj, bidi );
 330         pos = 0;
 331     }
 332 }
 333
 334 inline bool BidiIterator::atEnd() const
 335 {
 336     if(!obj) return true;
 337     return false;
 338 }
 339
 340 const QChar &BidiIterator::current() const
 341 {
 342     static QChar nullCharacter;
 343
 344     if (!obj || !obj->isText())
 345       return nullCharacter;
 346
 347     RenderText* text = static_cast<RenderText*>(obj);
 348     if (!text->text())
 349         return nullCharacter;
 350
 351     return text->text()[pos];
 352 }
 353
 354 inline QChar::Direction BidiIterator::direction() const
 355 {
 356     if (!obj)
 357         return QChar::DirON;
 358     if (obj->isListMarker())
 359         return obj->style()->direction() == LTR ? QChar::DirL : QChar::DirR;
 360     if (!obj->isText())
 361         return QChar::DirON;
 362
 363     RenderText *renderTxt = static_cast<RenderText *>( obj );
 364     if ( pos >= renderTxt->stringLength() )
 365         return QChar::DirON;
 366
 367     return renderTxt->text()[pos].direction();
 368 }
 369
 370 // -------------------------------------------------------------------------------------------------
 371
 372 static void addRun(BidiRun* bidiRun)
 373 {
 374     if (!sFirstBidiRun)
 375         sFirstBidiRun = sLastBidiRun = bidiRun;
 376     else {
 377         sLastBidiRun->nextRun = bidiRun;
 378         sLastBidiRun = bidiRun;
 379     }
 380     sBidiRunCount++;
 381     bidiRun->compact = sBuildingCompactRuns;
 382
 383     // Compute the number of spaces in this run,
 384     if (bidiRun->obj && bidiRun->obj->isText()) {
 385         RenderText* text = static_cast<RenderText*>(bidiRun->obj);
 386         if (text->text()) {
 387             for (int i = bidiRun->start; i < bidiRun->stop; i++) {
 388                 const QChar c = text->text()[i];
 389                 if (c == ' ' || c == '\n')
 390                     numSpaces++;
 391             }
 392         }
 393     }
 394 }
 395
 396 static void reverseRuns(int start, int end)
 397 {
 398     if (start >= end)
 399         return;
 400
 401     assert(start >= 0 && end < sBidiRunCount);
 402
 403     // Get the item before the start of the runs to reverse and put it in
 404     // |beforeStart|.  |curr| should point to the first run to reverse.
 405     BidiRun* curr = sFirstBidiRun;
 406     BidiRun* beforeStart = 0;
 407     int i = 0;
 408     while (i < start) {
 409         i++;
 410         beforeStart = curr;
 411         curr = curr->nextRun;
 412     }
 413
 414     BidiRun* startRun = curr;
 415     while (i < end) {
 416         i++;
 417         curr = curr->nextRun;
 418     }
 419     BidiRun* endRun = curr;
 420     BidiRun* afterEnd = curr->nextRun;
 421
 422     i = start;
 423     curr = startRun;
 424     BidiRun* newNext = afterEnd;
 425     while (i <= end) {
 426         // Do the reversal.
 427         BidiRun* next = curr->nextRun;
 428         curr->nextRun = newNext;
 429         newNext = curr;
 430         curr = next;
 431         i++;
 432     }
 433
 434     // Now hook up beforeStart and afterEnd to the newStart and newEnd.
 435     if (beforeStart)
 436         beforeStart->nextRun = endRun;
 437     else
 438         sFirstBidiRun = endRun;
 439
 440     startRun->nextRun = afterEnd;
 441     if (!afterEnd)
 442         sLastBidiRun = startRun;
 443 }
 444
 445 static void chopMidpointsAt(RenderObject* obj, uint pos)
 446 {
 447     if (!sNumMidpoints) return;
 448     BidiIterator* midpoints = smidpoints->data();
 449     for (uint i = 0; i < sNumMidpoints; i++) {
 450         const BidiIterator& point = midpoints[i];
 451         if (point.obj == obj && point.pos == pos) {
 452             sNumMidpoints = i;
 453             break;
 454         }
 455     }
 456 }
 457
 458 static void checkMidpoints(BidiIterator& lBreak, BidiState &bidi)
 459 {
 460     // Check to see if our last midpoint is a start point beyond the line break.  If so,
 461     // shave it off the list, and shave off a trailing space if the previous end point isn't
 462     // white-space: pre.
 463     if (lBreak.obj && sNumMidpoints && sNumMidpoints%2 == 0) {
 464         BidiIterator* midpoints = smidpoints->data();
 465         BidiIterator& endpoint = midpoints[sNumMidpoints-2];
 466         const BidiIterator& startpoint = midpoints[sNumMidpoints-1];
 467         BidiIterator currpoint = endpoint;
 468         while (!currpoint.atEnd() && currpoint != startpoint && currpoint != lBreak)
 469             currpoint.increment( bidi );
 470         if (currpoint == lBreak) {
 471             // We hit the line break before the start point.  Shave off the start point.
 472             sNumMidpoints--;
 473             if (endpoint.obj->style()->whiteSpace() != PRE) {
 474                 if (endpoint.obj->isText()) {
 475                     // Don't shave a character off the endpoint if it was from a soft hyphen.
 476                     RenderText* textObj = static_cast<RenderText*>(endpoint.obj);
 477                     if (endpoint.pos+1 < textObj->length() &&
 478                         textObj->text()[endpoint.pos+1].unicode() == SOFT_HYPHEN)
 479                         return;
 480                 }
 481                 endpoint.pos--;
 482             }
 483         }
 484     }
 485 }
 486
 487 static void addMidpoint(const BidiIterator& midpoint)
 488 {
 489     if (!smidpoints)
 490         return;
 491
 492     if (smidpoints->size() <= sNumMidpoints)
 493         smidpoints->resize(sNumMidpoints+10);
 494
 495     BidiIterator* midpoints = smidpoints->data();
 496     midpoints[sNumMidpoints++] = midpoint;
 497 }
 498
 499 static void appendRunsForObject(int start, int end, RenderObject* obj, BidiState &bidi)
 500 {
 501     if (start > end || obj->isFloating() ||
 502         (obj->isPositioned() && !obj->hasStaticX() && !obj->hasStaticY() && !obj->container()->isInlineFlow()))
 503         return;
 504
 505     bool haveNextMidpoint = (smidpoints && sCurrMidpoint < sNumMidpoints);
 506     BidiIterator nextMidpoint;
 507     if (haveNextMidpoint)
 508         nextMidpoint = smidpoints->at(sCurrMidpoint);
 509     if (betweenMidpoints) {
 510         if (!(haveNextMidpoint && nextMidpoint.obj == obj))
 511             return;
 512         // This is a new start point. Stop ignoring objects and
 513         // adjust our start.
 514         betweenMidpoints = false;
 515         start = nextMidpoint.pos;
 516         sCurrMidpoint++;
 517         if (start < end)
 518             return appendRunsForObject(start, end, obj, bidi);
 519     }
 520     else {
 521         if (!smidpoints || !haveNextMidpoint || (obj != nextMidpoint.obj)) {
 522             addRun(new (obj->renderArena()) BidiRun(start, end, obj, bidi.context, dir));
 523             return;
 524         }
 525
 526         // An end midpoint has been encountered within our object.  We
 527         // need to go ahead and append a run with our endpoint.
 528         if (int(nextMidpoint.pos+1) <= end) {
 529             betweenMidpoints = true;
 530             sCurrMidpoint++;
 531             if (nextMidpoint.pos != UINT_MAX) { // UINT_MAX means stop at the object and don't include any of it.
 532                 addRun(new (obj->renderArena())
 533                     BidiRun(start, nextMidpoint.pos+1, obj, bidi.context, dir));
 534                 return appendRunsForObject(nextMidpoint.pos+1, end, obj, bidi);
 535             }
 536         }
 537         else
 538            addRun(new (obj->renderArena()) BidiRun(start, end, obj, bidi.context, dir));
 539     }
 540 }
 541
 542 static void appendRun( BidiState &bidi )
 543 {
 544     if ( emptyRun ) return;
 545 #if BIDI_DEBUG > 1
 546     kdDebug(6041) << "appendRun: dir="<<(int)dir<<endl;
 547 #endif
 548
 549     bool b = adjustEmbedding;
 550     adjustEmbedding = false;
 551
 552     int start = bidi.sor.pos;
 553     RenderObject *obj = bidi.sor.obj;
 554     while( obj && obj != bidi.eor.obj ) {
 555         appendRunsForObject(start, obj->length(), obj, bidi);
 556         start = 0;
 557         obj = Bidinext( bidi.sor.par, obj, bidi );
 558     }
 559     if (obj)
 560         appendRunsForObject(start, bidi.eor.pos+1, obj, bidi);
 561
 562     bidi.eor.increment( bidi );
 563     bidi.sor = bidi.eor;
 564     dir = QChar::DirON;
 565     bidi.status.eor = QChar::DirON;
 566     adjustEmbedding = b;
 567 }
 568
 569 static void embed( QChar::Direction d, BidiState &bidi )
 570 {
 571 #if BIDI_DEBUG > 1
 572     qDebug("*** embed dir=%d emptyrun=%d", d, emptyRun );
 573 #endif
 574     bool b = adjustEmbedding ;
 575     adjustEmbedding = false;
 576     if ( d == QChar::DirPDF ) {
 577         BidiContext *c = bidi.context->parent;
 578         if (c) {
 579             if ( bidi.eor != bidi.last ) {
 580                 appendRun( bidi );
 581                 bidi.eor = bidi.last;
 582             }
 583             appendRun( bidi );
 584             emptyRun = true;
 585             bidi.status.last = bidi.context->dir;
 586             bidi.context->deref();
 587             bidi.context = c;
 588             if(bidi.context->override)
 589                 dir = bidi.context->dir;
 590             else
 591                 dir = QChar::DirON;
 592             bidi.status.lastStrong = bidi.context->dir;
 593         }
 594     } else {
 595         QChar::Direction runDir;
 596         if( d == QChar::DirRLE || d == QChar::DirRLO )
 597             runDir = QChar::DirR;
 598         else
 599             runDir = QChar::DirL;
 600         bool override;
 601         if( d == QChar::DirLRO || d == QChar::DirRLO )
 602             override = true;
 603         else
 604             override = false;
 605
 606         unsigned char level = bidi.context->level;
 607         if ( runDir == QChar::DirR ) {
 608             if(level%2) // we have an odd level
 609                 level += 2;
 610             else
 611                 level++;
 612         } else {
 613             if(level%2) // we have an odd level
 614                 level++;
 615             else
 616                 level += 2;
 617         }
 618
 619         if(level < 61) {
 620             if ( bidi.eor != bidi.last ) {
 621                 appendRun( bidi );
 622                 bidi.eor = bidi.last;
 623             }
 624             appendRun( bidi );
 625             emptyRun = true;
 626
 627             bidi.context = new BidiContext(level, runDir, bidi.context, override);
 628             bidi.context->ref();
 629             if ( override )
 630                 dir = runDir;
 631             bidi.status.last = runDir;
 632             bidi.status.lastStrong = runDir;
 633         }
 634     }
 635     adjustEmbedding = b;
 636 }
 637
 638 InlineFlowBox* RenderBlock::createLineBoxes(RenderObject* obj)
 639 {
 640     // See if we have an unconstructed line box for this object that is also
 641     // the last item on the line.
 642     KHTMLAssert(obj->isInlineFlow() || obj == this);
 643     RenderFlow* flow = static_cast<RenderFlow*>(obj);
 644
 645     // Get the last box we made for this render object.
 646     InlineFlowBox* box = flow->lastLineBox();
 647
 648     // If this box is constructed then it is from a previous line, and we need
 649     // to make a new box for our line.  If this box is unconstructed but it has
 650     // something following it on the line, then we know we have to make a new box
 651     // as well.  In this situation our inline has actually been split in two on
 652     // the same line (this can happen with very fancy language mixtures).
 653     if (!box || box->isConstructed() || box->nextOnLine()) {
 654         // We need to make a new box for this render object.  Once
 655         // made, we need to place it at the end of the current line.
 656         InlineBox* newBox = obj->createInlineBox(false, obj == this);
 657         KHTMLAssert(newBox->isInlineFlowBox());
 658         box = static_cast<InlineFlowBox*>(newBox);
 659         box->setFirstLineStyleBit(m_firstLine);
 660
 661         // We have a new box. Append it to the inline box we get by constructing our
 662         // parent.  If we have hit the block itself, then |box| represents the root
 663         // inline box for the line, and it doesn't have to be appended to any parent
 664         // inline.
 665         if (obj != this) {
 666             InlineFlowBox* parentBox = createLineBoxes(obj->parent());
 667             parentBox->addToLine(box);
 668         }
 669     }
 670
 671     return box;
 672 }
 673
 674 RootInlineBox* RenderBlock::constructLine(const BidiIterator &start, const BidiIterator &end)
 675 {
 676     if (!sFirstBidiRun)
 677         return 0; // We had no runs. Don't make a root inline box at all. The line is empty.
 678
 679     InlineFlowBox* parentBox = 0;
 680     for (BidiRun* r = sFirstBidiRun; r; r = r->nextRun) {
 681         // Create a box for our object.
 682         r->box = r->obj->createInlineBox(r->obj->isPositioned(), false, sBidiRunCount == 1);
 683         if (r->box) {
 684             // If we have no parent box yet, or if the run is not simply a sibling,
 685             // then we need to construct inline boxes as necessary to properly enclose the
 686             // run's inline box.
 687             if (!parentBox || (parentBox->object() != r->obj->parent()))
 688                 // Create new inline boxes all the way back to the appropriate insertion point.
 689                 parentBox = createLineBoxes(r->obj->parent());
 690
 691             // Append the inline box to this line.
 692             parentBox->addToLine(r->box);
 693         }
 694     }
 695
 696     // We should have a root inline box.  It should be unconstructed and
 697     // be the last continuation of our line list.
 698     KHTMLAssert(lastLineBox() && !lastLineBox()->isConstructed());
 699
 700     // Set bits on our inline flow boxes that indicate which sides should
 701     // paint borders/margins/padding.  This knowledge will ultimately be used when
 702     // we determine the horizontal positions and widths of all the inline boxes on
 703     // the line.
 704     RenderObject* endObject = 0;
 705     bool lastLine = !end.obj;
 706     if (end.obj && end.pos == 0)
 707         endObject = end.obj;
 708     lastLineBox()->determineSpacingForFlowBoxes(lastLine, endObject);
 709
 710     // Now mark the line boxes as being constructed.
 711     lastLineBox()->setConstructed();
 712
 713     // Return the last line.
 714     return lastRootBox();
 715 }
 716
 717 void RenderBlock::computeHorizontalPositionsForLine(RootInlineBox* lineBox, BidiState &bidi)
 718 {
 719     // First determine our total width.
 720     int availableWidth = lineWidth(m_height);
 721     int totWidth = lineBox->getFlowSpacingWidth();
 722     BidiRun* r = 0;
 723     for (r = sFirstBidiRun; r; r = r->nextRun) {
 724         if (!r->box || r->obj->isPositioned())
 725             continue; // Positioned objects are only participating to figure out their
 726                       // correct static x position.  They have no effect on the width.
 727         if (r->obj->isText()) {
 728             int textWidth = static_cast<RenderText *>(r->obj)->width(r->start, r->stop-r->start, m_firstLine);
 729             if (!r->compact) {
 730                 RenderStyle *style = r->obj->style();
 731                 if (style->whiteSpace() == NORMAL && style->khtmlLineBreak() == AFTER_WHITE_SPACE) {
 732                     // shrink the box as needed to keep the line from overflowing the available width
 733                     textWidth = kMin(textWidth, availableWidth - totWidth + style->borderLeftWidth());
 734                 }
 735             }
 736             r->box->setWidth(textWidth);
 737         }
 738         else if (!r->obj->isInlineFlow()) {
 739             r->obj->calcWidth();
 740             r->box->setWidth(r->obj->width());
 741             if (!r->compact)
 742                 totWidth += r->obj->marginLeft() + r->obj->marginRight();
 743         }
 744
 745         // Compacts don't contribute to the width of the line, since they are placed in the margin.
 746         if (!r->compact)
 747             totWidth += r->box->width();
 748     }
 749
 750     // Armed with the total width of the line (without justification),
 751     // we now examine our text-align property in order to determine where to position the
 752     // objects horizontally.  The total width of the line can be increased if we end up
 753     // justifying text.
 754     int x = leftOffset(m_height);
 755     switch(style()->textAlign()) {
 756         case LEFT:
 757         case KHTML_LEFT:
 758             // The direction of the block should determine what happens with wide lines.  In
 759             // particular with RTL blocks, wide lines should still spill out to the left.
 760             if (style()->direction() == RTL && totWidth > availableWidth)
 761                 x -= (totWidth - availableWidth);
 762             numSpaces = 0;
 763             break;
 764         case JUSTIFY:
 765             if (numSpaces != 0 && !bidi.current.atEnd() && !lineBox->endsWithBreak())
 766                 break;
 767             // fall through
 768         case TAAUTO:
 769             numSpaces = 0;
 770             // for right to left fall through to right aligned
 771             if (bidi.context->basicDir == QChar::DirL)
 772                 break;
 773         case RIGHT:
 774         case KHTML_RIGHT:
 775             // Wide lines spill out of the block based off direction.
 776             // So even if text-align is right, if direction is LTR, wide lines should overflow out of the right
 777             // side of the block.
 778             if (style()->direction() == RTL || totWidth < availableWidth)
 779                 x += availableWidth - totWidth;
 780             numSpaces = 0;
 781             break;
 782         case CENTER:
 783         case KHTML_CENTER:
 784             int xd = (availableWidth - totWidth)/2;
 785             x += xd >0 ? xd : 0;
 786             numSpaces = 0;
 787             break;
 788     }
 789
 790     if (numSpaces > 0) {
 791         for (r = sFirstBidiRun; r; r = r->nextRun) {
 792             if (!r->box) continue;
 793
 794             int spaceAdd = 0;
 795             if (numSpaces > 0 && r->obj->isText() && !r->compact) {
 796                 // get the number of spaces in the run
 797                 int spaces = 0;
 798                 for ( int i = r->start; i < r->stop; i++ ) {
 799                     const QChar c = static_cast<RenderText *>(r->obj)->text()[i];
 800                     if (c == ' ' || c == '\n')
 801                         spaces++;
 802                 }
 803
 804                 KHTMLAssert(spaces <= numSpaces);
 805
 806                 // Only justify text with white-space: normal.
 807                 if (r->obj->style()->whiteSpace() != PRE) {
 808                     spaceAdd = (availableWidth - totWidth)*spaces/numSpaces;
 809                     static_cast<InlineTextBox*>(r->box)->setSpaceAdd(spaceAdd);
 810                     totWidth += spaceAdd;
 811                 }
 812                 numSpaces -= spaces;
 813             }
 814         }
 815     }
 816
 817     // The widths of all runs are now known.  We can now place every inline box (and
 818     // compute accurate widths for the inline flow boxes).
 819     int leftPosition = x;
 820     int rightPosition = x;
 821     lineBox->placeBoxesHorizontally(x, leftPosition, rightPosition);
 822     lineBox->setHorizontalOverflowPositions(leftPosition, rightPosition);
 823 }
 824
 825 void RenderBlock::computeVerticalPositionsForLine(RootInlineBox* lineBox)
 826 {
 827     lineBox->verticallyAlignBoxes(m_height);
 828     lineBox->setBlockHeight(m_height);
 829
 830     // See if the line spilled out.  If so set overflow height accordingly.
 831     int bottomOfLine = lineBox->bottomOverflow();
 832     if (bottomOfLine > m_height && bottomOfLine > m_overflowHeight)
 833         m_overflowHeight = bottomOfLine;
 834
 835     // Now make sure we place replaced render objects correctly.
 836     for (BidiRun* r = sFirstBidiRun; r; r = r->nextRun) {
 837         if (!r->box) continue; // Skip runs with no line boxes.
 838
 839         // Align positioned boxes with the top of the line box.  This is
 840         // a reasonable approximation of an appropriate y position.
 841         if (r->obj->isPositioned())
 842             r->box->setYPos(m_height);
 843
 844         // Position is used to properly position both replaced elements and
 845         // to update the static normal flow x/y of positioned elements.
 846         r->obj->position(r->box, r->start, r->stop - r->start, r->level%2);
 847     }
 848 }
 849
 850 // collects one line of the paragraph and transforms it to visual order
 851 void RenderBlock::bidiReorderLine(const BidiIterator &start, const BidiIterator &end, BidiState &bidi)
 852 {
 853     if ( start == end ) {
 854         if ( start.current() == '\n' ) {
 855             m_height += lineHeight( m_firstLine, true );
 856         }
 857         return;
 858     }
 859
 860 #if BIDI_DEBUG > 1
 861     kdDebug(6041) << "reordering Line from " << start.obj << "/" << start.pos << " to " << end.obj << "/" << end.pos << endl;
 862 #endif
 863
 864     sFirstBidiRun = 0;
 865     sLastBidiRun = 0;
 866     sBidiRunCount = 0;
 867
 868     //    context->ref();
 869
 870     dir = QChar::DirON;
 871
 872     // Adopt the directionality of the text's element if specified as RTL
 873     // and the first position is neutral.
 874     if (start.direction() == QChar::DirON) {
 875         if (start.obj) {
 876             if (start.obj->style()->direction() == RTL)
 877                 dir = QChar::DirR;
 878         }
 879         else if (style()->direction() == RTL) {
 880             dir = QChar::DirR;
 881         }
 882     }
 883
 884     emptyRun = true;
 885
 886     numSpaces = 0;
 887
 888     bidi.current = start;
 889     bidi.last = bidi.current;
 890     bool atEnd = false;
 891
 892     while( 1 ) {
 893
 894         QChar::Direction dirCurrent;
 895         if (atEnd) {
 896             //kdDebug(6041) << "atEnd" << endl;
 897             BidiContext *c = bidi.context;
 898             if ( bidi.current.atEnd())
 899                 while ( c->parent )
 900                     c = c->parent;
 901             dirCurrent = c->dir;
 902         } else {
 903             dirCurrent = bidi.current.direction();
 904         }
 905
 906 #ifndef QT_NO_UNICODETABLES
 907
 908 #if BIDI_DEBUG > 1
 909         kdDebug(6041) << "directions: dir=" << (int)dir << " current=" << (int)dirCurrent << " last=" << status.last << " eor=" << status.eor << " lastStrong=" << status.lastStrong << " embedding=" << (int)context->dir << " level =" << (int)context->level << endl;
 910 #endif
 911
 912         switch(dirCurrent) {
 913
 914             // embedding and overrides (X1-X9 in the Bidi specs)
 915         case QChar::DirRLE:
 916         case QChar::DirLRE:
 917         case QChar::DirRLO:
 918         case QChar::DirLRO:
 919         case QChar::DirPDF:
 920             bidi.eor = bidi.last;
 921             embed( dirCurrent, bidi );
 922             break;
 923
 924             // strong types
 925         case QChar::DirL:
 926             if(dir == QChar::DirON)
 927                 dir = QChar::DirL;
 928             switch(bidi.status.last)
 929                 {
 930                 case QChar::DirL:
 931                     bidi.eor = bidi.current; bidi.status.eor = QChar::DirL; break;
 932                 case QChar::DirR:
 933                 case QChar::DirAL:
 934                 case QChar::DirEN:
 935                 case QChar::DirAN:
 936                     appendRun( bidi );
 937                     break;
 938                 case QChar::DirES:
 939                 case QChar::DirET:
 940                 case QChar::DirCS:
 941                 case QChar::DirBN:
 942                 case QChar::DirB:
 943                 case QChar::DirS:
 944                 case QChar::DirWS:
 945                 case QChar::DirON:
 946                     if(dir != QChar::DirL) {
 947                         //last stuff takes embedding dir
 948                         if( bidi.context->dir == QChar::DirR ) {
 949                             if(!(bidi.status.eor == QChar::DirR)) {
 950                                 // AN or EN
 951                                 appendRun( bidi );
 952                                 dir = QChar::DirR;
 953                             }
 954                             else
 955                                 bidi.eor = bidi.last;
 956                             appendRun( bidi );
 957                             dir = QChar::DirL;
 958                             bidi.status.eor = QChar::DirL;
 959                         } else {
 960                             if(bidi.status.eor == QChar::DirR) {
 961                                 appendRun( bidi );
 962                                 dir = QChar::DirL;
 963                             } else {
 964                                 bidi.eor = bidi.current; bidi.status.eor = QChar::DirL; break;
 965                             }
 966                         }
 967                     } else {
 968                         bidi.eor = bidi.current; bidi.status.eor = QChar::DirL;
 969                     }
 970                 default:
 971                     break;
 972                 }
 973             bidi.status.lastStrong = QChar::DirL;
 974             break;
 975         case QChar::DirAL:
 976         case QChar::DirR:
 977             if(dir == QChar::DirON) dir = QChar::DirR;
 978             switch(bidi.status.last)
 979                 {
 980                 case QChar::DirR:
 981                 case QChar::DirAL:
 982                     bidi.eor = bidi.current; bidi.status.eor = QChar::DirR; break;
 983                 case QChar::DirL:
 984                 case QChar::DirEN:
 985                 case QChar::DirAN:
 986                     appendRun( bidi );
 987                     dir = QChar::DirR;
 988                     bidi.eor = bidi.current;
 989                     bidi.status.eor = QChar::DirR;
 990                     break;
 991                 case QChar::DirES:
 992                 case QChar::DirET:
 993                 case QChar::DirCS:
 994                 case QChar::DirBN:
 995                 case QChar::DirB:
 996                 case QChar::DirS:
 997                 case QChar::DirWS:
 998                 case QChar::DirON:
 999                     if( !(bidi.status.eor == QChar::DirR) && !(bidi.status.eor == QChar::DirAL) ) {
1000                         //last stuff takes embedding dir
1001                         if(bidi.context->dir == QChar::DirR || bidi.status.lastStrong == QChar::DirR) {
1002                             appendRun( bidi );
1003                             dir = QChar::DirR;
1004                             bidi.eor = bidi.current;
1005                             bidi.status.eor = QChar::DirR;
1006                         } else {
1007                             bidi.eor = bidi.last;
1008                             appendRun( bidi );
1009                             dir = QChar::DirR;
1010                             bidi.status.eor = QChar::DirR;
1011                         }
1012                     } else {
1013                         bidi.eor = bidi.current; bidi.status.eor = QChar::DirR;
1014                     }
1015                 default:
1016                     break;
1017                 }
1018             bidi.status.lastStrong = dirCurrent;
1019             break;
1020
1021             // weak types:
1022
1023         case QChar::DirNSM:
1024             // ### if @sor, set dir to dirSor
1025             break;
1026         case QChar::DirEN:
1027             if(!(bidi.status.lastStrong == QChar::DirAL)) {
1028                 // if last strong was AL change EN to AN
1029                 if(dir == QChar::DirON) {
1030                     if(bidi.status.lastStrong == QChar::DirAL)
1031                         dir = QChar::DirAN;
1032                     else
1033                         dir = QChar::DirL;
1034                 }
1035                 switch(bidi.status.last)
1036                     {
1037                     case QChar::DirET:
1038                         if ( bidi.status.lastStrong == QChar::DirR || bidi.status.lastStrong == QChar::DirAL ) {
1039                             appendRun( bidi );
1040                             dir = QChar::DirEN;
1041                             bidi.status.eor = QChar::DirEN;
1042                         }
1043                         // fall through
1044                     case QChar::DirEN:
1045                     case QChar::DirL:
1046                         bidi.eor = bidi.current;
1047                         bidi.status.eor = dirCurrent;
1048                         break;
1049                     case QChar::DirR:
1050                     case QChar::DirAL:
1051                     case QChar::DirAN:
1052                         appendRun( bidi );
1053                         bidi.status.eor = QChar::DirEN;
1054                         dir = QChar::DirEN; break;
1055                     case QChar::DirES:
1056                     case QChar::DirCS:
1057                         if(bidi.status.eor == QChar::DirEN) {
1058                             bidi.eor = bidi.current; break;
1059                         }
1060                     case QChar::DirBN:
1061                     case QChar::DirB:
1062                     case QChar::DirS:
1063                     case QChar::DirWS:
1064                     case QChar::DirON:
1065                         if(bidi.status.eor == QChar::DirR) {
1066                             // neutrals go to R
1067                             bidi.eor = bidi.last;
1068                             appendRun( bidi );
1069                             dir = QChar::DirEN;
1070                             bidi.status.eor = QChar::DirEN;
1071                         }
1072                         else if( bidi.status.eor == QChar::DirL ||
1073                                  (bidi.status.eor == QChar::DirEN && bidi.status.lastStrong == QChar::DirL)) {
1074                             bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1075                         } else {
1076                             // numbers on both sides, neutrals get right to left direction
1077                             if(dir != QChar::DirL) {
1078                                 appendRun( bidi );
1079                                 bidi.eor = bidi.last;
1080                                 dir = QChar::DirR;
1081                                 appendRun( bidi );
1082                                 dir = QChar::DirEN;
1083                                 bidi.status.eor = QChar::DirEN;
1084                             } else {
1085                                 bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1086                             }
1087                         }
1088                     default:
1089                         break;
1090                     }
1091                 break;
1092             }
1093         case QChar::DirAN:
1094             dirCurrent = QChar::DirAN;
1095             if(dir == QChar::DirON) dir = QChar::DirAN;
1096             switch(bidi.status.last)
1097                 {
1098                 case QChar::DirL:
1099                 case QChar::DirAN:
1100                     bidi.eor = bidi.current; bidi.status.eor = QChar::DirAN; break;
1101                 case QChar::DirR:
1102                 case QChar::DirAL:
1103                 case QChar::DirEN:
1104                     appendRun( bidi );
1105                     dir = QChar::DirAN; bidi.status.eor = QChar::DirAN;
1106                     break;
1107                 case QChar::DirCS:
1108                     if(bidi.status.eor == QChar::DirAN) {
1109                         bidi.eor = bidi.current; bidi.status.eor = QChar::DirR; break;
1110                     }
1111                 case QChar::DirES:
1112                 case QChar::DirET:
1113                 case QChar::DirBN:
1114                 case QChar::DirB:
1115                 case QChar::DirS:
1116                 case QChar::DirWS:
1117                 case QChar::DirON:
1118                     if(bidi.status.eor == QChar::DirR) {
1119                         // neutrals go to R
1120                         bidi.eor = bidi.last;
1121                         appendRun( bidi );
1122                         dir = QChar::DirAN;
1123                         bidi.status.eor = QChar::DirAN;
1124                     } else if( bidi.status.eor == QChar::DirL ||
1125                                (bidi.status.eor == QChar::DirEN && bidi.status.lastStrong == QChar::DirL)) {
1126                         bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1127                     } else {
1128                         // numbers on both sides, neutrals get right to left direction
1129                         if(dir != QChar::DirL) {
1130                             appendRun( bidi );
1131                             bidi.eor = bidi.last;
1132                             dir = QChar::DirR;
1133                             appendRun( bidi );
1134                             dir = QChar::DirAN;
1135                             bidi.status.eor = QChar::DirAN;
1136                         } else {
1137                             bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1138                         }
1139                     }
1140                 default:
1141                     break;
1142                 }
1143             break;
1144         case QChar::DirES:
1145         case QChar::DirCS:
1146             break;
1147         case QChar::DirET:
1148             if(bidi.status.last == QChar::DirEN) {
1149                 dirCurrent = QChar::DirEN;
1150                 bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1151                 break;
1152             }
1153             break;
1154
1155         // boundary neutrals should be ignored
1156         case QChar::DirBN:
1157             break;
1158             // neutrals
1159         case QChar::DirB:
1160             // ### what do we do with newline and paragraph seperators that come to here?
1161             break;
1162         case QChar::DirS:
1163             // ### implement rule L1
1164             break;
1165         case QChar::DirWS:
1166             break;
1167         case QChar::DirON:
1168             break;
1169         default:
1170             break;
1171         }
1172
1173         //cout << "     after: dir=" << //        dir << " current=" << dirCurrent << " last=" << status.last << " eor=" << status.eor << " lastStrong=" << status.lastStrong << " embedding=" << context->dir << endl;
1174
1175         if(bidi.current.atEnd()) break;
1176
1177         // set status.last as needed.
1178         switch(dirCurrent)
1179             {
1180             case QChar::DirET:
1181             case QChar::DirES:
1182             case QChar::DirCS:
1183             case QChar::DirS:
1184             case QChar::DirWS:
1185             case QChar::DirON:
1186                 switch(bidi.status.last)
1187                     {
1188                     case QChar::DirL:
1189                     case QChar::DirR:
1190                     case QChar::DirAL:
1191                     case QChar::DirEN:
1192                     case QChar::DirAN:
1193                         bidi.status.last = dirCurrent;
1194                         break;
1195                     default:
1196                         bidi.status.last = QChar::DirON;
1197                     }
1198                 break;
1199             case QChar::DirNSM:
1200             case QChar::DirBN:
1201                 // ignore these
1202                 break;
1203             case QChar::DirEN:
1204                 if ( bidi.status.last == QChar::DirL ) {
1205                     bidi.status.last = QChar::DirL;
1206                     break;
1207                 }
1208                 // fall through
1209             default:
1210                 bidi.status.last = dirCurrent;
1211             }
1212 #endif
1213
1214         if ( atEnd ) break;
1215         bidi.last = bidi.current;
1216
1217         if ( emptyRun ) {
1218             bidi.sor = bidi.current;
1219             bidi.eor = bidi.current;
1220             emptyRun = false;
1221         }
1222
1223         // this causes the operator ++ to open and close embedding levels as needed
1224         // for the CSS unicode-bidi property
1225         adjustEmbedding = true;
1226         bidi.current.increment( bidi );
1227         adjustEmbedding = false;
1228
1229         if ( bidi.current == end ) {
1230             if ( emptyRun )
1231                 break;
1232             atEnd = true;
1233         }
1234     }
1235
1236 #if BIDI_DEBUG > 0
1237     kdDebug(6041) << "reached end of line current=" << current.obj << "/" << current.pos
1238                   << ", eor=" << eor.obj << "/" << eor.pos << endl;
1239 #endif
1240     if ( !emptyRun && bidi.sor != bidi.current ) {
1241             bidi.eor = bidi.last;
1242             appendRun( bidi );
1243     }
1244
1245     // reorder line according to run structure...
1246
1247     // first find highest and lowest levels
1248     uchar levelLow = 128;
1249     uchar levelHigh = 0;
1250     BidiRun *r = sFirstBidiRun;
1251     while ( r ) {
1252         if ( r->level > levelHigh )
1253             levelHigh = r->level;
1254         if ( r->level < levelLow )
1255             levelLow = r->level;
1256         r = r->nextRun;
1257     }
1258
1259     // implements reordering of the line (L2 according to Bidi spec):
1260     // L2. From the highest level found in the text to the lowest odd level on each line,
1261     // reverse any contiguous sequence of characters that are at that level or higher.
1262
1263     // reversing is only done up to the lowest odd level
1264     if( !(levelLow%2) ) levelLow++;
1265
1266 #if BIDI_DEBUG > 0
1267     kdDebug(6041) << "lineLow = " << (uint)levelLow << ", lineHigh = " << (uint)levelHigh << endl;
1268     kdDebug(6041) << "logical order is:" << endl;
1269     QPtrListIterator<BidiRun> it2(runs);
1270     BidiRun *r2;
1271     for ( ; (r2 = it2.current()); ++it2 )
1272         kdDebug(6041) << "    " << r2 << "  start=" << r2->start << "  stop=" << r2->stop << "  level=" << (uint)r2->level << endl;
1273 #endif
1274
1275     int count = sBidiRunCount - 1;
1276
1277     // do not reverse for visually ordered web sites
1278     if(!style()->visuallyOrdered()) {
1279         while(levelHigh >= levelLow) {
1280             int i = 0;
1281             BidiRun* currRun = sFirstBidiRun;
1282             while ( i < count ) {
1283                 while(i < count && currRun && currRun->level < levelHigh) {
1284                     i++;
1285                     currRun = currRun->nextRun;
1286                 }
1287                 int start = i;
1288                 while(i <= count && currRun && currRun->level >= levelHigh) {
1289                     i++;
1290                     currRun = currRun->nextRun;
1291                 }
1292                 int end = i-1;
1293                 reverseRuns(start, end);
1294                 i++;
1295                 if(i >= count) break;
1296             }
1297             levelHigh--;
1298         }
1299     }
1300
1301 #if BIDI_DEBUG > 0
1302     kdDebug(6041) << "visual order is:" << endl;
1303     for (BidiRun* curr = sFirstRun; curr; curr = curr->nextRun)
1304         kdDebug(6041) << "    " << curr << endl;
1305 #endif
1306 }
1307
1308 static void buildCompactRuns(RenderObject* compactObj, BidiState &bidi)
1309 {
1310     sBuildingCompactRuns = true;
1311     if (!compactObj->isRenderBlock()) {
1312         // Just append a run for our object.
1313         isLineEmpty = false;
1314         addRun(new (compactObj->renderArena()) BidiRun(0, compactObj->length(), compactObj, bidi.context, dir));
1315     }
1316     else {
1317         // Format the compact like it is its own single line.  We build up all the runs for
1318         // the little compact and then reorder them for bidi.
1319         RenderBlock* compactBlock = static_cast<RenderBlock*>(compactObj);
1320         adjustEmbedding = true;
1321         BidiIterator start(compactBlock, first(compactBlock, bidi), 0);
1322         adjustEmbedding = false;
1323         BidiIterator end = start;
1324
1325         betweenMidpoints = false;
1326         isLineEmpty = true;
1327         previousLineBrokeCleanly = true;
1328
1329         end = compactBlock->findNextLineBreak(start, bidi);
1330         if (!isLineEmpty)
1331             compactBlock->bidiReorderLine(start, end, bidi);
1332     }
1333
1334
1335     sCompactFirstBidiRun = sFirstBidiRun;
1336     sCompactLastBidiRun = sLastBidiRun;
1337     sCompactBidiRunCount = sBidiRunCount;
1338
1339     sNumMidpoints = 0;
1340     sCurrMidpoint = 0;
1341     betweenMidpoints = false;
1342     sBuildingCompactRuns = false;
1343 }
1344
1345 QRect RenderBlock::layoutInlineChildren(bool relayoutChildren)
1346 {
1347     BidiState bidi;
1348
1349     bool useRepaintRect = false;
1350     QRect repaintRect(0,0,0,0);
1351
1352     m_overflowHeight = 0;
1353
1354     invalidateVerticalPositions();
1355 #ifdef DEBUG_LAYOUT
1356     QTime qt;
1357     qt.start();
1358     kdDebug( 6040 ) << renderName() << " layoutInlineChildren( " << this <<" )" << endl;
1359 #endif
1360 #if BIDI_DEBUG > 1 || defined( DEBUG_LINEBREAKS )
1361     kdDebug(6041) << " ------- bidi start " << this << " -------" << endl;
1362 #endif
1363
1364     m_height = borderTop() + paddingTop();
1365     int toAdd = borderBottom() + paddingBottom();
1366     if (includeScrollbarSize())
1367         toAdd += m_layer->horizontalScrollbarHeight();
1368
1369     // Figure out if we should clear out our line boxes.
1370     // FIXME: Handle resize eventually!
1371     // FIXME: Do something better when floats are present.
1372     bool fullLayout = !firstLineBox() || !firstChild() || selfNeedsLayout() || relayoutChildren || containsFloats();
1373     if (fullLayout)
1374         deleteLineBoxes();
1375
1376     // Text truncation only kicks in if your overflow isn't visible and your text-overflow-mode isn't
1377     // clip.
1378     // FIXME: CSS3 says that descendants that are clipped must also know how to truncate.  This is insanely
1379     // difficult to figure out (especially in the middle of doing layout), and is really an esoteric pile of nonsense
1380     // anyway, so we won't worry about following the draft here.
1381     bool hasTextOverflow = style()->textOverflow() && hasOverflowClip();
1382
1383     // Walk all the lines and delete our ellipsis line boxes if they exist.
1384     if (hasTextOverflow)
1385          deleteEllipsisLineBoxes();
1386
1387     int oldLineBottom = lastRootBox() ? lastRootBox()->bottomOverflow() : m_height;
1388     int startLineBottom = 0;
1389
1390     if (firstChild()) {
1391         // layout replaced elements
1392         bool endOfInline = false;
1393         RenderObject *o = first(this, bidi, false);
1394         bool hasFloat = false;
1395         while (o) {
1396             if (o->isReplaced() || o->isFloating() || o->isPositioned()) {
1397                 if (relayoutChildren || o->style()->width().isPercent() || o->style()->height().isPercent())
1398                     o->setChildNeedsLayout(true, false);
1399                 if (o->isPositioned())
1400                     o->containingBlock()->insertPositionedObject(o);
1401                 else {
1402                     if (o->isFloating())
1403                         hasFloat = true;
1404                     else if (fullLayout || o->needsLayout()) // Replaced elements
1405                         o->dirtyLineBoxes(fullLayout);
1406                     o->layoutIfNeeded();
1407                 }
1408             }
1409             else if (o->isText() || (o->isInlineFlow() && !endOfInline)) {
1410                 if (fullLayout || o->selfNeedsLayout())
1411                     o->dirtyLineBoxes(fullLayout);
1412                 o->setNeedsLayout(false);
1413             }
1414             o = Bidinext( this, o, bidi, false, &endOfInline);
1415         }
1416
1417         if (hasFloat)
1418             fullLayout = true; // FIXME: Will need to find a way to optimize floats some day.
1419
1420         if (fullLayout && !selfNeedsLayout()) {
1421             setNeedsLayout(true, false);  // Mark ourselves as needing a full layout. This way we'll repaint like
1422                                           // we're supposed to.
1423             if (!document()->view()->needsFullRepaint() && m_layer) {
1424                 // Because we waited until we were already inside layout to discover
1425                 // that the block really needed a full layout, we missed our chance to repaint the layer
1426                 // before layout started.  Luckily the layer has cached the repaint rect for its original
1427                 // position and size, and so we can use that to make a repaint happen now.
1428                 RenderCanvas* c = canvas();
1429                 if (c && !c->printingMode())
1430                     c->repaintViewRectangle(m_layer->repaintRect());
1431             }
1432         }
1433
1434         BidiContext *startEmbed;
1435         if( style()->direction() == LTR ) {
1436             startEmbed = new BidiContext( 0, QChar::DirL );
1437             bidi.status.eor = QChar::DirL;
1438         } else {
1439             startEmbed = new BidiContext( 1, QChar::DirR );
1440             bidi.status.eor = QChar::DirR;
1441         }
1442         startEmbed->ref();
1443
1444         bidi.status.lastStrong = QChar::DirON;
1445         bidi.status.last = QChar::DirON;
1446         bidi.context = startEmbed;
1447
1448         if (!smidpoints)
1449             smidpoints = new QMemArray<BidiIterator>;
1450
1451         sNumMidpoints = 0;
1452         sCurrMidpoint = 0;
1453         sCompactFirstBidiRun = sCompactLastBidiRun = 0;
1454         sCompactBidiRunCount = 0;
1455
1456         // We want to skip ahead to the first dirty line
1457         BidiIterator start;
1458         RootInlineBox* startLine = determineStartPosition(fullLayout, start, bidi);
1459
1460         // We also find the first clean line and extract these lines.  We will add them back
1461         // if we determine that we're able to synchronize after handling all our dirty lines.
1462         BidiIterator cleanLineStart;
1463         int endLineYPos;
1464         RootInlineBox* endLine = (fullLayout || !startLine) ?
1465                                  0 : determineEndPosition(startLine, cleanLineStart, endLineYPos);
1466         if (startLine) {
1467             useRepaintRect = true;
1468             startLineBottom = startLine->bottomOverflow();
1469             repaintRect.setY(kMin(m_height, startLine->topOverflow()));
1470             RenderArena* arena = renderArena();
1471             RootInlineBox* box = startLine;
1472             while (box) {
1473                 RootInlineBox* next = box->nextRootBox();
1474                 box->deleteLine(arena);
1475                 box = next;
1476             }
1477             startLine = 0;
1478         }
1479
1480         BidiIterator end = start;
1481
1482         bool endLineMatched = false;
1483         while (!end.atEnd()) {
1484             start = end;
1485             if (endLine && (endLineMatched = matchedEndLine(start, cleanLineStart, endLine, endLineYPos)))
1486                 break;
1487
1488             betweenMidpoints = false;
1489             isLineEmpty = true;
1490             if (m_firstLine && firstChild() && firstChild()->isCompact() && firstChild()->isRenderBlock()) {
1491                 buildCompactRuns(firstChild(), bidi);
1492                 start.obj = firstChild()->nextSibling();
1493                 end = start;
1494             }
1495             end = findNextLineBreak(start, bidi);
1496             if( start.atEnd() ) break;
1497             if (!isLineEmpty) {
1498                 bidiReorderLine(start, end, bidi);
1499
1500                 // Now that the runs have been ordered, we create the line boxes.
1501                 // At the same time we figure out where border/padding/margin should be applied for
1502                 // inline flow boxes.
1503                 if (sCompactFirstBidiRun) {
1504                     // We have a compact line sharing this line.  Link the compact runs
1505                     // to our runs to create a single line of runs.
1506                     sCompactLastBidiRun->nextRun = sFirstBidiRun;
1507                     sFirstBidiRun = sCompactFirstBidiRun;
1508                     sBidiRunCount += sCompactBidiRunCount;
1509                 }
1510
1511                 RootInlineBox* lineBox = 0;
1512                 if (sBidiRunCount) {
1513                     lineBox = constructLine(start, end);
1514                     if (lineBox) {
1515                         lineBox->setEndsWithBreak(previousLineBrokeCleanly);
1516
1517                         // Now we position all of our text runs horizontally.
1518                         computeHorizontalPositionsForLine(lineBox, bidi);
1519
1520                         // Now position our text runs vertically.
1521                         computeVerticalPositionsForLine(lineBox);
1522
1523                         deleteBidiRuns(renderArena());
1524                     }
1525                 }
1526
1527                 if (end == start || (!previousLineBrokeCleanly && end.obj && end.obj->style()->whiteSpace() == PRE && end.current() == QChar('\n'))) {
1528                     adjustEmbedding = true;
1529                     end.increment(bidi);
1530                     adjustEmbedding = false;
1531                 }
1532
1533                 if (lineBox)
1534                     lineBox->setLineBreakInfo(end.obj, end.pos);
1535
1536                 m_firstLine = false;
1537                 newLine();
1538             }
1539
1540             sNumMidpoints = 0;
1541             sCurrMidpoint = 0;
1542             sCompactFirstBidiRun = sCompactLastBidiRun = 0;
1543             sCompactBidiRunCount = 0;
1544         }
1545         startEmbed->deref();
1546         //embed->deref();
1547
1548         if (endLine) {
1549             if (endLineMatched) {
1550                 // Note our current y-position for correct repainting when no lines move.  If no lines move, we still have to
1551                 // repaint up to the maximum of the bottom overflow of the old start line or the bottom overflow of the new last line.
1552                 int currYPos = kMax(startLineBottom, m_height);
1553                 if (lastRootBox())
1554                     currYPos = kMax(currYPos, lastRootBox()->bottomOverflow());
1555
1556                 // Attach all the remaining lines, and then adjust their y-positions as needed.
1557                 for (RootInlineBox* line = endLine; line; line = line->nextRootBox())
1558                     line->attachLine();
1559
1560                 // Now apply the offset to each line if needed.
1561                 int delta = m_height - endLineYPos;
1562                 if (delta)
1563                     for (RootInlineBox* line = endLine; line; line = line->nextRootBox())
1564                         line->adjustPosition(0, delta);
1565                 m_height = lastRootBox()->blockHeight();
1566                 m_overflowHeight = kMax(m_height, m_overflowHeight);
1567                 int bottomOfLine = lastRootBox()->bottomOverflow();
1568                 if (bottomOfLine > m_height && bottomOfLine > m_overflowHeight)
1569                     m_overflowHeight = bottomOfLine;
1570                 if (delta)
1571                     repaintRect.setHeight(kMax(m_overflowHeight-delta, m_overflowHeight) - repaintRect.y());
1572                 else
1573                     repaintRect.setHeight(currYPos - repaintRect.y());
1574             }
1575             else {
1576                 // Delete all the remaining lines.
1577                 m_overflowHeight = kMax(m_height, m_overflowHeight);
1578                 InlineRunBox* line = endLine;
1579                 RenderArena* arena = renderArena();
1580                 while (line) {
1581                     InlineRunBox* next = line->nextLineBox();
1582                     if (!next)
1583                         repaintRect.setHeight(kMax(m_overflowHeight, line->bottomOverflow()) - repaintRect.y());
1584                     line->deleteLine(arena);
1585                     line = next;
1586                 }
1587             }
1588         }
1589     }
1590
1591     sNumMidpoints = 0;
1592     sCurrMidpoint = 0;
1593
1594     // in case we have a float on the last line, it might not be positioned up to now.
1595     // This has to be done before adding in the bottom border/padding, or the float will
1596     // include the padding incorrectly. -dwh
1597     positionNewFloats();
1598
1599     // Now add in the bottom border/padding.
1600     m_height += toAdd;
1601
1602     // Always make sure this is at least our height.
1603     m_overflowHeight = kMax(m_height, m_overflowHeight);
1604
1605     // See if any lines spill out of the block.  If so, we need to update our overflow width.
1606     checkLinesForOverflow();
1607
1608     if (useRepaintRect) {
1609         repaintRect.setWidth(kMax((int)m_width, m_overflowWidth));
1610         if (repaintRect.height() == 0)
1611             repaintRect.setHeight(kMax(oldLineBottom, m_overflowHeight) - repaintRect.y());
1612     }
1613
1614     if (!firstLineBox() && element() && element()->isContentEditable() && element()->rootEditableElement() == element())
1615         m_height += lineHeight(true);
1616
1617     // See if we have any lines that spill out of our block.  If we do, then we will possibly need to
1618     // truncate text.
1619     if (hasTextOverflow)
1620         checkLinesForTextOverflow();
1621
1622     return repaintRect;
1623
1624 #if BIDI_DEBUG > 1
1625     kdDebug(6041) << " ------- bidi end " << this << " -------" << endl;
1626 #endif
1627     //kdDebug() << "RenderBlock::layoutInlineChildren time used " << qt.elapsed() << endl;
1628     //kdDebug(6040) << "height = " << m_height <<endl;
1629 }
1630
1631 RootInlineBox* RenderBlock::determineStartPosition(bool fullLayout, BidiIterator& start, BidiState& bidi)
1632 {
1633     RootInlineBox* curr = 0;
1634     RootInlineBox* last = 0;
1635     RenderObject* startObj = 0;
1636     int pos = 0;
1637
1638     if (fullLayout) {
1639         // Nuke all our lines.
1640         if (firstRootBox()) {
1641             RenderArena* arena = renderArena();
1642             curr = firstRootBox();
1643             while (curr) {
1644                 RootInlineBox* next = curr->nextRootBox();
1645                 curr->deleteLine(arena);
1646                 curr = next;
1647             }
1648             KHTMLAssert(!m_firstLineBox && !m_lastLineBox);
1649         }
1650     }
1651     else {
1652         for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox());
1653         if (curr) {
1654             // We have a dirty line.
1655             if (curr->prevRootBox()) {
1656                 // We have a previous line.
1657                 if (!curr->prevRootBox()->endsWithBreak())
1658                     curr = curr->prevRootBox();  // The previous line didn't break cleanly, so treat it as dirty also.
1659             }
1660         }
1661         else {
1662             // No dirty lines were found.
1663             // If the last line didn't break cleanly, treat it as dirty.
1664             if (lastRootBox() && !lastRootBox()->endsWithBreak())
1665                 curr = lastRootBox();
1666         }
1667
1668         // If we have no dirty lines, then last is just the last root box.
1669         last = curr ? curr->prevRootBox() : lastRootBox();
1670     }
1671
1672     m_firstLine = !last;
1673     previousLineBrokeCleanly = !last || last->endsWithBreak();
1674     if (last) {
1675         m_height = last->blockHeight();
1676         int bottomOfLine = last->bottomOverflow();
1677         if (bottomOfLine > m_height && bottomOfLine > m_overflowHeight)
1678             m_overflowHeight = bottomOfLine;
1679         startObj = last->lineBreakObj();
1680         pos = last->lineBreakPos();
1681     }
1682     else
1683         startObj = first(this, bidi, 0);
1684
1685     adjustEmbedding = true;
1686     start = BidiIterator(this, startObj, pos);
1687
1688     adjustEmbedding = false;
1689
1690     return curr;
1691 }
1692
1693 RootInlineBox* RenderBlock::determineEndPosition(RootInlineBox* startLine, BidiIterator& cleanLineStart,
1694                                                  int& yPos)
1695 {
1696     RootInlineBox* last = 0;
1697     if (!startLine)
1698         last = 0;
1699     else {
1700         for (RootInlineBox* curr = startLine->nextRootBox(); curr; curr = curr->nextRootBox()) {
1701             if (curr->isDirty())
1702                 last = 0;
1703             else if (!last)
1704                 last = curr;
1705         }
1706     }
1707
1708     if (!last)
1709         return 0;
1710
1711     cleanLineStart = BidiIterator(this, last->prevRootBox()->lineBreakObj(), last->prevRootBox()->lineBreakPos());
1712     yPos = last->prevRootBox()->blockHeight();
1713
1714     for (RootInlineBox* line = last; line; line = line->nextRootBox())
1715         line->extractLine(); // Disconnect all line boxes from their render objects while preserving
1716                              // their connections to one another.
1717
1718     return last;
1719 }
1720
1721 bool RenderBlock::matchedEndLine(const BidiIterator& start, const BidiIterator& endLineStart,
1722                                  RootInlineBox*& endLine, int& endYPos)
1723 {
1724     if (start == endLineStart)
1725         return true; // The common case. All the data we already have is correct.
1726     else {
1727         // The first clean line doesn't match, but we can check a handful of following lines to try
1728         // to match back up.
1729         static int numLines = 8; // The # of lines we're willing to match against.
1730         RootInlineBox* line = endLine;
1731         for (int i = 0; i < numLines && line; i++, line = line->nextRootBox()) {
1732             if (line->lineBreakObj() == start.obj && line->lineBreakPos() == start.pos) {
1733                 // We have a match.
1734                 RootInlineBox* result = line->nextRootBox();
1735
1736                 // Set our yPos to be the block height of endLine.
1737                 if (result)
1738                     endYPos = line->blockHeight();
1739
1740                 // Now delete the lines that we failed to sync.
1741                 RootInlineBox* boxToDelete = endLine;
1742                 RenderArena* arena = renderArena();
1743                 while (boxToDelete && boxToDelete != result) {
1744                     RootInlineBox* next = boxToDelete->nextRootBox();
1745                     boxToDelete->deleteLine(arena);
1746                     boxToDelete = next;
1747                 }
1748
1749                 endLine = result;
1750                 return result;
1751             }
1752         }
1753     }
1754     return false;
1755 }
1756
1757 static const ushort nonBreakingSpace = 0xa0;
1758
1759 inline bool RenderBlock::skipNonBreakingSpace(BidiIterator &it)
1760 {
1761     if (it.obj->style()->nbspMode() != SPACE || it.current().unicode() != nonBreakingSpace)
1762         return false;
1763
1764     // Do not skip a non-breaking space if it is the first character
1765     // on the first line of a block.
1766     if (m_firstLine && isLineEmpty)
1767         return false;
1768
1769     // Do not skip a non-breaking space if it is the first character
1770     // on a line after a clean line break.
1771     if (!m_firstLine && isLineEmpty && previousLineBrokeCleanly)
1772         return false;
1773
1774     return true;
1775 }
1776
1777 int RenderBlock::skipWhitespace(BidiIterator &it, BidiState &bidi)
1778 {
1779     // FIXME: The entire concept of the skipWhitespace function is flawed, since we really need to be building
1780     // line boxes even for containers that may ultimately collapse away.  Otherwise we'll never get positioned
1781     // elements quite right.  In other words, we need to build this function's work into the normal line
1782     // object iteration process.
1783     int w = lineWidth(m_height);
1784     while (!it.atEnd() && (it.obj->isInlineFlow() || (it.obj->style()->whiteSpace() != PRE && !it.obj->isBR() &&
1785           (it.current() == ' ' || it.current() == '\n' ||
1786            skipNonBreakingSpace(it) || it.obj->isFloatingOrPositioned())))) {
1787         if (it.obj->isFloatingOrPositioned()) {
1788             RenderObject *o = it.obj;
1789             // add to special objects...
1790             if (o->isFloating()) {
1791                 insertFloatingObject(o);
1792                 positionNewFloats();
1793                 w = lineWidth(m_height);
1794             }
1795             else if (o->isPositioned()) {
1796                 // FIXME: The math here is actually not really right.  It's a best-guess approximation that
1797                 // will work for the common cases
1798                 RenderObject* c = o->container();
1799                 if (c->isInlineFlow()) {
1800                     // A relative positioned inline encloses us.  In this case, we also have to determine our
1801                     // position as though we were an inline.  Set |staticX| and |staticY| on the relative positioned
1802                     // inline so that we can obtain the value later.
1803                     c->setStaticX(style()->direction() == LTR ?
1804                                   leftOffset(m_height) : rightOffset(m_height));
1805                     c->setStaticY(m_height);
1806                 }
1807
1808                 if (o->hasStaticX()) {
1809                     bool wasInline = o->style()->isOriginalDisplayInlineType();
1810                     if (wasInline)
1811                         o->setStaticX(style()->direction() == LTR ?
1812                                       leftOffset(m_height) :
1813                                       width() - rightOffset(m_height));
1814                     else
1815                         o->setStaticX(style()->direction() == LTR ?
1816                                       borderLeft() + paddingLeft() :
1817                                       borderRight() + paddingRight());
1818                 }
1819                 if (o->hasStaticY())
1820                     o->setStaticY(m_height);
1821             }
1822         }
1823
1824         adjustEmbedding = true;
1825         it.increment(bidi);
1826         adjustEmbedding = false;
1827     }
1828     return w;
1829 }
1830
1831 BidiIterator RenderBlock::findNextLineBreak(BidiIterator &start, BidiState &bidi)
1832 {
1833     int width = lineWidth(m_height);
1834     int w = 0;
1835     int tmpW = 0;
1836 #ifdef DEBUG_LINEBREAKS
1837     kdDebug(6041) << "findNextLineBreak: line at " << m_height << " line width " << width << endl;
1838     kdDebug(6041) << "sol: " << start.obj << " " << start.pos << endl;
1839 #endif
1840
1841     // eliminate spaces at beginning of line
1842     width = skipWhitespace(start, bidi);
1843     if (start.atEnd())
1844         return start;
1845
1846     // This variable is used only if whitespace isn't set to PRE, and it tells us whether
1847     // or not we are currently ignoring whitespace.
1848     bool ignoringSpaces = false;
1849     BidiIterator ignoreStart;
1850
1851     // This variable tracks whether the very last character we saw was a space.  We use
1852     // this to detect when we encounter a second space so we know we have to terminate
1853     // a run.
1854     bool currentCharacterIsSpace = false;
1855     bool currentCharacterIsWS = false;
1856     RenderObject* trailingSpaceObject = 0;
1857
1858     BidiIterator lBreak = start;
1859
1860     RenderObject *o = start.obj;
1861     RenderObject *last = o;
1862     int pos = start.pos;
1863
1864     bool prevLineBrokeCleanly = previousLineBrokeCleanly;
1865     previousLineBrokeCleanly = false;
1866
1867     while( o ) {
1868 #ifdef DEBUG_LINEBREAKS
1869         kdDebug(6041) << "new object "<< o <<" width = " << w <<" tmpw = " << tmpW << endl;
1870 #endif
1871         if(o->isBR()) {
1872             if (w + tmpW <= width) {
1873                 lBreak.obj = o;
1874                 lBreak.pos = 0;
1875                 lBreak.increment(bidi);
1876
1877                 // A <br> always breaks a line, so don't let the line be collapsed
1878                 // away. Also, the space at the end of a line with a <br> does not
1879                 // get collapsed away.  It only does this if the previous line broke
1880                 // cleanly.  Otherwise the <br> has no effect on whether the line is
1881                 // empty or not.
1882                 if (prevLineBrokeCleanly)
1883                     isLineEmpty = false;
1884                 trailingSpaceObject = 0;
1885                 previousLineBrokeCleanly = true;
1886
1887                 if (!isLineEmpty) {
1888                     // only check the clear status for non-empty lines.
1889                     EClear clear = o->style()->clear();
1890                     if(clear != CNONE)
1891                         m_clearStatus = (EClear) (m_clearStatus | clear);
1892                 }
1893             }
1894             goto end;
1895         }
1896         if( o->isFloatingOrPositioned() ) {
1897             // add to special objects...
1898             if(o->isFloating()) {
1899                 insertFloatingObject(o);
1900                 // check if it fits in the current line.
1901                 // If it does, position it now, otherwise, position
1902                 // it after moving to next line (in newLine() func)
1903                 if (o->width()+o->marginLeft()+o->marginRight()+w+tmpW <= width) {
1904                     positionNewFloats();
1905                     width = lineWidth(m_height);
1906                 }
1907             }
1908             else if (o->isPositioned()) {
1909                 // If our original display wasn't an inline type, then we can
1910                 // go ahead and determine our static x position now.
1911                 bool isInlineType = o->style()->isOriginalDisplayInlineType();
1912                 bool needToSetStaticX = o->hasStaticX();
1913                 if (o->hasStaticX() && !isInlineType) {
1914                     o->setStaticX(o->parent()->style()->direction() == LTR ?
1915                                   borderLeft()+paddingLeft() :
1916                                   borderRight()+paddingRight());
1917                     needToSetStaticX = false;
1918                 }
1919
1920                 // If our original display was an INLINE type, then we can go ahead
1921                 // and determine our static y position now.
1922                 bool needToSetStaticY = o->hasStaticY();
1923                 if (o->hasStaticY() && isInlineType) {
1924                     o->setStaticY(m_height);
1925                     needToSetStaticY = false;
1926                 }
1927
1928                 bool needToCreateLineBox = needToSetStaticX || needToSetStaticY;
1929                 RenderObject* c = o->container();
1930                 if (c->isInlineFlow() && (!needToSetStaticX || !needToSetStaticY))
1931                     needToCreateLineBox = true;
1932
1933                 // If we're ignoring spaces, we have to stop and include this object and
1934                 // then start ignoring spaces again.
1935                 if (needToCreateLineBox) {
1936                     trailingSpaceObject = 0;
1937                     ignoreStart.obj = o;
1938                     ignoreStart.pos = 0;
1939                     if (ignoringSpaces) {
1940                         addMidpoint(ignoreStart); // Stop ignoring spaces.
1941                         addMidpoint(ignoreStart); // Start ignoring again.
1942                     }
1943
1944                 }
1945             }
1946         } else if (o->isInlineFlow()) {
1947             // Only empty inlines matter.  We treat those similarly to replaced elements.
1948             KHTMLAssert(!o->firstChild());
1949             tmpW += o->marginLeft()+o->borderLeft()+o->paddingLeft()+
1950                     o->marginRight()+o->borderRight()+o->paddingRight();
1951         } else if ( o->isReplaced() ) {
1952             EWhiteSpace currWS = o->style()->whiteSpace();
1953             EWhiteSpace lastWS = last->style()->whiteSpace();
1954
1955             // WinIE marquees have different whitespace characteristics by default when viewed from
1956             // the outside vs. the inside.  Text inside is NOWRAP, and so we altered the marquee's
1957             // style to reflect this, but we now have to get back to the original whitespace value
1958             // for the marquee when checking for line breaking.
1959             if (o->isHTMLMarquee() && o->layer() && o->layer()->marquee())
1960                 currWS = o->layer()->marquee()->whiteSpace();
1961             if (last->isHTMLMarquee() && last->layer() && last->layer()->marquee())
1962                 lastWS = last->layer()->marquee()->whiteSpace();
1963
1964             // Break on replaced elements if either has normal white-space.
1965             // FIXME: This does not match WinIE, Opera, and Mozilla.  They treat replaced elements
1966             // like characters in a word, and require spaces between the replaced elements in order
1967             // to break.
1968             if (currWS == NORMAL || lastWS == NORMAL) {
1969                 w += tmpW;
1970                 tmpW = 0;
1971                 lBreak.obj = o;
1972                 lBreak.pos = 0;
1973             }
1974
1975             tmpW += o->width()+o->marginLeft()+o->marginRight()+inlineWidth(o);
1976             if (ignoringSpaces) {
1977                 BidiIterator startMid( 0, o, 0 );
1978                 addMidpoint(startMid);
1979             }
1980             isLineEmpty = false;
1981             ignoringSpaces = false;
1982             currentCharacterIsSpace = false;
1983             currentCharacterIsWS = false;
1984             trailingSpaceObject = 0;
1985
1986             if (o->isListMarker() && o->style()->listStylePosition() == OUTSIDE) {
1987                 // The marker must not have an effect on whitespace at the start
1988                 // of the line.  We start ignoring spaces to make sure that any additional
1989                 // spaces we see will be discarded.
1990                 //
1991                 // Optimize for a common case. If we can't find whitespace after the list
1992                 // item, then this is all moot. -dwh
1993                 RenderObject* next = Bidinext( start.par, o, bidi );
1994                 if (!m_pre && next && next->isText() && static_cast<RenderText*>(next)->stringLength() > 0) {
1995                     if (static_cast<RenderText*>(next)->text()[0].unicode() == nonBreakingSpace &&
1996                         o->style()->whiteSpace() == NORMAL && o->style()->nbspMode() == SPACE) {
1997                         currentCharacterIsWS = true;
1998                     }
1999                     if (static_cast<RenderText*>(next)->text()[0].unicode() == ' ' ||
2000                         static_cast<RenderText*>(next)->text()[0] == '\n') {
2001                         currentCharacterIsSpace = true;
2002                         currentCharacterIsWS = true;
2003                         ignoringSpaces = true;
2004                         BidiIterator endMid( 0, o, 0 );
2005                         addMidpoint(endMid);
2006                     }
2007                 }
2008             }
2009         } else if ( o->isText() ) {
2010             RenderText *t = static_cast<RenderText *>(o);
2011             int strlen = t->stringLength();
2012             int len = strlen - pos;
2013             QChar *str = t->text();
2014
2015             const Font *f = t->htmlFont( m_firstLine );
2016             // proportional font, needs a bit more work.
2017             int lastSpace = pos;
2018             bool isPre = o->style()->whiteSpace() == PRE;
2019             int wordSpacing = o->style()->wordSpacing();
2020
2021             bool appliedStartWidth = pos > 0; // If the span originated on a previous line,
2022                                               // then assume the start width has been applied.
2023             bool appliedEndWidth = false;
2024
2025             int wrapW = tmpW;
2026
2027             while(len) {
2028                 bool previousCharacterIsSpace = currentCharacterIsSpace;
2029                 bool previousCharacterIsWS = currentCharacterIsWS;
2030                 const QChar c = str[pos];
2031                 currentCharacterIsSpace = c == ' ' || (!isPre && c == '\n');
2032
2033                 if (isPre || !currentCharacterIsSpace)
2034                     isLineEmpty = false;
2035
2036                 // Check for soft hyphens.  Go ahead and ignore them.
2037                 if (c.unicode() == SOFT_HYPHEN && pos > 0) {
2038                     if (!ignoringSpaces) {
2039                         // Ignore soft hyphens
2040                         BidiIterator endMid(0, o, pos-1);
2041                         addMidpoint(endMid);
2042
2043                         // Add the width up to but not including the hyphen.
2044                         tmpW += t->width(lastSpace, pos - lastSpace, f);
2045
2046                         // For whitespace normal only, include the hyphen.  We need to ensure it will fit
2047                         // on the line if it shows when we break.
2048                         if (o->style()->whiteSpace() == NORMAL)
2049                             tmpW += t->width(pos, 1, f);
2050
2051                         BidiIterator startMid(0, o, pos+1);
2052                         addMidpoint(startMid);
2053                     }
2054
2055                     pos++;
2056                     len--;
2057                     lastSpace = pos; // Cheesy hack to prevent adding in widths of the run twice.
2058                     continue;
2059                 }
2060
2061                 bool applyWordSpacing = false;
2062                 bool isNormal = o->style()->whiteSpace() == NORMAL;
2063                 bool breakNBSP = isNormal && o->style()->nbspMode() == SPACE;
2064                 bool breakWords = w == 0 && isNormal && o->style()->wordWrap() == BREAK_WORD;
2065
2066                 currentCharacterIsWS = currentCharacterIsSpace || (breakNBSP && c.unicode() == nonBreakingSpace);
2067
2068                 if (breakWords)
2069                     wrapW += t->width(pos, 1, f);
2070                 if ((isPre && c == '\n') || (!isPre && isBreakable(str, pos, strlen, breakNBSP)) || (breakWords && wrapW > width)) {
2071                     if (ignoringSpaces) {
2072                         if (!currentCharacterIsSpace) {
2073                             // Stop ignoring spaces and begin at this
2074                             // new point.
2075                             ignoringSpaces = false;
2076                             lastSpace = pos; // e.g., "Foo    goo", don't add in any of the ignored spaces.
2077                             BidiIterator startMid ( 0, o, pos );
2078                             addMidpoint(startMid);
2079                         } else {
2080                             // Just keep ignoring these spaces.
2081                             pos++;
2082                             len--;
2083                             continue;
2084                         }
2085                     }
2086
2087                     tmpW += t->width(lastSpace, pos - lastSpace, f);
2088                     if (!appliedStartWidth) {
2089                         tmpW += inlineWidth(o, true, false);
2090                         appliedStartWidth = true;
2091                     }
2092
2093                     applyWordSpacing = (wordSpacing && currentCharacterIsSpace && !previousCharacterIsSpace &&
2094                         !t->containsOnlyWhitespace(pos+1, strlen-(pos+1)));
2095
2096 #ifdef DEBUG_LINEBREAKS
2097                     kdDebug(6041) << "found space at " << pos << " in string '" << QString( str, strlen ).latin1() << "' adding " << tmpW << " new width = " << w << endl;
2098 #endif
2099                     if ( !isPre && w + tmpW > width && w == 0 ) {
2100                         int fb = nearestFloatBottom(m_height);
2101                         int newLineWidth = lineWidth(fb);
2102                         // See if |tmpW| will fit on the new line.  As long as it does not,
2103                         // keep adjusting our float bottom until we find some room.
2104                         int lastFloatBottom = m_height;
2105                         while (lastFloatBottom < fb && tmpW > newLineWidth) {
2106                             lastFloatBottom = fb;
2107                             fb = nearestFloatBottom(fb);
2108                             newLineWidth = lineWidth(fb);
2109                         }
2110
2111                         if(!w && m_height < fb && width < newLineWidth) {
2112                             m_height = fb;
2113                             width = newLineWidth;
2114 #ifdef DEBUG_LINEBREAKS
2115                             kdDebug() << "RenderBlock::findNextLineBreak new position at " << m_height << " newWidth " << width << endl;
2116 #endif
2117                         }
2118                     }
2119
2120                     if (o->style()->whiteSpace() == NORMAL) {
2121                         // In AFTER_WHITE_SPACE mode, consider the current character
2122                         // as candidate width for this line.
2123                         int charWidth = o->style()->khtmlLineBreak() == AFTER_WHITE_SPACE ? t->width(pos, 1, f) : 0;
2124                         if (w + tmpW + charWidth > width) {
2125                             if (o->style()->khtmlLineBreak() == AFTER_WHITE_SPACE) {
2126                                 // Check if line is too big even without the extra space
2127                                 // at the end of the line. If it is not, do nothing.
2128                                 // If the line needs the extra whitespace to be too long,
2129                                 // then move the line break to the space and skip all
2130                                 // additional whitespace.
2131                                 if (w + tmpW < width) {
2132                                     lBreak.obj = o;
2133                                     lBreak.pos = pos;
2134                                     skipWhitespace(lBreak, bidi);
2135                                 }
2136                             }
2137                             goto end; // Didn't fit. Jump to the end.
2138                         }
2139                         else if (pos > 1 && str[pos-1].unicode() == SOFT_HYPHEN)
2140                             // Subtract the width of the soft hyphen out since we fit on a line.
2141                             tmpW -= t->width(pos-1, 1, f);
2142                     }
2143
2144                     if( *(str+pos) == '\n' && isPre) {
2145                         lBreak.obj = o;
2146                         lBreak.pos = pos;
2147
2148 #ifdef DEBUG_LINEBREAKS
2149                         kdDebug(6041) << "forced break sol: " << start.obj << " " << start.pos << "   end: " << lBreak.obj << " " << lBreak.pos << "   width=" << w << endl;
2150 #endif
2151                         return lBreak;
2152                     }
2153
2154                     if (o->style()->whiteSpace() == NORMAL) {
2155                         w += tmpW;
2156                         tmpW = 0;
2157                         lBreak.obj = o;
2158                         lBreak.pos = pos;
2159                     }
2160
2161                     lastSpace = pos;
2162
2163                     if (applyWordSpacing)
2164                         w += wordSpacing;
2165
2166                     if (!ignoringSpaces && !isPre) {
2167                         // If we encounter a newline, or if we encounter a
2168                         // second space, we need to go ahead and break up this
2169                         // run and enter a mode where we start collapsing spaces.
2170                         if (currentCharacterIsSpace && previousCharacterIsSpace) {
2171                             ignoringSpaces = true;
2172
2173                             // We just entered a mode where we are ignoring
2174                             // spaces. Create a midpoint to terminate the run
2175                             // before the second space.
2176                             addMidpoint(ignoreStart);
2177                             lastSpace = pos;
2178                         }
2179                     }
2180                 }
2181                 else if (ignoringSpaces) {
2182                     // Stop ignoring spaces and begin at this
2183                     // new point.
2184                     ignoringSpaces = false;
2185                     lastSpace = pos; // e.g., "Foo    goo", don't add in any of the ignored spaces.
2186                     BidiIterator startMid ( 0, o, pos );
2187                     addMidpoint(startMid);
2188                 }
2189
2190                 if (currentCharacterIsSpace && !previousCharacterIsSpace) {
2191                     ignoreStart.obj = o;
2192                     ignoreStart.pos = pos;
2193                 }
2194
2195                 if (!currentCharacterIsWS && previousCharacterIsWS) {
2196                     if (o->style()->khtmlLineBreak() == AFTER_WHITE_SPACE && o->style()->whiteSpace() == NORMAL) {
2197                         lBreak.obj = o;
2198                         lBreak.pos = pos;
2199                     }
2200                 }
2201
2202                 if (!isPre && currentCharacterIsSpace && !ignoringSpaces)
2203                     trailingSpaceObject = o;
2204                 else if (isPre || !currentCharacterIsSpace)
2205                     trailingSpaceObject = 0;
2206
2207                 pos++;
2208                 len--;
2209             }
2210
2211             // IMPORTANT: pos is > length here!
2212             if (!ignoringSpaces)
2213                 tmpW += t->width(lastSpace, pos - lastSpace, f);
2214             if (!appliedStartWidth)
2215                 tmpW += inlineWidth(o, true, false);
2216             if (!appliedEndWidth)
2217                 tmpW += inlineWidth(o, false, true);
2218         } else
2219             KHTMLAssert( false );
2220
2221         RenderObject* next = Bidinext(start.par, o, bidi);
2222         bool isNormal = o->style()->whiteSpace() == NORMAL;
2223         bool checkForBreak = isNormal;
2224         if (w && w + tmpW > width+1 && lBreak.obj && o->style()->whiteSpace() == NOWRAP)
2225             checkForBreak = true;
2226         else if (next && o->isText() && next->isText() && !next->isBR()) {
2227             if (isNormal || (next->style()->whiteSpace() == NORMAL)) {
2228                 if (currentCharacterIsSpace)
2229                     checkForBreak = true;
2230                 else {
2231                     RenderText* nextText = static_cast<RenderText*>(next);
2232                     int strlen = nextText->stringLength();
2233                     QChar *str = nextText->text();
2234                     if (strlen &&
2235                         ((str[0].unicode() == ' ') ||
2236                             (next->style()->whiteSpace() != PRE && str[0] == '\n')))
2237                         // If the next item on the line is text, and if we did not end with
2238                         // a space, then the next text run continues our word (and so it needs to
2239                         // keep adding to |tmpW|.  Just update and continue.
2240                         checkForBreak = true;
2241                     else
2242                         checkForBreak = false;
2243
2244                     bool canPlaceOnLine = (w + tmpW <= width+1) || !isNormal;
2245                     if (canPlaceOnLine && checkForBreak) {
2246                         w += tmpW;
2247                         tmpW = 0;
2248                         lBreak.obj = next;
2249                         lBreak.pos = 0;
2250                     }
2251                 }
2252             }
2253         }
2254
2255         if (checkForBreak && (w + tmpW > width+1)) {
2256             //kdDebug() << " too wide w=" << w << " tmpW = " << tmpW << " width = " << width << endl;
2257             //kdDebug() << "start=" << start.obj << " current=" << o << endl;
2258             // if we have floats, try to get below them.
2259             if (currentCharacterIsSpace && !ignoringSpaces && o->style()->whiteSpace() != PRE)
2260                 trailingSpaceObject = 0;
2261
2262             int fb = nearestFloatBottom(m_height);
2263             int newLineWidth = lineWidth(fb);
2264             // See if |tmpW| will fit on the new line.  As long as it does not,
2265             // keep adjusting our float bottom until we find some room.
2266             int lastFloatBottom = m_height;
2267             while (lastFloatBottom < fb && tmpW > newLineWidth) {
2268                 lastFloatBottom = fb;
2269                 fb = nearestFloatBottom(fb);
2270                 newLineWidth = lineWidth(fb);
2271             }
2272             if( !w && m_height < fb && width < newLineWidth ) {
2273                 m_height = fb;
2274                 width = newLineWidth;
2275 #ifdef DEBUG_LINEBREAKS
2276                 kdDebug() << "RenderBlock::findNextLineBreak new position at " << m_height << " newWidth " << width << endl;
2277 #endif
2278             }
2279
2280             // |width| may have been adjusted because we got shoved down past a float (thus
2281             // giving us more room), so we need to retest, and only jump to
2282             // the end label if we still don't fit on the line. -dwh
2283             if (w + tmpW > width+1)
2284                 goto end;
2285         }
2286
2287         last = o;
2288         o = next;
2289
2290         if (!last->isFloatingOrPositioned() && last->isReplaced() && last->style()->whiteSpace() == NORMAL) {
2291             // Go ahead and add in tmpW.
2292             w += tmpW;
2293             tmpW = 0;
2294             lBreak.obj = o;
2295             lBreak.pos = 0;
2296         }
2297
2298         // Clear out our character space bool, since inline <pre>s don't collapse whitespace
2299         // with adjacent inline normal/nowrap spans.
2300         if (last->style()->whiteSpace() == PRE)
2301             currentCharacterIsSpace = false;
2302
2303         pos = 0;
2304     }
2305
2306 #ifdef DEBUG_LINEBREAKS
2307     kdDebug( 6041 ) << "end of par, width = " << width << " linewidth = " << w + tmpW << endl;
2308 #endif
2309     if( w + tmpW <= width || (last && last->style()->whiteSpace() == NOWRAP)) {
2310         lBreak.obj = 0;
2311         lBreak.pos = 0;
2312     }
2313
2314  end:
2315
2316     if( lBreak == start && !lBreak.obj->isBR() ) {
2317         // we just add as much as possible
2318         if ( m_pre ) {
2319             if(pos != 0) {
2320                 lBreak.obj = o;
2321                 lBreak.pos = pos - 1;
2322             } else {
2323                 lBreak.obj = last;
2324                 lBreak.pos = last->isText() ? last->length() : 0;
2325             }
2326         } else if( lBreak.obj ) {
2327             if( last != o ) {
2328                 // better to break between object boundaries than in the middle of a word
2329                 lBreak.obj = o;
2330                 lBreak.pos = 0;
2331             } else {
2332                 // Don't ever break in the middle of a word if we can help it.
2333                 // There's no room at all. We just have to be on this line,
2334                 // even though we'll spill out.
2335                 lBreak.obj = o;
2336                 lBreak.pos = pos;
2337             }
2338         }
2339     }
2340
2341     // make sure we consume at least one char/object.
2342     if( lBreak == start )
2343         lBreak.increment(bidi);
2344
2345 #ifdef DEBUG_LINEBREAKS
2346     kdDebug(6041) << "regular break sol: " << start.obj << " " << start.pos << "   end: " << lBreak.obj << " " << lBreak.pos << "   width=" << w << endl;
2347 #endif
2348
2349     // Sanity check our midpoints.
2350     checkMidpoints(lBreak, bidi);
2351
2352     if (trailingSpaceObject) {
2353         // This object is either going to be part of the last midpoint, or it is going
2354         // to be the actual endpoint.  In both cases we just decrease our pos by 1 level to
2355         // exclude the space, allowing it to - in effect - collapse into the newline.
2356         if (sNumMidpoints%2==1) {
2357             BidiIterator* midpoints = smidpoints->data();
2358             midpoints[sNumMidpoints-1].pos--;
2359         }
2360         //else if (lBreak.pos > 0)
2361         //    lBreak.pos--;
2362         else if (lBreak.obj == 0 && trailingSpaceObject->isText()) {
2363             // Add a new end midpoint that stops right at the very end.
2364             RenderText* text = static_cast<RenderText *>(trailingSpaceObject);
2365             unsigned pos = text->length() >=2 ? text->length() - 2 : UINT_MAX;
2366             BidiIterator endMid ( 0, trailingSpaceObject, pos );
2367             addMidpoint(endMid);
2368         }
2369     }
2370
2371     // We might have made lBreak an iterator that points past the end
2372     // of the object. Do this adjustment to make it point to the start
2373     // of the next object instead to avoid confusing the rest of the
2374     // code.
2375     if (lBreak.pos > 0) {
2376         lBreak.pos--;
2377         lBreak.increment(bidi);
2378     }
2379
2380     if (lBreak.obj && lBreak.pos >= 2 && lBreak.obj->isText()) {
2381         // For soft hyphens on line breaks, we have to chop out the midpoints that made us
2382         // ignore the hyphen so that it will render at the end of the line.
2383         QChar c = static_cast<RenderText*>(lBreak.obj)->text()[lBreak.pos-1];
2384         if (c.unicode() == SOFT_HYPHEN)
2385             chopMidpointsAt(lBreak.obj, lBreak.pos-2);
2386     }
2387
2388     return lBreak;
2389 }
2390
2391 void RenderBlock::checkLinesForOverflow()
2392 {
2393     // FIXME: Inline blocks can have overflow.  Need to understand when those objects are present on a line
2394     // and factor that in somehow.
2395     m_overflowWidth = m_width;
2396     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
2397         m_overflowLeft = kMin(curr->leftOverflow(), m_overflowLeft);
2398         m_overflowTop = kMin(curr->topOverflow(), m_overflowTop);
2399         m_overflowWidth = kMax(curr->rightOverflow(), m_overflowWidth);
2400         m_overflowHeight = kMax(curr->bottomOverflow(), m_overflowHeight);
2401     }
2402 }
2403
2404 void RenderBlock::deleteEllipsisLineBoxes()
2405 {
2406     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox())
2407         curr->clearTruncation();
2408 }
2409
2410 void RenderBlock::checkLinesForTextOverflow()
2411 {
2412     // Determine the width of the ellipsis using the current font.
2413     QChar ellipsis = 0x2026; // FIXME: CSS3 says this is configurable, also need to use 0x002E (FULL STOP) if 0x2026 not renderable
2414     static AtomicString ellipsisStr(ellipsis);
2415     const Font& firstLineFont = style(true)->htmlFont();
2416     const Font& font = style()->htmlFont();
2417     int firstLineEllipsisWidth = firstLineFont.width(&ellipsis, 1, 0);
2418     int ellipsisWidth = (font == firstLineFont) ? firstLineEllipsisWidth : font.width(&ellipsis, 1, 0);
2419
2420     // For LTR text truncation, we want to get the right edge of our padding box, and then we want to see
2421     // if the right edge of a line box exceeds that.  For RTL, we use the left edge of the padding box and
2422     // check the left edge of the line box to see if it is less
2423     // Include the scrollbar for overflow blocks, which means we want to use "contentWidth()"
2424     bool ltr = style()->direction() == LTR;
2425     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
2426         int blockEdge = ltr ? rightOffset(curr->yPos()) : leftOffset(curr->yPos());
2427         int lineBoxEdge = ltr ? curr->xPos() + curr->width() : curr->xPos();
2428         if ((ltr && lineBoxEdge > blockEdge) || (!ltr && lineBoxEdge < blockEdge)) {
2429             // This line spills out of our box in the appropriate direction.  Now we need to see if the line
2430             // can be truncated.  In order for truncation to be possible, the line must have sufficient space to
2431             // accommodate our truncation string, and no replaced elements (images, tables) can overlap the ellipsis
2432             // space.
2433             int width = curr == firstRootBox() ? firstLineEllipsisWidth : ellipsisWidth;
2434             if (curr->canAccommodateEllipsis(ltr, blockEdge, lineBoxEdge, width))
2435                 curr->placeEllipsis(ellipsisStr, ltr, blockEdge, width);
2436         }
2437     }
2438 }
2439
2440 // For --enable-final
2441 #undef BIDI_DEBUG
2442 #undef DEBUG_LINEBREAKS
2443 #undef DEBUG_LAYOUT
2444
2445 }