3cdaa54bfe51c11bb8a439fa2b9295b7487a2d18
[WebKit-https.git] / 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
63 struct BidiStatus {
64     BidiStatus() : eor(QChar::DirON), lastStrong(QChar::DirON), last(QChar::DirON) {}
65     
66     QChar::Direction eor;
67     QChar::Direction lastStrong;
68     QChar::Direction last;
69 };
70     
71 struct BidiState {
72     BidiState() : context(0) {}
73     
74     BidiIterator sor;
75     BidiIterator eor;
76     BidiIterator last;
77     BidiIterator current;
78     BidiContext *context;
79     BidiStatus status;
80 };
81
82 // Used to track a list of chained bidi runs.
83 static BidiRun* sFirstBidiRun;
84 static BidiRun* sLastBidiRun;
85 static int sBidiRunCount;
86 static BidiRun* sCompactFirstBidiRun;
87 static BidiRun* sCompactLastBidiRun;
88 static int sCompactBidiRunCount;
89 static bool sBuildingCompactRuns;
90
91 // Midpoint globals.  The goal is not to do any allocation when dealing with
92 // these midpoints, so we just keep an array around and never clear it.  We track
93 // the number of items and position using the two other variables.
94 static QMemArray<BidiIterator> *smidpoints;
95 static uint sNumMidpoints;
96 static uint sCurrMidpoint;
97 static bool betweenMidpoints;
98
99 static bool isLineEmpty = true;
100 static bool previousLineBrokeCleanly = true;
101 static QChar::Direction dir;
102 static bool adjustEmbedding;
103 static bool emptyRun = true;
104 static int numSpaces;
105
106 static void embed( QChar::Direction d, BidiState &bidi );
107 static void appendRun( BidiState &bidi );
108
109 static int getBPMWidth(int childValue, Length cssUnit)
110 {
111     if (cssUnit.type != Variable)
112         return (cssUnit.type == Fixed ? cssUnit.value : childValue);
113     return 0;
114 }
115
116 static int getBorderPaddingMargin(RenderObject* child, bool endOfInline)
117 {
118     RenderStyle* cstyle = child->style();
119     int result = 0;
120     bool leftSide = (cstyle->direction() == LTR) ? !endOfInline : endOfInline;
121     result += getBPMWidth((leftSide ? child->marginLeft() : child->marginRight()),
122                           (leftSide ? cstyle->marginLeft() :
123                            cstyle->marginRight()));
124     result += getBPMWidth((leftSide ? child->paddingLeft() : child->paddingRight()),
125                           (leftSide ? cstyle->paddingLeft() :
126                            cstyle->paddingRight()));
127     result += leftSide ? child->borderLeft() : child->borderRight();
128     return result;
129 }
130
131 static int inlineWidth(RenderObject* child, bool start = true, bool end = true)
132 {
133     int extraWidth = 0;
134     RenderObject* parent = child->parent();
135     while (parent->isInline() && !parent->isInlineBlockOrInlineTable()) {
136         if (start && parent->firstChild() == child)
137             extraWidth += getBorderPaddingMargin(parent, false);
138         if (end && parent->lastChild() == child)
139             extraWidth += getBorderPaddingMargin(parent, true);
140         child = parent;
141         parent = child->parent();
142     }
143     return extraWidth;
144 }
145
146 #ifndef NDEBUG
147 static bool inBidiRunDetach;
148 #endif
149
150 void BidiRun::detach(RenderArena* renderArena)
151 {
152 #ifndef NDEBUG
153     inBidiRunDetach = true;
154 #endif
155     delete this;
156 #ifndef NDEBUG
157     inBidiRunDetach = false;
158 #endif
159
160     // Recover the size left there for us by operator delete and free the memory.
161     renderArena->free(*(size_t *)this, this);
162 }
163
164 void* BidiRun::operator new(size_t sz, RenderArena* renderArena) throw()
165 {
166     return renderArena->allocate(sz);
167 }
168
169 void BidiRun::operator delete(void* ptr, size_t sz)
170 {
171     assert(inBidiRunDetach);
172
173     // Stash size where detach can find it.
174     *(size_t*)ptr = sz;
175 }
176
177 static void deleteBidiRuns(RenderArena* arena)
178 {
179     if (!sFirstBidiRun)
180         return;
181
182     BidiRun* curr = sFirstBidiRun;
183     while (curr) {
184         BidiRun* s = curr->nextRun;
185         curr->detach(arena);
186         curr = s;
187     }
188     
189     sFirstBidiRun = 0;
190     sLastBidiRun = 0;
191     sBidiRunCount = 0;
192 }
193
194 // ---------------------------------------------------------------------
195
196 /* a small helper class used internally to resolve Bidi embedding levels.
197    Each line of text caches the embedding level at the start of the line for faster
198    relayouting
199 */
200 BidiContext::BidiContext(unsigned char l, QChar::Direction e, BidiContext *p, bool o)
201     : level(l) , override(o), dir(e)
202 {
203     parent = p;
204     if(p) {
205         p->ref();
206         basicDir = p->basicDir;
207     } else
208         basicDir = e;
209     count = 0;
210 }
211
212 BidiContext::~BidiContext()
213 {
214     if(parent) parent->deref();
215 }
216
217 void BidiContext::ref() const
218 {
219     count++;
220 }
221
222 void BidiContext::deref() const
223 {
224     count--;
225     if(count <= 0) delete this;
226 }
227
228 // ---------------------------------------------------------------------
229
230 inline bool operator==( const BidiIterator &it1, const BidiIterator &it2 )
231 {
232     if(it1.pos != it2.pos) return false;
233     if(it1.obj != it2.obj) return false;
234     return true;
235 }
236
237 inline bool operator!=( const BidiIterator &it1, const BidiIterator &it2 )
238 {
239     if(it1.pos != it2.pos) return true;
240     if(it1.obj != it2.obj) return true;
241     return false;
242 }
243
244 static inline RenderObject *Bidinext(RenderObject *par, RenderObject *current, BidiState &bidi,
245                                      bool skipInlines = true, bool* endOfInline = 0)
246 {
247     RenderObject *next = 0;
248     bool oldEndOfInline = endOfInline ? *endOfInline : false;
249     if (endOfInline)
250         *endOfInline = false;
251
252     while(current != 0)
253     {
254         //kdDebug( 6040 ) << "current = " << current << endl;
255         if (!oldEndOfInline && !current->isFloating() && !current->isReplaced() && !current->isPositioned()) {
256             next = current->firstChild();
257             if ( next && adjustEmbedding ) {
258                 EUnicodeBidi ub = next->style()->unicodeBidi();
259                 if ( ub != UBNormal && !emptyRun ) {
260                     EDirection dir = next->style()->direction();
261 QChar::Direction d = ( ub == Embed ? ( dir == RTL ? QChar::DirRLE : QChar::DirLRE )
262                                    : ( dir == RTL ? QChar::DirRLO : QChar::DirLRO ) );
263                     embed( d, bidi );
264                 }
265             }
266         }
267         if (!next) {
268             if (!skipInlines && !oldEndOfInline && current->isInlineFlow())
269             {
270                 next = current;
271                 if (endOfInline)
272                     *endOfInline = true;
273                 break;
274             }
275
276             while (current && current != par) {
277                 next = current->nextSibling();
278                 if (next) break;
279                 if ( adjustEmbedding && current->style()->unicodeBidi() != UBNormal && !emptyRun ) {
280                     embed( QChar::DirPDF, bidi );
281                 }
282                 current = current->parent();
283                 if (!skipInlines && current && current != par && current->isInlineFlow()) {
284                     next = current;
285                     if (endOfInline)
286                         *endOfInline = true;
287                     break;
288                 }
289             }
290         }
291
292         if (!next) break;
293
294         if (next->isText() || next->isBR() || next->isFloating() || next->isReplaced() || next->isPositioned()
295             || ((!skipInlines || !next->firstChild()) // Always return EMPTY inlines.
296                 && next->isInlineFlow()))
297             break;
298         current = next;
299     }
300     return next;
301 }
302
303 static RenderObject *first( RenderObject *par, BidiState &bidi, bool skipInlines = true )
304 {
305     if(!par->firstChild()) return 0;
306     RenderObject *o = par->firstChild();
307
308     if (o->isInlineFlow()) {
309         if (skipInlines && o->firstChild())
310             o = Bidinext( par, o, bidi, skipInlines );
311         else
312             return o; // Never skip empty inlines.
313     }
314
315     if (o && !o->isText() && !o->isBR() && !o->isReplaced() && !o->isFloating() && !o->isPositioned())
316         o = Bidinext( par, o, bidi, skipInlines );
317     return o;
318 }
319
320 inline void BidiIterator::increment (BidiState &bidi)
321 {
322     if(!obj) return;
323     if(obj->isText()) {
324         pos++;
325         if(pos >= static_cast<RenderText *>(obj)->stringLength()) {
326             obj = Bidinext( par, obj, bidi );
327             pos = 0;
328         }
329     } else {
330         obj = Bidinext( par, obj, bidi );
331         pos = 0;
332     }
333 }
334
335 inline bool BidiIterator::atEnd() const
336 {
337     if(!obj) return true;
338     return false;
339 }
340
341 const QChar &BidiIterator::current() const
342 {
343     static QChar nonBreakingSpace(0xA0);
344     
345     if (!obj || !obj->isText())
346       return nonBreakingSpace;
347     
348     RenderText* text = static_cast<RenderText*>(obj);
349     if (!text->text())
350         return nonBreakingSpace;
351     
352     return text->text()[pos];
353 }
354
355 inline QChar::Direction BidiIterator::direction() const
356 {
357     if (!obj)
358         return QChar::DirON;
359     if (obj->isListMarker())
360         return obj->style()->direction() == LTR ? QChar::DirL : QChar::DirR;
361     if (!obj->isText())
362         return QChar::DirON;
363
364     RenderText *renderTxt = static_cast<RenderText *>( obj );
365     if ( pos >= renderTxt->stringLength() )
366         return QChar::DirON;
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()))
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 totWidth = lineBox->getFlowSpacingWidth();
721     BidiRun* r = 0;
722     for (r = sFirstBidiRun; r; r = r->nextRun) {
723         if (!r->box || r->obj->isPositioned())
724             continue; // Positioned objects are only participating to figure out their
725                       // correct static x position.  They have no effect on the width.
726         if (r->obj->isText())
727             r->box->setWidth(static_cast<RenderText *>(r->obj)->width(r->start, r->stop-r->start, m_firstLine));
728         else if (!r->obj->isInlineFlow()) {
729             r->obj->calcWidth();
730             r->box->setWidth(r->obj->width());
731             if (!r->compact)
732                 totWidth += r->obj->marginLeft() + r->obj->marginRight();
733         }
734
735         // Compacts don't contribute to the width of the line, since they are placed in the margin.
736         if (!r->compact)
737             totWidth += r->box->width();
738     }
739
740     // Armed with the total width of the line (without justification),
741     // we now examine our text-align property in order to determine where to position the
742     // objects horizontally.  The total width of the line can be increased if we end up
743     // justifying text.
744     int x = leftOffset(m_height);
745     int availableWidth = lineWidth(m_height);
746     switch(style()->textAlign()) {
747         case LEFT:
748         case KHTML_LEFT:
749             // The direction of the block should determine what happens with wide lines.  In
750             // particular with RTL blocks, wide lines should still spill out to the left.
751             if (style()->direction() == RTL && totWidth > availableWidth)
752                 x -= (totWidth - availableWidth);
753             numSpaces = 0;
754             break;
755         case JUSTIFY:
756             if (numSpaces != 0 && !bidi.current.atEnd() && !lineBox->endsWithBreak())
757                 break;
758             // fall through
759         case TAAUTO:
760             numSpaces = 0;
761             // for right to left fall through to right aligned
762             if (bidi.context->basicDir == QChar::DirL)
763                 break;
764         case RIGHT:
765         case KHTML_RIGHT:
766             // Wide lines spill out of the block based off direction.
767             // So even if text-align is right, if direction is LTR, wide lines should overflow out of the right
768             // side of the block.
769             if (style()->direction() == RTL || totWidth < availableWidth)
770                 x += availableWidth - totWidth;
771             numSpaces = 0;
772             break;
773         case CENTER:
774         case KHTML_CENTER:
775             int xd = (availableWidth - totWidth)/2;
776             x += xd >0 ? xd : 0;
777             numSpaces = 0;
778             break;
779     }
780
781     if (numSpaces > 0) {
782         for (r = sFirstBidiRun; r; r = r->nextRun) {
783             if (!r->box) continue;
784
785             int spaceAdd = 0;
786             if (numSpaces > 0 && r->obj->isText() && !r->compact) {
787                 // get the number of spaces in the run
788                 int spaces = 0;
789                 for ( int i = r->start; i < r->stop; i++ ) {
790                     const QChar c = static_cast<RenderText *>(r->obj)->text()[i];
791                     if (c == ' ' || c == '\n')
792                         spaces++;
793                 }
794
795                 KHTMLAssert(spaces <= numSpaces);
796
797                 // Only justify text with white-space: normal.
798                 if (r->obj->style()->whiteSpace() != PRE) {
799                     spaceAdd = (availableWidth - totWidth)*spaces/numSpaces;
800                     static_cast<InlineTextBox*>(r->box)->setSpaceAdd(spaceAdd);
801                     totWidth += spaceAdd;
802                 }
803                 numSpaces -= spaces;
804             }
805         }
806     }
807     
808     // The widths of all runs are now known.  We can now place every inline box (and
809     // compute accurate widths for the inline flow boxes).
810     int rightPos = lineBox->placeBoxesHorizontally(x);
811     if (rightPos > m_overflowWidth)
812         m_overflowWidth = rightPos; // FIXME: Work for rtl overflow also.
813 }
814
815 void RenderBlock::computeVerticalPositionsForLine(RootInlineBox* lineBox)
816 {
817     lineBox->verticallyAlignBoxes(m_height);
818     lineBox->setBlockHeight(m_height);
819
820     // See if the line spilled out.  If so set overflow height accordingly.
821     int bottomOfLine = lineBox->bottomOverflow();
822     if (bottomOfLine > m_height && bottomOfLine > m_overflowHeight)
823         m_overflowHeight = bottomOfLine;
824         
825     // Now make sure we place replaced render objects correctly.
826     for (BidiRun* r = sFirstBidiRun; r; r = r->nextRun) {
827         if (!r->box) continue; // Skip runs with no line boxes.
828
829         // Align positioned boxes with the top of the line box.  This is
830         // a reasonable approximation of an appropriate y position.
831         if (r->obj->isPositioned())
832             r->box->setYPos(m_height);
833
834         // Position is used to properly position both replaced elements and
835         // to update the static normal flow x/y of positioned elements.
836         r->obj->position(r->box, r->start, r->stop - r->start, r->level%2);
837     }
838 }
839
840 // collects one line of the paragraph and transforms it to visual order
841 void RenderBlock::bidiReorderLine(const BidiIterator &start, const BidiIterator &end, BidiState &bidi)
842 {
843     if ( start == end ) {
844         if ( start.current() == '\n' ) {
845             m_height += lineHeight( m_firstLine, true );
846         }
847         return;
848     }
849
850 #if BIDI_DEBUG > 1
851     kdDebug(6041) << "reordering Line from " << start.obj << "/" << start.pos << " to " << end.obj << "/" << end.pos << endl;
852 #endif
853
854     sFirstBidiRun = 0;
855     sLastBidiRun = 0;
856     sBidiRunCount = 0;
857     
858     //    context->ref();
859
860     dir = QChar::DirON;
861     emptyRun = true;
862
863     numSpaces = 0;
864
865     bidi.current = start;
866     bidi.last = bidi.current;
867     bool atEnd = false;
868     while( 1 ) {
869
870         QChar::Direction dirCurrent;
871         if (atEnd) {
872             //kdDebug(6041) << "atEnd" << endl;
873             BidiContext *c = bidi.context;
874             if ( bidi.current.atEnd())
875                 while ( c->parent )
876                     c = c->parent;
877             dirCurrent = c->dir;
878         } else {
879             dirCurrent = bidi.current.direction();
880         }
881
882 #ifndef QT_NO_UNICODETABLES
883
884 #if BIDI_DEBUG > 1
885         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;
886 #endif
887
888         switch(dirCurrent) {
889
890             // embedding and overrides (X1-X9 in the Bidi specs)
891         case QChar::DirRLE:
892         case QChar::DirLRE:
893         case QChar::DirRLO:
894         case QChar::DirLRO:
895         case QChar::DirPDF:
896             bidi.eor = bidi.last;
897             embed( dirCurrent, bidi );
898             break;
899
900             // strong types
901         case QChar::DirL:
902             if(dir == QChar::DirON)
903                 dir = QChar::DirL;
904             switch(bidi.status.last)
905                 {
906                 case QChar::DirL:
907                     bidi.eor = bidi.current; bidi.status.eor = QChar::DirL; break;
908                 case QChar::DirR:
909                 case QChar::DirAL:
910                 case QChar::DirEN:
911                 case QChar::DirAN:
912                     appendRun( bidi );
913                     break;
914                 case QChar::DirES:
915                 case QChar::DirET:
916                 case QChar::DirCS:
917                 case QChar::DirBN:
918                 case QChar::DirB:
919                 case QChar::DirS:
920                 case QChar::DirWS:
921                 case QChar::DirON:
922                     if(dir != QChar::DirL) {
923                         //last stuff takes embedding dir
924                         if( bidi.context->dir == QChar::DirR ) {
925                             if(!(bidi.status.eor == QChar::DirR)) {
926                                 // AN or EN
927                                 appendRun( bidi );
928                                 dir = QChar::DirR;
929                             }
930                             else
931                                 bidi.eor = bidi.last;
932                             appendRun( bidi );
933                             dir = QChar::DirL;
934                             bidi.status.eor = QChar::DirL;
935                         } else {
936                             if(bidi.status.eor == QChar::DirR) {
937                                 appendRun( bidi );
938                                 dir = QChar::DirL;
939                             } else {
940                                 bidi.eor = bidi.current; bidi.status.eor = QChar::DirL; break;
941                             }
942                         }
943                     } else {
944                         bidi.eor = bidi.current; bidi.status.eor = QChar::DirL;
945                     }
946                 default:
947                     break;
948                 }
949             bidi.status.lastStrong = QChar::DirL;
950             break;
951         case QChar::DirAL:
952         case QChar::DirR:
953             if(dir == QChar::DirON) dir = QChar::DirR;
954             switch(bidi.status.last)
955                 {
956                 case QChar::DirR:
957                 case QChar::DirAL:
958                     bidi.eor = bidi.current; bidi.status.eor = QChar::DirR; break;
959                 case QChar::DirL:
960                 case QChar::DirEN:
961                 case QChar::DirAN:
962                     appendRun( bidi );
963                     dir = QChar::DirR;
964                     bidi.eor = bidi.current;
965                     bidi.status.eor = QChar::DirR;
966                     break;
967                 case QChar::DirES:
968                 case QChar::DirET:
969                 case QChar::DirCS:
970                 case QChar::DirBN:
971                 case QChar::DirB:
972                 case QChar::DirS:
973                 case QChar::DirWS:
974                 case QChar::DirON:
975                     if( !(bidi.status.eor == QChar::DirR) && !(bidi.status.eor == QChar::DirAL) ) {
976                         //last stuff takes embedding dir
977                         if(bidi.context->dir == QChar::DirR || bidi.status.lastStrong == QChar::DirR) {
978                             appendRun( bidi );
979                             dir = QChar::DirR;
980                             bidi.eor = bidi.current;
981                             bidi.status.eor = QChar::DirR;
982                         } else {
983                             bidi.eor = bidi.last;
984                             appendRun( bidi );
985                             dir = QChar::DirR;
986                             bidi.status.eor = QChar::DirR;
987                         }
988                     } else {
989                         bidi.eor = bidi.current; bidi.status.eor = QChar::DirR;
990                     }
991                 default:
992                     break;
993                 }
994             bidi.status.lastStrong = dirCurrent;
995             break;
996
997             // weak types:
998
999         case QChar::DirNSM:
1000             // ### if @sor, set dir to dirSor
1001             break;
1002         case QChar::DirEN:
1003             if(!(bidi.status.lastStrong == QChar::DirAL)) {
1004                 // if last strong was AL change EN to AN
1005                 if(dir == QChar::DirON) {
1006                     if(bidi.status.lastStrong == QChar::DirAL)
1007                         dir = QChar::DirAN;
1008                     else
1009                         dir = QChar::DirL;
1010                 }
1011                 switch(bidi.status.last)
1012                     {
1013                     case QChar::DirET:
1014                         if ( bidi.status.lastStrong == QChar::DirR || bidi.status.lastStrong == QChar::DirAL ) {
1015                             appendRun( bidi );
1016                             dir = QChar::DirEN;
1017                             bidi.status.eor = QChar::DirEN;
1018                         }
1019                         // fall through
1020                     case QChar::DirEN:
1021                     case QChar::DirL:
1022                         bidi.eor = bidi.current;
1023                         bidi.status.eor = dirCurrent;
1024                         break;
1025                     case QChar::DirR:
1026                     case QChar::DirAL:
1027                     case QChar::DirAN:
1028                         appendRun( bidi );
1029                         bidi.status.eor = QChar::DirEN;
1030                         dir = QChar::DirEN; break;
1031                     case QChar::DirES:
1032                     case QChar::DirCS:
1033                         if(bidi.status.eor == QChar::DirEN) {
1034                             bidi.eor = bidi.current; break;
1035                         }
1036                     case QChar::DirBN:
1037                     case QChar::DirB:
1038                     case QChar::DirS:
1039                     case QChar::DirWS:
1040                     case QChar::DirON:
1041                         if(bidi.status.eor == QChar::DirR) {
1042                             // neutrals go to R
1043                             bidi.eor = bidi.last;
1044                             appendRun( bidi );
1045                             dir = QChar::DirEN;
1046                             bidi.status.eor = QChar::DirEN;
1047                         }
1048                         else if( bidi.status.eor == QChar::DirL ||
1049                                  (bidi.status.eor == QChar::DirEN && bidi.status.lastStrong == QChar::DirL)) {
1050                             bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1051                         } else {
1052                             // numbers on both sides, neutrals get right to left direction
1053                             if(dir != QChar::DirL) {
1054                                 appendRun( bidi );
1055                                 bidi.eor = bidi.last;
1056                                 dir = QChar::DirR;
1057                                 appendRun( bidi );
1058                                 dir = QChar::DirEN;
1059                                 bidi.status.eor = QChar::DirEN;
1060                             } else {
1061                                 bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1062                             }
1063                         }
1064                     default:
1065                         break;
1066                     }
1067                 break;
1068             }
1069         case QChar::DirAN:
1070             dirCurrent = QChar::DirAN;
1071             if(dir == QChar::DirON) dir = QChar::DirAN;
1072             switch(bidi.status.last)
1073                 {
1074                 case QChar::DirL:
1075                 case QChar::DirAN:
1076                     bidi.eor = bidi.current; bidi.status.eor = QChar::DirAN; break;
1077                 case QChar::DirR:
1078                 case QChar::DirAL:
1079                 case QChar::DirEN:
1080                     appendRun( bidi );
1081                     dir = QChar::DirAN; bidi.status.eor = QChar::DirAN;
1082                     break;
1083                 case QChar::DirCS:
1084                     if(bidi.status.eor == QChar::DirAN) {
1085                         bidi.eor = bidi.current; bidi.status.eor = QChar::DirR; break;
1086                     }
1087                 case QChar::DirES:
1088                 case QChar::DirET:
1089                 case QChar::DirBN:
1090                 case QChar::DirB:
1091                 case QChar::DirS:
1092                 case QChar::DirWS:
1093                 case QChar::DirON:
1094                     if(bidi.status.eor == QChar::DirR) {
1095                         // neutrals go to R
1096                         bidi.eor = bidi.last;
1097                         appendRun( bidi );
1098                         dir = QChar::DirAN;
1099                         bidi.status.eor = QChar::DirAN;
1100                     } else if( bidi.status.eor == QChar::DirL ||
1101                                (bidi.status.eor == QChar::DirEN && bidi.status.lastStrong == QChar::DirL)) {
1102                         bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1103                     } else {
1104                         // numbers on both sides, neutrals get right to left direction
1105                         if(dir != QChar::DirL) {
1106                             appendRun( bidi );
1107                             bidi.eor = bidi.last;
1108                             dir = QChar::DirR;
1109                             appendRun( bidi );
1110                             dir = QChar::DirAN;
1111                             bidi.status.eor = QChar::DirAN;
1112                         } else {
1113                             bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1114                         }
1115                     }
1116                 default:
1117                     break;
1118                 }
1119             break;
1120         case QChar::DirES:
1121         case QChar::DirCS:
1122             break;
1123         case QChar::DirET:
1124             if(bidi.status.last == QChar::DirEN) {
1125                 dirCurrent = QChar::DirEN;
1126                 bidi.eor = bidi.current; bidi.status.eor = dirCurrent;
1127                 break;
1128             }
1129             break;
1130
1131         // boundary neutrals should be ignored
1132         case QChar::DirBN:
1133             break;
1134             // neutrals
1135         case QChar::DirB:
1136             // ### what do we do with newline and paragraph seperators that come to here?
1137             break;
1138         case QChar::DirS:
1139             // ### implement rule L1
1140             break;
1141         case QChar::DirWS:
1142             break;
1143         case QChar::DirON:
1144             break;
1145         default:
1146             break;
1147         }
1148
1149         //cout << "     after: dir=" << //        dir << " current=" << dirCurrent << " last=" << status.last << " eor=" << status.eor << " lastStrong=" << status.lastStrong << " embedding=" << context->dir << endl;
1150
1151         if(bidi.current.atEnd()) break;
1152
1153         // set status.last as needed.
1154         switch(dirCurrent)
1155             {
1156             case QChar::DirET:
1157             case QChar::DirES:
1158             case QChar::DirCS:
1159             case QChar::DirS:
1160             case QChar::DirWS:
1161             case QChar::DirON:
1162                 switch(bidi.status.last)
1163                     {
1164                     case QChar::DirL:
1165                     case QChar::DirR:
1166                     case QChar::DirAL:
1167                     case QChar::DirEN:
1168                     case QChar::DirAN:
1169                         bidi.status.last = dirCurrent;
1170                         break;
1171                     default:
1172                         bidi.status.last = QChar::DirON;
1173                     }
1174                 break;
1175             case QChar::DirNSM:
1176             case QChar::DirBN:
1177                 // ignore these
1178                 break;
1179             case QChar::DirEN:
1180                 if ( bidi.status.last == QChar::DirL ) {
1181                     bidi.status.last = QChar::DirL;
1182                     break;
1183                 }
1184                 // fall through
1185             default:
1186                 bidi.status.last = dirCurrent;
1187             }
1188 #endif
1189
1190         if ( atEnd ) break;
1191         bidi.last = bidi.current;
1192
1193         if ( emptyRun ) {
1194             bidi.sor = bidi.current;
1195             bidi.eor = bidi.current;
1196             emptyRun = false;
1197         }
1198
1199         // this causes the operator ++ to open and close embedding levels as needed
1200         // for the CSS unicode-bidi property
1201         adjustEmbedding = true;
1202         bidi.current.increment( bidi );
1203         adjustEmbedding = false;
1204
1205         if ( bidi.current == end ) {
1206             if ( emptyRun )
1207                 break;
1208             atEnd = true;
1209         }
1210     }
1211
1212 #if BIDI_DEBUG > 0
1213     kdDebug(6041) << "reached end of line current=" << current.obj << "/" << current.pos
1214                   << ", eor=" << eor.obj << "/" << eor.pos << endl;
1215 #endif
1216     if ( !emptyRun && bidi.sor != bidi.current ) {
1217             bidi.eor = bidi.last;
1218             appendRun( bidi );
1219     }
1220
1221     // reorder line according to run structure...
1222
1223     // first find highest and lowest levels
1224     uchar levelLow = 128;
1225     uchar levelHigh = 0;
1226     BidiRun *r = sFirstBidiRun;
1227     while ( r ) {
1228         if ( r->level > levelHigh )
1229             levelHigh = r->level;
1230         if ( r->level < levelLow )
1231             levelLow = r->level;
1232         r = r->nextRun;
1233     }
1234
1235     // implements reordering of the line (L2 according to Bidi spec):
1236     // L2. From the highest level found in the text to the lowest odd level on each line,
1237     // reverse any contiguous sequence of characters that are at that level or higher.
1238
1239     // reversing is only done up to the lowest odd level
1240     if( !(levelLow%2) ) levelLow++;
1241
1242 #if BIDI_DEBUG > 0
1243     kdDebug(6041) << "lineLow = " << (uint)levelLow << ", lineHigh = " << (uint)levelHigh << endl;
1244     kdDebug(6041) << "logical order is:" << endl;
1245     QPtrListIterator<BidiRun> it2(runs);
1246     BidiRun *r2;
1247     for ( ; (r2 = it2.current()); ++it2 )
1248         kdDebug(6041) << "    " << r2 << "  start=" << r2->start << "  stop=" << r2->stop << "  level=" << (uint)r2->level << endl;
1249 #endif
1250
1251     int count = sBidiRunCount - 1;
1252
1253     // do not reverse for visually ordered web sites
1254     if(!style()->visuallyOrdered()) {
1255         while(levelHigh >= levelLow) {
1256             int i = 0;
1257             BidiRun* currRun = sFirstBidiRun;
1258             while ( i < count ) {
1259                 while(i < count && currRun && currRun->level < levelHigh) {
1260                     i++;
1261                     currRun = currRun->nextRun;
1262                 }
1263                 int start = i;
1264                 while(i <= count && currRun && currRun->level >= levelHigh) {
1265                     i++;
1266                     currRun = currRun->nextRun;
1267                 }
1268                 int end = i-1;
1269                 reverseRuns(start, end);
1270                 i++;
1271                 if(i >= count) break;
1272             }
1273             levelHigh--;
1274         }
1275     }
1276
1277 #if BIDI_DEBUG > 0
1278     kdDebug(6041) << "visual order is:" << endl;
1279     for (BidiRun* curr = sFirstRun; curr; curr = curr->nextRun)
1280         kdDebug(6041) << "    " << curr << endl;
1281 #endif
1282 }
1283
1284 static void buildCompactRuns(RenderObject* compactObj, BidiState &bidi)
1285 {
1286     sBuildingCompactRuns = true;
1287     if (!compactObj->isRenderBlock()) {
1288         // Just append a run for our object.
1289         isLineEmpty = false;
1290         addRun(new (compactObj->renderArena()) BidiRun(0, compactObj->length(), compactObj, bidi.context, dir));
1291     }
1292     else {
1293         // Format the compact like it is its own single line.  We build up all the runs for
1294         // the little compact and then reorder them for bidi.
1295         RenderBlock* compactBlock = static_cast<RenderBlock*>(compactObj);
1296         adjustEmbedding = true;
1297         BidiIterator start(compactBlock, first(compactBlock, bidi), 0);
1298         adjustEmbedding = false;
1299         BidiIterator end = start;
1300     
1301         betweenMidpoints = false;
1302         isLineEmpty = true;
1303         previousLineBrokeCleanly = true;
1304         
1305         end = compactBlock->findNextLineBreak(start, bidi);
1306         if (!isLineEmpty)
1307             compactBlock->bidiReorderLine(start, end, bidi);
1308     }
1309     
1310     
1311     sCompactFirstBidiRun = sFirstBidiRun;
1312     sCompactLastBidiRun = sLastBidiRun;
1313     sCompactBidiRunCount = sBidiRunCount;
1314     
1315     sNumMidpoints = 0;
1316     sCurrMidpoint = 0;
1317     betweenMidpoints = false;
1318     sBuildingCompactRuns = false;
1319 }
1320
1321 QRect RenderBlock::layoutInlineChildren(bool relayoutChildren)
1322 {
1323     BidiState bidi;
1324
1325     bool useRepaintRect = false;
1326     QRect repaintRect(0,0,0,0);
1327
1328     m_overflowHeight = 0;
1329     
1330     invalidateVerticalPositions();
1331 #ifdef DEBUG_LAYOUT
1332     QTime qt;
1333     qt.start();
1334     kdDebug( 6040 ) << renderName() << " layoutInlineChildren( " << this <<" )" << endl;
1335 #endif
1336 #if BIDI_DEBUG > 1 || defined( DEBUG_LINEBREAKS )
1337     kdDebug(6041) << " ------- bidi start " << this << " -------" << endl;
1338 #endif
1339     
1340     m_height = borderTop() + paddingTop();
1341     int toAdd = borderBottom() + paddingBottom();
1342     if (includeScrollbarSize())
1343         toAdd += m_layer->horizontalScrollbarHeight();
1344     
1345     // Figure out if we should clear out our line boxes.
1346     // FIXME: Handle resize eventually!
1347     // FIXME: Do something better when floats are present.
1348     bool fullLayout = !firstLineBox() || !firstChild() || selfNeedsLayout() || relayoutChildren || containsFloats();
1349     if (fullLayout)
1350         deleteLineBoxes();
1351         
1352     // Text truncation only kicks in if your overflow isn't visible and your text-overflow-mode isn't
1353     // clip.
1354     // FIXME: CSS3 says that descendants that are clipped must also know how to truncate.  This is insanely
1355     // difficult to figure out (especially in the middle of doing layout), and is really an esoteric pile of nonsense
1356     // anyway, so we won't worry about following the draft here.
1357     bool hasTextOverflow = style()->textOverflow() && hasOverflowClip();
1358     
1359     // Walk all the lines and delete our ellipsis line boxes if they exist.
1360     if (hasTextOverflow)
1361          deleteEllipsisLineBoxes();
1362
1363     if (firstChild()) {
1364         // layout replaced elements
1365         bool endOfInline = false;
1366         RenderObject *o = first(this, bidi, false);
1367         bool hasFloat = false;
1368         while (o) {
1369             if (o->isReplaced() || o->isFloating() || o->isPositioned()) {
1370                 if (relayoutChildren || o->style()->width().isPercent() || o->style()->height().isPercent())
1371                     o->setChildNeedsLayout(true, false);
1372                 if (o->isPositioned())
1373                     o->containingBlock()->insertPositionedObject(o);
1374                 else {
1375                     if (o->isFloating())
1376                         hasFloat = true;
1377                     else if (fullLayout || o->needsLayout()) // Replaced elements
1378                         o->dirtyLineBoxes(fullLayout);
1379                     o->layoutIfNeeded();
1380                 }
1381             }
1382             else if (o->isText() || (o->isInlineFlow() && !endOfInline)) {
1383                 if (fullLayout || o->selfNeedsLayout())
1384                     o->dirtyLineBoxes(fullLayout);
1385                 o->setNeedsLayout(false);
1386             }
1387             o = Bidinext( this, o, bidi, false, &endOfInline);
1388         }
1389
1390         if (hasFloat)
1391             fullLayout = true; // FIXME: Will need to find a way to optimize floats some day.
1392         
1393         if (fullLayout && !selfNeedsLayout()) {
1394             setNeedsLayout(true, false);  // Mark ourselves as needing a full layout. This way we'll repaint like
1395                                           // we're supposed to.
1396             if (!document()->view()->needsFullRepaint() && m_layer) {
1397                 // Because we waited until we were already inside layout to discover
1398                 // that the block really needed a full layout, we missed our chance to repaint the layer
1399                 // before layout started.  Luckily the layer has cached the repaint rect for its original
1400                 // position and size, and so we can use that to make a repaint happen now.
1401                 RenderCanvas* c = canvas();
1402                 if (c && !c->printingMode())
1403                     c->repaintViewRectangle(m_layer->repaintRect());
1404             }
1405         }
1406
1407         BidiContext *startEmbed;
1408         if( style()->direction() == LTR ) {
1409             startEmbed = new BidiContext( 0, QChar::DirL );
1410             bidi.status.eor = QChar::DirL;
1411         } else {
1412             startEmbed = new BidiContext( 1, QChar::DirR );
1413             bidi.status.eor = QChar::DirR;
1414         }
1415         startEmbed->ref();
1416
1417         bidi.status.lastStrong = QChar::DirON;
1418         bidi.status.last = QChar::DirON;
1419         bidi.context = startEmbed;
1420         
1421         if (!smidpoints)
1422             smidpoints = new QMemArray<BidiIterator>;
1423         
1424         sNumMidpoints = 0;
1425         sCurrMidpoint = 0;
1426         sCompactFirstBidiRun = sCompactLastBidiRun = 0;
1427         sCompactBidiRunCount = 0;
1428         
1429         // We want to skip ahead to the first dirty line
1430         BidiIterator start;
1431         RootInlineBox* startLine = determineStartPosition(fullLayout, start, bidi);
1432         
1433         // We also find the first clean line and extract these lines.  We will add them back
1434         // if we determine that we're able to synchronize after handling all our dirty lines.
1435         BidiIterator cleanLineStart;
1436         int endLineYPos;
1437         RootInlineBox* endLine = (fullLayout || !startLine) ? 
1438                                  0 : determineEndPosition(startLine, cleanLineStart, endLineYPos);
1439         
1440         if (startLine) {
1441             useRepaintRect = true;
1442             repaintRect.setY(m_height);
1443             RenderArena* arena = renderArena();
1444             RootInlineBox* box = startLine;
1445             while (box) {
1446                 RootInlineBox* next = box->nextRootBox();
1447                 box->deleteLine(arena);
1448                 box = next;
1449             }
1450             startLine = 0;
1451         }
1452         
1453         BidiIterator end = start;
1454
1455         bool endLineMatched = false;
1456         while (!end.atEnd()) {
1457             start = end;
1458             if (endLine && (endLineMatched = matchedEndLine(start, cleanLineStart, endLine, endLineYPos)))
1459                 break;
1460
1461             betweenMidpoints = false;
1462             isLineEmpty = true;
1463             if (m_firstLine && firstChild() && firstChild()->isCompact() && firstChild()->isRenderBlock()) {
1464                 buildCompactRuns(firstChild(), bidi);
1465                 start.obj = firstChild()->nextSibling();
1466                 end = start;
1467             }
1468             end = findNextLineBreak(start, bidi);
1469             if( start.atEnd() ) break;
1470             if (!isLineEmpty) {
1471                 bidiReorderLine(start, end, bidi);
1472
1473                 // Now that the runs have been ordered, we create the line boxes.
1474                 // At the same time we figure out where border/padding/margin should be applied for
1475                 // inline flow boxes.
1476                 if (sCompactFirstBidiRun) {
1477                     // We have a compact line sharing this line.  Link the compact runs
1478                     // to our runs to create a single line of runs.
1479                     sCompactLastBidiRun->nextRun = sFirstBidiRun;
1480                     sFirstBidiRun = sCompactFirstBidiRun;
1481                     sBidiRunCount += sCompactBidiRunCount;
1482                 }
1483
1484                 RootInlineBox* lineBox = 0;
1485                 if (sBidiRunCount) {
1486                     lineBox = constructLine(start, end);
1487                     if (lineBox) {
1488                         lineBox->setEndsWithBreak(previousLineBrokeCleanly);
1489                         
1490                         // Now we position all of our text runs horizontally.
1491                         computeHorizontalPositionsForLine(lineBox, bidi);
1492         
1493                         // Now position our text runs vertically.
1494                         computeVerticalPositionsForLine(lineBox);
1495         
1496                         deleteBidiRuns(renderArena());
1497                     }
1498                 }
1499                 
1500                 if (end == start || (!previousLineBrokeCleanly && end.obj && end.obj->style()->whiteSpace() == PRE && end.current() == QChar('\n'))) {
1501                     adjustEmbedding = true;
1502                     end.increment(bidi);
1503                     adjustEmbedding = false;
1504                 }
1505
1506                 if (lineBox)
1507                     lineBox->setLineBreakInfo(end.obj, end.pos);
1508                 
1509                 m_firstLine = false;
1510                 newLine();
1511             }
1512              
1513             sNumMidpoints = 0;
1514             sCurrMidpoint = 0;
1515             sCompactFirstBidiRun = sCompactLastBidiRun = 0;
1516             sCompactBidiRunCount = 0;
1517         }
1518         startEmbed->deref();
1519         //embed->deref();
1520         
1521         if (endLine) {
1522             if (endLineMatched) {
1523                 // Attach all the remaining lines, and then adjust their y-positions as needed.
1524                 for (RootInlineBox* line = endLine; line; line = line->nextRootBox())
1525                     line->attachLine();
1526                 
1527                 // Now apply the offset to each line if needed.
1528                 int delta = m_height - endLineYPos;
1529                 if (delta)
1530                     for (RootInlineBox* line = endLine; line; line = line->nextRootBox())
1531                         line->adjustPosition(0, delta);
1532
1533                 // Now set our height and check for overflow.
1534                 int currYPos = m_height;
1535                 m_height = lastRootBox()->blockHeight();
1536                 m_overflowHeight = kMax(m_height, m_overflowHeight);
1537                 int bottomOfLine = lastRootBox()->bottomOverflow();
1538                 if (bottomOfLine > m_height && bottomOfLine > m_overflowHeight)
1539                     m_overflowHeight = bottomOfLine;
1540                 if (delta)
1541                     repaintRect.setHeight(kMax(m_overflowHeight-delta, m_overflowHeight) - repaintRect.y());
1542                 else
1543                     repaintRect.setHeight(currYPos - repaintRect.y());
1544             }
1545             else {
1546                 // Delete all the remaining lines.
1547                 m_overflowHeight = kMax(m_height, m_overflowHeight);
1548                 InlineRunBox* line = endLine;
1549                 RenderArena* arena = renderArena();
1550                 while (line) {
1551                     InlineRunBox* next = line->nextLineBox();
1552                     if (!next)
1553                         repaintRect.setHeight(kMax(m_overflowHeight, line->bottomOverflow()) - repaintRect.y());
1554                     line->deleteLine(arena);
1555                     line = next;
1556                 }
1557             }
1558         }
1559     }
1560
1561     sNumMidpoints = 0;
1562     sCurrMidpoint = 0;
1563
1564     // in case we have a float on the last line, it might not be positioned up to now.
1565     // This has to be done before adding in the bottom border/padding, or the float will
1566     // include the padding incorrectly. -dwh
1567     positionNewFloats();
1568     
1569     // Now add in the bottom border/padding.
1570     m_height += toAdd;
1571
1572     // Always make sure this is at least our height.
1573     m_overflowHeight = kMax(m_height, m_overflowHeight);
1574     
1575     if (useRepaintRect) {
1576         repaintRect.setWidth(kMax((int)m_width, m_overflowWidth));
1577         if (repaintRect.height() == 0)
1578             repaintRect.setHeight(m_overflowHeight - repaintRect.y());
1579     }
1580     
1581     setLinesAppended(false);
1582     
1583     if (!firstLineBox() && element() && element()->isContentEditable() && element()->rootEditableElement() == element()) {
1584         m_height += lineHeight(true);
1585     }
1586
1587     // See if we have any lines that spill out of our block.  If we do, then we will possibly need to
1588     // truncate text.
1589     if (hasTextOverflow)
1590         checkLinesForTextOverflow();
1591
1592     return repaintRect;
1593
1594 #if BIDI_DEBUG > 1
1595     kdDebug(6041) << " ------- bidi end " << this << " -------" << endl;
1596 #endif
1597     //kdDebug() << "RenderBlock::layoutInlineChildren time used " << qt.elapsed() << endl;
1598     //kdDebug(6040) << "height = " << m_height <<endl;
1599 }
1600
1601 RootInlineBox* RenderBlock::determineStartPosition(bool fullLayout, BidiIterator& start, BidiState& bidi)
1602 {
1603     RootInlineBox* curr = 0;
1604     RootInlineBox* last = 0;
1605     RenderObject* startObj = 0;
1606     int pos = 0;
1607     
1608     if (fullLayout) {
1609         // Nuke all our lines.
1610         if (firstRootBox()) {
1611             RenderArena* arena = renderArena();
1612             curr = firstRootBox(); 
1613             while (curr) {
1614                 RootInlineBox* next = curr->nextRootBox();
1615                 curr->deleteLine(arena);
1616                 curr = next;
1617             }
1618             KHTMLAssert(!m_firstLineBox && !m_lastLineBox);
1619         }
1620     }
1621     else {
1622         for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox());
1623         if (curr) {
1624             // We have a dirty line.
1625             if (curr->prevRootBox()) {
1626                 // We have a previous line.
1627                 if (!curr->prevRootBox()->endsWithBreak())
1628                     curr = curr->prevRootBox();  // The previous line didn't break cleanly, so treat it as dirty also.
1629             }
1630         }
1631         else {
1632             // No dirty lines were found.
1633             // If the last line didn't break cleanly, treat it as dirty.
1634             if (lastRootBox() && !lastRootBox()->endsWithBreak())
1635                 curr = lastRootBox();
1636         }
1637         
1638         // If we have no dirty lines, then last is just the last root box.
1639         last = curr ? curr->prevRootBox() : lastRootBox();
1640     }
1641     
1642     m_firstLine = !last;
1643     previousLineBrokeCleanly = !last || last->endsWithBreak();
1644     if (last) {
1645         m_height = last->blockHeight();
1646         int bottomOfLine = last->bottomOverflow();
1647         if (bottomOfLine > m_height && bottomOfLine > m_overflowHeight)
1648             m_overflowHeight = bottomOfLine;
1649         startObj = last->lineBreakObj();
1650         pos = last->lineBreakPos();
1651     }
1652     else
1653         startObj = first(this, bidi, 0);
1654         
1655     adjustEmbedding = true;
1656     start = BidiIterator(this, startObj, pos);
1657     adjustEmbedding = false;
1658     
1659     return curr;
1660 }
1661
1662 RootInlineBox* RenderBlock::determineEndPosition(RootInlineBox* startLine, BidiIterator& cleanLineStart,
1663                                                  int& yPos)
1664 {
1665     RootInlineBox* last = 0;
1666     if (m_linesAppended || !startLine)
1667         last = 0;
1668     else {
1669         for (RootInlineBox* curr = startLine->nextRootBox(); curr; curr = curr->nextRootBox()) {
1670             if (curr->isDirty())
1671                 last = 0;
1672             else if (!last)
1673                 last = curr;
1674         }
1675     }
1676     
1677     if (!last)
1678         return 0;
1679     
1680     cleanLineStart = BidiIterator(this, last->prevRootBox()->lineBreakObj(), last->prevRootBox()->lineBreakPos());
1681     yPos = last->prevRootBox()->blockHeight();
1682     
1683     for (RootInlineBox* line = last; line; line = line->nextRootBox())
1684         line->extractLine(); // Disconnect all line boxes from their render objects while preserving
1685                              // their connections to one another.
1686     
1687     return last;
1688 }
1689
1690 bool RenderBlock::matchedEndLine(const BidiIterator& start, const BidiIterator& endLineStart, 
1691                                  RootInlineBox*& endLine, int& endYPos)
1692 {
1693     if (start == endLineStart)
1694         return true; // The common case. All the data we already have is correct.
1695     else {
1696         // The first clean line doesn't match, but we can check a handful of following lines to try
1697         // to match back up.
1698         static int numLines = 8; // The # of lines we're willing to match against.
1699         RootInlineBox* line = endLine;
1700         for (int i = 0; i < numLines && line; i++, line = line->nextRootBox()) {
1701             if (line->lineBreakObj() == start.obj && line->lineBreakPos() == start.pos) {
1702                 // We have a match.
1703                 RootInlineBox* result = line->nextRootBox();
1704                                 
1705                 // Set our yPos to be the block height of endLine.
1706                 if (result)
1707                     endYPos = line->blockHeight();
1708                 
1709                 // Now delete the lines that we failed to sync.
1710                 RootInlineBox* boxToDelete = endLine;
1711                 RenderArena* arena = renderArena();
1712                 while (boxToDelete && boxToDelete != result) {
1713                     RootInlineBox* next = boxToDelete->nextRootBox();
1714                     boxToDelete->deleteLine(arena);
1715                     boxToDelete = next;
1716                 }
1717
1718                 endLine = result;
1719                 return result;
1720             }
1721         }
1722     }
1723     return false;
1724 }
1725
1726 BidiIterator RenderBlock::findNextLineBreak(BidiIterator &start, BidiState &bidi)
1727 {
1728     int width = lineWidth(m_height);
1729     int w = 0;
1730     int tmpW = 0;
1731 #ifdef DEBUG_LINEBREAKS
1732     kdDebug(6041) << "findNextLineBreak: line at " << m_height << " line width " << width << endl;
1733     kdDebug(6041) << "sol: " << start.obj << " " << start.pos << endl;
1734 #endif
1735
1736     // eliminate spaces at beginning of line
1737     // remove leading spaces.  Any inline flows we encounter will be empty and should also
1738     // be skipped.
1739     while (!start.atEnd() && (start.obj->isInlineFlow() || (start.obj->style()->whiteSpace() != PRE && !start.obj->isBR() &&
1740           (start.current() == ' ' || start.current() == '\n' || start.obj->isFloatingOrPositioned())))) {
1741         if( start.obj->isFloatingOrPositioned() ) {
1742             RenderObject *o = start.obj;
1743             // add to special objects...
1744             if (o->isFloating()) {
1745                 insertFloatingObject(o);
1746                 positionNewFloats();
1747                 width = lineWidth(m_height);
1748             }
1749             else if (o->isPositioned()) {
1750                 if (o->hasStaticX())
1751                     o->setStaticX(style()->direction() == LTR ?
1752                                   borderLeft()+paddingLeft() :
1753                                   borderRight()+paddingRight());
1754                 if (o->hasStaticY())
1755                     o->setStaticY(m_height);
1756             }
1757         }
1758         
1759         adjustEmbedding = true;
1760         start.increment(bidi);
1761         adjustEmbedding = false;
1762     }
1763     
1764     if ( start.atEnd() ){
1765         return start;
1766     }
1767
1768     // This variable is used only if whitespace isn't set to PRE, and it tells us whether
1769     // or not we are currently ignoring whitespace.
1770     bool ignoringSpaces = false;
1771     BidiIterator ignoreStart;
1772     
1773     // This variable tracks whether the very last character we saw was a space.  We use
1774     // this to detect when we encounter a second space so we know we have to terminate
1775     // a run.
1776     bool currentCharacterIsSpace = false;
1777     RenderObject* trailingSpaceObject = 0;
1778
1779     BidiIterator lBreak = start;
1780
1781     RenderObject *o = start.obj;
1782     RenderObject *last = o;
1783     int pos = start.pos;
1784
1785     bool prevLineBrokeCleanly = previousLineBrokeCleanly;
1786     previousLineBrokeCleanly = false;
1787     
1788     while( o ) {
1789 #ifdef DEBUG_LINEBREAKS
1790         kdDebug(6041) << "new object "<< o <<" width = " << w <<" tmpw = " << tmpW << endl;
1791 #endif
1792         if(o->isBR()) {
1793             if (w + tmpW <= width) {
1794                 lBreak.obj = o;
1795                 lBreak.pos = 0;
1796                 lBreak.increment(bidi);
1797
1798                 // A <br> always breaks a line, so don't let the line be collapsed
1799                 // away. Also, the space at the end of a line with a <br> does not
1800                 // get collapsed away.  It only does this if the previous line broke
1801                 // cleanly.  Otherwise the <br> has no effect on whether the line is
1802                 // empty or not.
1803                 if (prevLineBrokeCleanly)
1804                     isLineEmpty = false;
1805                 trailingSpaceObject = 0;
1806                 previousLineBrokeCleanly = true;
1807
1808                 if (!isLineEmpty) {
1809                     // only check the clear status for non-empty lines.
1810                     EClear clear = o->style()->clear();
1811                     if(clear != CNONE)
1812                         m_clearStatus = (EClear) (m_clearStatus | clear);
1813                 }
1814             }
1815             goto end;
1816         }
1817         if( o->isFloatingOrPositioned() ) {
1818             // add to special objects...
1819             if(o->isFloating()) {
1820                 insertFloatingObject(o);
1821                 // check if it fits in the current line.
1822                 // If it does, position it now, otherwise, position
1823                 // it after moving to next line (in newLine() func)
1824                 if (o->width()+o->marginLeft()+o->marginRight()+w+tmpW <= width) {
1825                     positionNewFloats();
1826                     width = lineWidth(m_height);
1827                 }
1828             }
1829             else if (o->isPositioned()) {
1830                 // If our original display wasn't an inline type, then we can
1831                 // go ahead and determine our static x position now.
1832                 bool isInlineType = o->style()->isOriginalDisplayInlineType();
1833                 bool needToSetStaticX = o->hasStaticX();
1834                 if (o->hasStaticX() && !isInlineType) {
1835                     o->setStaticX(o->parent()->style()->direction() == LTR ?
1836                                   borderLeft()+paddingLeft() :
1837                                   borderRight()+paddingRight());
1838                     needToSetStaticX = false;
1839                 }
1840
1841                 // If our original display was an INLINE type, then we can go ahead
1842                 // and determine our static y position now.
1843                 bool needToSetStaticY = o->hasStaticY();
1844                 if (o->hasStaticY() && isInlineType) {
1845                     o->setStaticY(m_height);
1846                     needToSetStaticY = false;
1847                 }
1848                 
1849                 // If we're ignoring spaces, we have to stop and include this object and
1850                 // then start ignoring spaces again.
1851                 if (needToSetStaticX || needToSetStaticY) {
1852                     trailingSpaceObject = 0;
1853                     ignoreStart.obj = o;
1854                     ignoreStart.pos = 0;
1855                     if (ignoringSpaces) {
1856                         addMidpoint(ignoreStart); // Stop ignoring spaces.
1857                         addMidpoint(ignoreStart); // Start ignoring again.
1858                     }
1859                     
1860                 }
1861             }
1862         } else if (o->isInlineFlow()) {
1863             // Only empty inlines matter.  We treat those similarly to replaced elements.
1864             KHTMLAssert(!o->firstChild());
1865             tmpW += o->marginLeft()+o->borderLeft()+o->paddingLeft()+
1866                     o->marginRight()+o->borderRight()+o->paddingRight();
1867         } else if ( o->isReplaced() ) {
1868             EWhiteSpace currWS = o->style()->whiteSpace();
1869             EWhiteSpace lastWS = last->style()->whiteSpace();
1870             
1871             // WinIE marquees have different whitespace characteristics by default when viewed from
1872             // the outside vs. the inside.  Text inside is NOWRAP, and so we altered the marquee's
1873             // style to reflect this, but we now have to get back to the original whitespace value
1874             // for the marquee when checking for line breaking.
1875             if (o->isHTMLMarquee() && o->layer() && o->layer()->marquee())
1876                 currWS = o->layer()->marquee()->whiteSpace();
1877             if (last->isHTMLMarquee() && last->layer() && last->layer()->marquee())
1878                 lastWS = last->layer()->marquee()->whiteSpace();
1879             
1880             // Break on replaced elements if either has normal white-space.
1881             // FIXME: This does not match WinIE, Opera, and Mozilla.  They treat replaced elements
1882             // like characters in a word, and require spaces between the replaced elements in order
1883             // to break.
1884             if (currWS == NORMAL || lastWS == NORMAL) {
1885                 w += tmpW;
1886                 tmpW = 0;
1887                 lBreak.obj = o;
1888                 lBreak.pos = 0;
1889             }
1890
1891             tmpW += o->width()+o->marginLeft()+o->marginRight()+inlineWidth(o);
1892             if (ignoringSpaces) {
1893                 BidiIterator startMid( 0, o, 0 );
1894                 addMidpoint(startMid);
1895             }
1896             isLineEmpty = false;
1897             ignoringSpaces = false;
1898             currentCharacterIsSpace = false;
1899             trailingSpaceObject = 0;
1900             
1901             if (o->isListMarker() && o->style()->listStylePosition() == OUTSIDE) {
1902                 // The marker must not have an effect on whitespace at the start
1903                 // of the line.  We start ignoring spaces to make sure that any additional
1904                 // spaces we see will be discarded. 
1905                 //
1906                 // Optimize for a common case. If we can't find whitespace after the list
1907                 // item, then this is all moot. -dwh
1908                 RenderObject* next = Bidinext( start.par, o, bidi );
1909                 if (!m_pre && next && next->isText() && static_cast<RenderText*>(next)->stringLength() > 0 &&
1910                       (static_cast<RenderText*>(next)->text()[0].unicode() == ' ' ||
1911                       static_cast<RenderText*>(next)->text()[0] == '\n')) {
1912                     currentCharacterIsSpace = true;
1913                     ignoringSpaces = true;
1914                     BidiIterator endMid( 0, o, 0 );
1915                     addMidpoint(endMid);
1916                 }
1917             }
1918         } else if ( o->isText() ) {
1919             RenderText *t = static_cast<RenderText *>(o);
1920             int strlen = t->stringLength();
1921             int len = strlen - pos;
1922             QChar *str = t->text();
1923
1924             const Font *f = t->htmlFont( m_firstLine );
1925             // proportional font, needs a bit more work.
1926             int lastSpace = pos;
1927             bool isPre = o->style()->whiteSpace() == PRE;
1928             int wordSpacing = o->style()->wordSpacing();
1929
1930             bool appliedStartWidth = pos > 0; // If the span originated on a previous line,
1931                                               // then assume the start width has been applied.
1932             bool appliedEndWidth = false;
1933
1934             int wrapW = tmpW;
1935             
1936             while(len) {
1937                 bool previousCharacterIsSpace = currentCharacterIsSpace;
1938                 const QChar c = str[pos];
1939                 currentCharacterIsSpace = c == ' ' || (!isPre && c == '\n');
1940                 
1941                 if (isPre || !currentCharacterIsSpace)
1942                     isLineEmpty = false;
1943                 
1944                 // Check for soft hyphens.  Go ahead and ignore them.
1945                 if (c.unicode() == SOFT_HYPHEN && pos > 0) {
1946                     if (!ignoringSpaces) {
1947                         // Ignore soft hyphens
1948                         BidiIterator endMid(0, o, pos-1);
1949                         addMidpoint(endMid);
1950                         
1951                         // Add the width up to but not including the hyphen.
1952                         tmpW += t->width(lastSpace, pos - lastSpace, f);
1953                         
1954                         // For whitespace normal only, include the hyphen.  We need to ensure it will fit
1955                         // on the line if it shows when we break.
1956                         if (o->style()->whiteSpace() == NORMAL)
1957                             tmpW += t->width(pos, 1, f);
1958                         
1959                         BidiIterator startMid(0, o, pos+1);
1960                         addMidpoint(startMid);
1961                     }
1962                     
1963                     pos++;
1964                     len--;
1965                     lastSpace = pos; // Cheesy hack to prevent adding in widths of the run twice.
1966                     continue;
1967                 }
1968                 
1969                 bool applyWordSpacing = false;
1970
1971                 bool breakWords = w == 0 && o->style()->whiteSpace() == NORMAL && o->style()->wordWrap() == BREAK_WORD;
1972                 if (breakWords)
1973                     wrapW += t->width(pos, 1, f);
1974                 if ((isPre && c == '\n') || (!isPre && isBreakable(str, pos, strlen)) || (breakWords && wrapW > width)) {
1975                     if (ignoringSpaces) {
1976                         if (!currentCharacterIsSpace) {
1977                             // Stop ignoring spaces and begin at this
1978                             // new point.
1979                             ignoringSpaces = false;
1980                             lastSpace = pos; // e.g., "Foo    goo", don't add in any of the ignored spaces.
1981                             BidiIterator startMid ( 0, o, pos );
1982                             addMidpoint(startMid);
1983                         }
1984                         else {
1985                             // Just keep ignoring these spaces.
1986                             pos++;
1987                             len--;
1988                             continue;
1989                         }
1990                     }
1991
1992                     tmpW += t->width(lastSpace, pos - lastSpace, f);
1993                     if (!appliedStartWidth) {
1994                         tmpW += inlineWidth(o, true, false);
1995                         appliedStartWidth = true;
1996                     }
1997                     
1998                     applyWordSpacing = (wordSpacing && currentCharacterIsSpace && !previousCharacterIsSpace &&
1999                         !t->containsOnlyWhitespace(pos+1, strlen-(pos+1)));
2000
2001 #ifdef DEBUG_LINEBREAKS
2002                     kdDebug(6041) << "found space at " << pos << " in string '" << QString( str, strlen ).latin1() << "' adding " << tmpW << " new width = " << w << endl;
2003 #endif
2004                     if ( !isPre && w + tmpW > width && w == 0 ) {
2005                         int fb = nearestFloatBottom(m_height);
2006                         int newLineWidth = lineWidth(fb);
2007                         // See if |tmpW| will fit on the new line.  As long as it does not,
2008                         // keep adjusting our float bottom until we find some room.
2009                         int lastFloatBottom = m_height;
2010                         while (lastFloatBottom < fb && tmpW > newLineWidth) {
2011                             lastFloatBottom = fb;
2012                             fb = nearestFloatBottom(fb);
2013                             newLineWidth = lineWidth(fb);
2014                         }
2015                         
2016                         if(!w && m_height < fb && width < newLineWidth) {
2017                             m_height = fb;
2018                             width = newLineWidth;
2019 #ifdef DEBUG_LINEBREAKS
2020                             kdDebug() << "RenderBlock::findNextLineBreak new position at " << m_height << " newWidth " << width << endl;
2021 #endif
2022                         }
2023                     }
2024         
2025                     if (o->style()->whiteSpace() == NORMAL) {
2026                         if (w + tmpW > width)
2027                             goto end; // Didn't fit. Jump to the end.
2028                         else if (pos > 1 && str[pos-1].unicode() == SOFT_HYPHEN)
2029                             // Subtract the width of the soft hyphen out since we fit on a line.
2030                             tmpW -= t->width(pos-1, 1, f);
2031                     }
2032
2033                     if( *(str+pos) == '\n' && isPre) {
2034                         lBreak.obj = o;
2035                         lBreak.pos = pos;
2036
2037 #ifdef DEBUG_LINEBREAKS
2038                         kdDebug(6041) << "forced break sol: " << start.obj << " " << start.pos << "   end: " << lBreak.obj << " " << lBreak.pos << "   width=" << w << endl;
2039 #endif
2040                         return lBreak;
2041                     }
2042
2043                     if (o->style()->whiteSpace() == NORMAL) {
2044                         w += tmpW;
2045                         tmpW = 0;
2046                         lBreak.obj = o;
2047                         lBreak.pos = pos;
2048                     }
2049                     
2050                     lastSpace = pos;
2051                     
2052                     if (applyWordSpacing)
2053                         w += wordSpacing;
2054                         
2055                     if (!ignoringSpaces && !isPre) {
2056                         // If we encounter a newline, or if we encounter a
2057                         // second space, we need to go ahead and break up this
2058                         // run and enter a mode where we start collapsing spaces.
2059                         if (currentCharacterIsSpace && previousCharacterIsSpace) {
2060                             ignoringSpaces = true;
2061                             
2062                             // We just entered a mode where we are ignoring
2063                             // spaces. Create a midpoint to terminate the run
2064                             // before the second space. 
2065                             addMidpoint(ignoreStart);
2066                             lastSpace = pos;
2067                         }
2068                     }
2069                 }
2070                 else if (ignoringSpaces) {
2071                     // Stop ignoring spaces and begin at this
2072                     // new point.
2073                     ignoringSpaces = false;
2074                     lastSpace = pos; // e.g., "Foo    goo", don't add in any of the ignored spaces.
2075                     BidiIterator startMid ( 0, o, pos );
2076                     addMidpoint(startMid);
2077                 }
2078
2079                 if (currentCharacterIsSpace && !previousCharacterIsSpace) {
2080                     ignoreStart.obj = o;
2081                     ignoreStart.pos = pos;
2082                 }
2083                 
2084                 if (!isPre && currentCharacterIsSpace && !ignoringSpaces)
2085                     trailingSpaceObject = o;
2086                 else if (isPre || !currentCharacterIsSpace)
2087                     trailingSpaceObject = 0;
2088                     
2089                 pos++;
2090                 len--;
2091             }
2092             
2093             // IMPORTANT: pos is > length here!
2094             if (!ignoringSpaces)
2095                 tmpW += t->width(lastSpace, pos - lastSpace, f);
2096             if (!appliedStartWidth)
2097                 tmpW += inlineWidth(o, true, false);
2098             if (!appliedEndWidth)
2099                 tmpW += inlineWidth(o, false, true);
2100         } else
2101             KHTMLAssert( false );
2102
2103         RenderObject* next = Bidinext(start.par, o, bidi);
2104         bool isNormal = o->style()->whiteSpace() == NORMAL;
2105         bool checkForBreak = isNormal;
2106         if (w && w + tmpW > width+1 && lBreak.obj && o->style()->whiteSpace() == NOWRAP)
2107             checkForBreak = true;
2108         else if (next && o->isText() && next->isText() && !next->isBR()) {
2109             if (isNormal || (next->style()->whiteSpace() == NORMAL)) {
2110                 if (currentCharacterIsSpace)
2111                     checkForBreak = true;
2112                 else {
2113                     RenderText* nextText = static_cast<RenderText*>(next);
2114                     int strlen = nextText->stringLength();
2115                     QChar *str = nextText->text();
2116                     if (strlen &&
2117                         ((str[0].unicode() == ' ') ||
2118                             (next->style()->whiteSpace() != PRE && str[0] == '\n')))
2119                         // If the next item on the line is text, and if we did not end with
2120                         // a space, then the next text run continues our word (and so it needs to
2121                         // keep adding to |tmpW|.  Just update and continue.
2122                         checkForBreak = true;
2123                     else
2124                         checkForBreak = false;
2125
2126                     bool canPlaceOnLine = (w + tmpW <= width+1) || !isNormal;
2127                     if (canPlaceOnLine && checkForBreak) {
2128                         w += tmpW;
2129                         tmpW = 0;
2130                         lBreak.obj = next;
2131                         lBreak.pos = 0;
2132                     }
2133                 }
2134             }
2135         }
2136
2137         if (checkForBreak && (w + tmpW > width+1)) {
2138             //kdDebug() << " too wide w=" << w << " tmpW = " << tmpW << " width = " << width << endl;
2139             //kdDebug() << "start=" << start.obj << " current=" << o << endl;
2140             // if we have floats, try to get below them.
2141             if (currentCharacterIsSpace && !ignoringSpaces && o->style()->whiteSpace() != PRE)
2142                 trailingSpaceObject = 0;
2143             
2144             int fb = nearestFloatBottom(m_height);
2145             int newLineWidth = lineWidth(fb);
2146             // See if |tmpW| will fit on the new line.  As long as it does not,
2147             // keep adjusting our float bottom until we find some room.
2148             int lastFloatBottom = m_height;
2149             while (lastFloatBottom < fb && tmpW > newLineWidth) {
2150                 lastFloatBottom = fb;
2151                 fb = nearestFloatBottom(fb);
2152                 newLineWidth = lineWidth(fb);
2153             }            
2154             if( !w && m_height < fb && width < newLineWidth ) {
2155                 m_height = fb;
2156                 width = newLineWidth;
2157 #ifdef DEBUG_LINEBREAKS
2158                 kdDebug() << "RenderBlock::findNextLineBreak new position at " << m_height << " newWidth " << width << endl;
2159 #endif
2160             }
2161
2162             // |width| may have been adjusted because we got shoved down past a float (thus
2163             // giving us more room), so we need to retest, and only jump to
2164             // the end label if we still don't fit on the line. -dwh
2165             if (w + tmpW > width+1)
2166                 goto end;
2167         }
2168
2169         last = o;
2170         o = next;
2171
2172         if (!last->isFloatingOrPositioned() && last->isReplaced() && last->style()->whiteSpace() == NORMAL) {
2173             // Go ahead and add in tmpW.
2174             w += tmpW;
2175             tmpW = 0;
2176             lBreak.obj = o;
2177             lBreak.pos = 0;
2178         }
2179
2180         // Clear out our character space bool, since inline <pre>s don't collapse whitespace
2181         // with adjacent inline normal/nowrap spans.
2182         if (last->style()->whiteSpace() == PRE)
2183             currentCharacterIsSpace = false;
2184         
2185         pos = 0;
2186     }
2187
2188 #ifdef DEBUG_LINEBREAKS
2189     kdDebug( 6041 ) << "end of par, width = " << width << " linewidth = " << w + tmpW << endl;
2190 #endif
2191     if( w + tmpW <= width || (last && last->style()->whiteSpace() == NOWRAP)) {
2192         lBreak.obj = 0;
2193         lBreak.pos = 0;
2194     }
2195
2196  end:
2197
2198     if( lBreak == start && !lBreak.obj->isBR() ) {
2199         // we just add as much as possible
2200         if ( m_pre ) {
2201             if(pos != 0) {
2202                 lBreak.obj = o;
2203                 lBreak.pos = pos - 1;
2204             } else {
2205                 lBreak.obj = last;
2206                 lBreak.pos = last->isText() ? last->length() : 0;
2207             }
2208         } else if( lBreak.obj ) {
2209             if( last != o ) {
2210                 // better to break between object boundaries than in the middle of a word
2211                 lBreak.obj = o;
2212                 lBreak.pos = 0;
2213             } else {
2214                 // Don't ever break in the middle of a word if we can help it.
2215                 // There's no room at all. We just have to be on this line,
2216                 // even though we'll spill out.
2217                 lBreak.obj = o;
2218                 lBreak.pos = pos;
2219             }
2220         }
2221     }
2222
2223     // make sure we consume at least one char/object.
2224     if( lBreak == start )
2225         lBreak.increment(bidi);
2226     
2227 #ifdef DEBUG_LINEBREAKS
2228     kdDebug(6041) << "regular break sol: " << start.obj << " " << start.pos << "   end: " << lBreak.obj << " " << lBreak.pos << "   width=" << w << endl;
2229 #endif
2230
2231     // Sanity check our midpoints.
2232     checkMidpoints(lBreak, bidi);
2233         
2234     if (trailingSpaceObject) {
2235         // This object is either going to be part of the last midpoint, or it is going
2236         // to be the actual endpoint.  In both cases we just decrease our pos by 1 level to
2237         // exclude the space, allowing it to - in effect - collapse into the newline.
2238         if (sNumMidpoints%2==1) {
2239             BidiIterator* midpoints = smidpoints->data();
2240             midpoints[sNumMidpoints-1].pos--;
2241         }
2242         //else if (lBreak.pos > 0)
2243         //    lBreak.pos--;
2244         else if (lBreak.obj == 0 && trailingSpaceObject->isText()) {
2245             // Add a new end midpoint that stops right at the very end.
2246             RenderText* text = static_cast<RenderText *>(trailingSpaceObject);
2247             unsigned pos = text->length() >=2 ? text->length() - 2 : UINT_MAX;
2248             BidiIterator endMid ( 0, trailingSpaceObject, pos );
2249             addMidpoint(endMid);
2250         }
2251     }
2252
2253     // We might have made lBreak an iterator that points past the end
2254     // of the object. Do this adjustment to make it point to the start
2255     // of the next object instead to avoid confusing the rest of the
2256     // code.
2257     if (lBreak.pos > 0) {
2258         lBreak.pos--;
2259         lBreak.increment(bidi);
2260     }
2261
2262     if (lBreak.obj && lBreak.pos >= 2 && lBreak.obj->isText()) {
2263         // For soft hyphens on line breaks, we have to chop out the midpoints that made us
2264         // ignore the hyphen so that it will render at the end of the line.
2265         QChar c = static_cast<RenderText*>(lBreak.obj)->text()[lBreak.pos-1];
2266         if (c.unicode() == SOFT_HYPHEN)
2267             chopMidpointsAt(lBreak.obj, lBreak.pos-2);
2268     }
2269     
2270     return lBreak;
2271 }
2272
2273 void RenderBlock::deleteEllipsisLineBoxes()
2274 {
2275     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox())
2276         curr->clearTruncation();
2277 }
2278
2279 void RenderBlock::checkLinesForTextOverflow()
2280 {
2281     // Determine the width of the ellipsis using the current font.
2282     QChar ellipsis = 0x2026; // FIXME: CSS3 says this is configurable, also need to use 0x002E (FULL STOP) if 0x2026 not renderable
2283     static AtomicString ellipsisStr(ellipsis);
2284     const Font& firstLineFont = style(true)->htmlFont();
2285     const Font& font = style()->htmlFont();
2286     int firstLineEllipsisWidth = firstLineFont.width(&ellipsis, 1, 0);
2287     int ellipsisWidth = (font == firstLineFont) ? firstLineEllipsisWidth : font.width(&ellipsis, 1, 0);
2288
2289     // For LTR text truncation, we want to get the right edge of our padding box, and then we want to see
2290     // if the right edge of a line box exceeds that.  For RTL, we use the left edge of the padding box and
2291     // check the left edge of the line box to see if it is less
2292     // Include the scrollbar for overflow blocks, which means we want to use "contentWidth()"
2293     bool ltr = style()->direction() == LTR;
2294     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
2295         int blockEdge = ltr ? rightOffset(curr->yPos()) : leftOffset(curr->yPos());
2296         int lineBoxEdge = ltr ? curr->xPos() + curr->width() : curr->xPos();
2297         if ((ltr && lineBoxEdge > blockEdge) || (!ltr && lineBoxEdge < blockEdge)) {
2298             // This line spills out of our box in the appropriate direction.  Now we need to see if the line
2299             // can be truncated.  In order for truncation to be possible, the line must have sufficient space to
2300             // accommodate our truncation string, and no replaced elements (images, tables) can overlap the ellipsis
2301             // space.
2302             int width = curr == firstRootBox() ? firstLineEllipsisWidth : ellipsisWidth;
2303             if (curr->canAccommodateEllipsis(ltr, blockEdge, lineBoxEdge, width))
2304                 curr->placeEllipsis(ellipsisStr, ltr, blockEdge, width);
2305         }
2306     }
2307 }
2308
2309 // For --enable-final
2310 #undef BIDI_DEBUG
2311 #undef DEBUG_LINEBREAKS
2312 #undef DEBUG_LAYOUT
2313
2314 }