Reviewed by Chris
[WebKit-https.git] / WebCore / khtml / rendering / render_box.cpp
1 /**
2  * This file is part of the DOM implementation for KDE.
3  *
4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
6  * Copyright (C) 2004 Apple Computer, Inc.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  *
23  */
24 // -------------------------------------------------------------------------
25 //#define DEBUG_LAYOUT
26
27
28 #include <qpainter.h>
29
30 #include "rendering/render_box.h"
31 #include "rendering/render_replaced.h"
32 #include "rendering/render_canvas.h"
33 #include "rendering/render_table.h"
34 #include "render_flexbox.h"
35 #include "render_arena.h"
36
37 #include "misc/htmlhashes.h"
38 #include "xml/dom_nodeimpl.h"
39 #include "xml/dom_docimpl.h"
40 #include "render_line.h"
41
42 #include <khtmlview.h>
43 #include <kdebug.h>
44 #include <assert.h>
45
46
47 using namespace DOM;
48 using namespace khtml;
49
50 #define TABLECELLMARGIN -0x4000
51
52 RenderBox::RenderBox(DOM::NodeImpl* node)
53     : RenderContainer(node)
54 {
55     m_minWidth = -1;
56     m_maxWidth = -1;
57     m_overrideSize = -1;
58     m_width = m_height = 0;
59     m_x = 0;
60     m_y = 0;
61     m_marginTop = 0;
62     m_marginBottom = 0;
63     m_marginLeft = 0;
64     m_marginRight = 0;
65     m_staticX = 0;
66     m_staticY = 0;
67     m_layer = 0;
68     m_inlineBoxWrapper = 0;
69 }
70
71 void RenderBox::setStyle(RenderStyle *_style)
72 {
73     RenderObject::setStyle(_style);
74
75     // The root always paints its background/border.
76     if (isRoot())
77         setShouldPaintBackgroundOrBorder(true);
78
79     setInline(_style->isDisplayInlineType());
80
81     switch(_style->position())
82     {
83     case ABSOLUTE:
84     case FIXED:
85         setPositioned(true);
86         break;
87     default:
88         setPositioned(false);
89
90         if (_style->isFloating())
91             setFloating(true);
92
93         if (_style->position() == RELATIVE)
94             setRelPositioned(true);
95     }
96
97     // FIXME: Note that we restrict overflow to blocks for now.  One day table bodies and cells 
98     // will need to support overflow.
99     // We also deal with the body scroll quirk here, since it sets the scrollbars for the document.
100     if (_style->overflow() != OVISIBLE && isBlockFlow() && !isTableCell() &&
101         (!document()->isHTMLDocument() || !isBody()))
102         setHasOverflowClip();
103
104     if (requiresLayer()) {
105         if (!m_layer) {
106             m_layer = new (renderArena()) RenderLayer(this);
107             m_layer->insertOnlyThisLayer();
108         }
109     }
110     else if (m_layer && !isRoot() && !isCanvas()) {
111         m_layer->removeOnlyThisLayer();
112         m_layer = 0;
113     }
114
115     if (m_layer)
116         m_layer->styleChanged();
117     
118     // Set the text color if we're the body.
119     if (isBody())
120         element()->getDocument()->setTextColor(_style->color());
121     
122     if (style()->outlineWidth() > 0 && style()->outlineSize() > maximalOutlineSize(PaintActionOutline))
123         static_cast<RenderCanvas*>(document()->renderer())->setMaximalOutlineSize(style()->outlineSize());
124 }
125
126 RenderBox::~RenderBox()
127 {
128     //kdDebug( 6040 ) << "Element destructor: this=" << nodeName().string() << endl;
129 }
130
131 void RenderBox::detach()
132 {
133     RenderLayer* layer = m_layer;
134     RenderArena* arena = renderArena();
135     
136     if (m_inlineBoxWrapper) {
137         if (!documentBeingDestroyed())
138             m_inlineBoxWrapper->remove();
139         m_inlineBoxWrapper->detach(arena);
140         m_inlineBoxWrapper = 0;
141     }
142
143     RenderContainer::detach();
144     
145     if (layer)
146         layer->detach(arena);
147 }
148
149 int RenderBox::contentWidth() const
150 {
151     int w = m_width - borderLeft() - borderRight();
152     w -= paddingLeft() + paddingRight();
153
154     if (includeScrollbarSize())
155         w -= m_layer->verticalScrollbarWidth();
156     
157     //kdDebug( 6040 ) << "RenderBox::contentWidth(2) = " << w << endl;
158     return w;
159 }
160
161 int RenderBox::contentHeight() const
162 {
163     int h = m_height - borderTop() - borderBottom();
164     h -= paddingTop() + paddingBottom();
165
166     if (includeScrollbarSize())
167         h -= m_layer->horizontalScrollbarHeight();
168
169     return h;
170 }
171
172 int RenderBox::overrideWidth() const
173 {
174     return m_overrideSize == -1 ? m_width : m_overrideSize;
175 }
176
177 int RenderBox::overrideHeight() const
178 {
179     return m_overrideSize == -1 ? m_height : m_overrideSize;
180 }
181
182 void RenderBox::setPos( int xPos, int yPos )
183 {
184     if (xPos == m_x && yPos == m_y)
185         return; // Optimize for the case where we don't move at all.
186     
187     m_x = xPos; m_y = yPos;
188 }
189
190 int RenderBox::width() const
191 {
192     return m_width;
193 }
194
195 int RenderBox::height() const
196 {
197     return m_height;
198 }
199
200
201 // --------------------- painting stuff -------------------------------
202
203 void RenderBox::paint(PaintInfo& i, int _tx, int _ty)
204 {
205     _tx += m_x;
206     _ty += m_y;
207
208     // default implementation. Just pass paint through to the children
209     for (RenderObject* child = firstChild(); child; child = child->nextSibling())
210         child->paint(i, _tx, _ty);
211 }
212
213 void RenderBox::paintRootBoxDecorations(PaintInfo& i, int _tx, int _ty)
214 {
215     //kdDebug( 6040 ) << renderName() << "::paintBoxDecorations()" << _tx << "/" << _ty << endl;
216     QColor c = style()->backgroundColor();
217     CachedImage *bg = style()->backgroundImage();
218
219     bool canBeTransparent = true;
220     if (!c.isValid() && !bg) {
221         // Locate the <body> element using the DOM.  This is easier than trying
222         // to crawl around a render tree with potential :before/:after content and
223         // anonymous blocks created by inline <body> tags etc.  We can locate the <body>
224         // render object very easily via the DOM.
225         RenderObject* bodyObject = 0;
226         for (DOM::NodeImpl* elt = element()->firstChild(); elt; elt = elt->nextSibling()) {
227             if (elt->id() == ID_BODY) {
228                 bodyObject = elt->renderer();
229                 break;
230             }
231             else if (elt->id() == ID_FRAMESET) {
232                 canBeTransparent = false; // Can't scroll a frameset document anyway.
233                 break;
234             }
235         }
236
237         if (bodyObject) {
238             c = bodyObject->style()->backgroundColor();
239             bg = bodyObject->style()->backgroundImage();
240         }
241     }
242
243     // Only fill with a base color (e.g., white) if we're the root document, since iframes/frames with
244     // no background in the child document should show the parent's background.
245     if ((!c.isValid() || qAlpha(c.rgb()) == 0) && canvas()->view()) {
246         bool isTransparent;
247         DOM::NodeImpl* elt = element()->getDocument()->ownerElement();
248         if (elt)
249             isTransparent = canBeTransparent && elt->id() != ID_FRAME; // Frames are never transparent.
250         else
251             isTransparent = canvas()->view()->isTransparent();
252
253         if (isTransparent)
254             canvas()->view()->useSlowRepaints(); // The parent must show behind the child.
255         else
256             c = canvas()->view()->palette().active().color(QColorGroup::Base);
257     }
258     
259     int w = width();
260     int h = height();
261
262     //    kdDebug(0) << "width = " << w <<endl;
263
264     int rw, rh;
265     if (canvas()->view()) {
266         rw = canvas()->view()->contentsWidth();
267         rh = canvas()->view()->contentsHeight();
268     }
269     else {
270         rw = canvas()->width();
271         rh = canvas()->height();
272     }
273     
274     //    kdDebug(0) << "rw = " << rw <<endl;
275
276     int bx = _tx - marginLeft();
277     int by = _ty - marginTop();
278     int bw = kMax(w + marginLeft() + marginRight() + borderLeft() + borderRight(), rw);
279     int bh = kMax(h + marginTop() + marginBottom() + borderTop() + borderBottom(), rh);
280
281     // CSS2 14.2:
282     // " The background of the box generated by the root element covers the entire canvas."
283     // hence, paint the background even in the margin areas (unlike for every other element!)
284     // I just love these little inconsistencies .. :-( (Dirk)
285     int my = kMax(by, i.r.y());
286
287     paintBackground(i.p, c, bg, my, i.r.height(), bx, by, bw, bh);
288
289     if (style()->hasBorder() && style()->display() != INLINE)
290         paintBorder( i.p, _tx, _ty, w, h, style() );
291 }
292
293 void RenderBox::paintBoxDecorations(PaintInfo& i, int _tx, int _ty)
294 {
295     if (!shouldPaintWithinRoot(i))
296         return;
297
298     //kdDebug( 6040 ) << renderName() << "::paintDecorations()" << endl;
299     if (isRoot())
300         return paintRootBoxDecorations(i, _tx, _ty);
301     
302     int w = width();
303     int h = height() + borderTopExtra() + borderBottomExtra();
304     _ty -= borderTopExtra();
305
306     int my = kMax(_ty, i.r.y());
307     int mh;
308     if (_ty < i.r.y())
309         mh= kMax(0, h - (i.r.y() - _ty));
310     else
311         mh = kMin(i.r.height(), h);
312
313     // The <body> only paints its background if the root element has defined a background
314     // independent of the body.  Go through the DOM to get to the root element's render object,
315     // since the root could be inline and wrapped in an anonymous block.
316     if (!isBody()
317         || element()->getDocument()->documentElement()->renderer()->style()->backgroundColor().isValid()
318         || element()->getDocument()->documentElement()->renderer()->style()->backgroundImage())
319         paintBackground(i.p, style()->backgroundColor(), style()->backgroundImage(), my, mh, _tx, _ty, w, h);
320    
321     if (style()->hasBorder())
322         paintBorder(i.p, _tx, _ty, w, h, style());
323 }
324
325 void RenderBox::paintBackground(QPainter *p, const QColor &c, CachedImage *bg, int clipy, int cliph, int _tx, int _ty, int w, int height)
326 {
327     paintBackgroundExtended(p, c, bg, clipy, cliph, _tx, _ty, w, height,
328                             borderLeft(), borderRight());
329 }
330
331 void RenderBox::paintBackgroundExtended(QPainter *p, const QColor &c, CachedImage *bg, int clipy, int cliph,
332                                         int _tx, int _ty, int w, int h,
333                                         int bleft, int bright)
334 {
335     if (c.isValid() && qAlpha(c.rgb()) > 0) {
336         // If we have an alpha and we are painting the root element, go ahead and blend with our default
337         // background color (typically white).
338         if (qAlpha(c.rgb()) < 0xFF && isRoot() && !canvas()->view()->isTransparent())
339             p->fillRect(_tx, clipy, w, cliph, canvas()->view()->palette().active().color(QColorGroup::Base));
340         p->fillRect(_tx, clipy, w, cliph, c);
341     }
342     
343     // no progressive loading of the background image
344     if(bg && bg->pixmap_size() == bg->valid_rect().size() && !bg->isTransparent() && !bg->isErrorImage()) {
345         //kdDebug( 6040 ) << "painting bgimage at " << _tx << "/" << _ty << endl;
346         // ### might need to add some correct offsets
347         // ### use paddingX/Y
348
349         // for propagation of <body> up to <html>
350         RenderStyle* sptr = style();
351         if ((isRoot() && element() && element()->id() == ID_HTML) && firstChild() && !style()->backgroundImage())
352             sptr = firstChild()->style();
353
354         int sx = 0;
355         int sy = 0;
356             int cw,ch;
357         int cx,cy;
358         int vpab = bleft + bright;
359         int hpab = borderTop() + borderBottom();
360         
361         // CSS2 chapter 14.2.1
362
363         if (sptr->backgroundAttachment())
364         {
365             //scroll
366             int pw = w - vpab;
367             int ph = h - hpab;
368             
369             int pixw = bg->pixmap_size().width();
370             int pixh = bg->pixmap_size().height();
371             EBackgroundRepeat bgr = sptr->backgroundRepeat();
372             if( (bgr == NO_REPEAT || bgr == REPEAT_Y) && w > pixw ) {
373                 cw = pixw;
374                 int xPosition = sptr->backgroundXPosition().minWidth(pw-pixw);
375                 if (xPosition >= 0)
376                     cx = _tx + xPosition;
377                 else {
378                     cx = _tx;
379                     if (pixw == 0)
380                         sx = 0;
381                     else {
382                         sx = -xPosition;
383                         cw += xPosition;
384                     }
385                 }
386                 cx += bleft;
387             } else {
388                 cw = w;
389                 cx = _tx;
390                 if (pixw == 0)
391                     sx = 0;
392                 else {
393                     sx =  pixw - ((sptr->backgroundXPosition().minWidth(pw-pixw)) % pixw );
394                     sx -= bleft % pixw;
395                 }
396             }
397
398             if( (bgr == NO_REPEAT || bgr == REPEAT_X) && h > pixh ) {
399                 ch = pixh;
400                 int yPosition = sptr->backgroundYPosition().minWidth(ph-pixh);
401                 if (yPosition >= 0)
402                     cy = _ty + yPosition;
403                 else {
404                     cy = _ty;
405                     if (pixh == 0)
406                         sy = 0;
407                     else {
408                         sy = -yPosition;
409                         ch += yPosition;
410                     }
411                 }
412                 
413                 cy += borderTop();
414             } else {
415                 ch = h;
416                 cy = _ty;
417                 if(pixh == 0){
418                     sy = 0;
419                 }else{
420                     sy = pixh - ((sptr->backgroundYPosition().minWidth(ph-pixh)) % pixh );
421                     sy -= borderTop() % pixh;
422                 }
423             }
424         }
425         else
426         {
427             //fixed
428             QRect vr = viewRect();
429             int pw = vr.width();
430             int ph = vr.height();
431
432             int pixw = bg->pixmap_size().width();
433             int pixh = bg->pixmap_size().height();
434             EBackgroundRepeat bgr = sptr->backgroundRepeat();
435             if( (bgr == NO_REPEAT || bgr == REPEAT_Y) && pw > pixw ) {
436                 cw = pixw;
437                 cx = vr.x() + sptr->backgroundXPosition().minWidth(pw-pixw);
438             } else {
439                 cw = pw;
440                 cx = vr.x();
441                 if(pixw == 0){
442                     sx = 0;
443                 }else{
444                     sx =  pixw - ((sptr->backgroundXPosition().minWidth(pw-pixw)) % pixw );
445                 }
446             }
447
448             if( (bgr == NO_REPEAT || bgr == REPEAT_X) && ph > pixh ) {
449                 ch = pixh;
450                 cy = vr.y() + sptr->backgroundYPosition().minWidth(ph-pixh);
451             } else {
452                 ch = ph;
453                 cy = vr.y();
454                 if(pixh == 0){
455                     sy = 0;
456                 }else{
457                     sy = pixh - ((sptr->backgroundYPosition().minWidth(ph-pixh)) % pixh );
458                 }
459             }
460
461             QRect fix(cx,cy,cw,ch);
462             QRect ele(_tx,_ty,w,h);
463             QRect b = fix.intersect(ele);
464             sx+=b.x()-cx;
465             sy+=b.y()-cy;
466             cx=b.x();cy=b.y();cw=b.width();ch=b.height();
467         }
468
469
470 //        kdDebug() << "cx="<<cx << " cy="<<cy<< " cw="<<cw << " ch="<<ch << " sx="<<sx << " sy="<<sy << endl;
471
472         if (cw>0 && ch>0)
473             p->drawTiledPixmap(cx, cy, cw, ch, bg->tiled_pixmap(c), sx, sy);
474     }
475 }
476
477 void RenderBox::outlineBox(QPainter *p, int _tx, int _ty, const char *color)
478 {
479     p->setPen(QPen(QColor(color), 1, Qt::DotLine));
480     p->setBrush( Qt::NoBrush );
481     p->drawRect(_tx, _ty, m_width, m_height);
482 }
483
484 QRect RenderBox::getOverflowClipRect(int tx, int ty)
485 {
486     // XXX When overflow-clip (CSS3) is implemented, we'll obtain the property
487     // here.
488     int bl=borderLeft(),bt=borderTop(),bb=borderBottom(),br=borderRight();
489     int clipx = tx+bl;
490     int clipy = ty+bt;
491     int clipw = m_width-bl-br;
492     int cliph = m_height-bt-bb;
493
494     // Subtract out scrollbars if we have them.
495     if (m_layer) {
496         clipw -= m_layer->verticalScrollbarWidth();
497         cliph -= m_layer->horizontalScrollbarHeight();
498     }
499     return QRect(clipx,clipy,clipw,cliph);
500 }
501
502 QRect RenderBox::getClipRect(int tx, int ty)
503 {
504     int clipx = tx;
505     int clipy = ty;
506     int clipw = m_width;
507     int cliph = m_height;
508
509     if (!style()->clipLeft().isVariable())
510     {
511         int c=style()->clipLeft().width(m_width);
512         clipx+=c;
513         clipw-=c;
514     }
515         
516     if (!style()->clipRight().isVariable())
517     {
518         int w = style()->clipRight().width(m_width);
519         clipw -= m_width - w;
520     }
521     
522     if (!style()->clipTop().isVariable())
523     {
524         int c=style()->clipTop().width(m_height);
525         clipy+=c;
526         cliph-=c;
527     }
528     if (!style()->clipBottom().isVariable())
529     {
530         int h = style()->clipBottom().width(m_height);
531         cliph -= m_height - h;
532     }
533     //kdDebug( 6040 ) << "setting clip("<<clipx<<","<<clipy<<","<<clipw<<","<<cliph<<")"<<endl;
534
535     QRect cr(clipx,clipy,clipw,cliph);
536     return cr;
537 }
538
539 int RenderBox::containingBlockWidth() const
540 {
541     RenderBlock* cb = containingBlock();
542     if (!cb)
543         return 0;
544     if (usesLineWidth())
545         return cb->lineWidth(m_y);
546     else
547         return cb->contentWidth();
548 }
549
550 bool RenderBox::absolutePosition(int &xPos, int &yPos, bool f)
551 {
552     if (style()->position() == FIXED)
553         f = true;
554     RenderObject *o = container();
555     if (o && o->absolutePosition(xPos, yPos, f)) {
556         if (o->hasOverflowClip())
557             o->layer()->subtractScrollOffset(xPos, yPos); 
558             
559         if (!isInline() || isReplaced())
560             xPos += m_x, yPos += m_y;
561
562         if (isRelPositioned())
563             relativePositionOffset(xPos, yPos);
564
565         return true;
566     }
567     else {
568         xPos = yPos = 0;
569         return false;
570     }
571 }
572
573 void RenderBox::dirtyLineBoxes(bool fullLayout, bool)
574 {
575     if (m_inlineBoxWrapper) {
576         if (fullLayout) {
577             m_inlineBoxWrapper->detach(renderArena());
578             m_inlineBoxWrapper = 0;
579         }
580         else
581             m_inlineBoxWrapper->dirtyLineBoxes();
582     }
583 }
584
585 void RenderBox::position(InlineBox* box, int from, int len, bool reverse)
586 {
587     if (isPositioned()) {
588         // Cache the x position only if we were an INLINE type originally.
589         bool wasInline = style()->originalDisplay() == INLINE ||
590                          style()->originalDisplay() == INLINE_TABLE;
591         if (wasInline && hasStaticX()) {
592             // The value is cached in the xPos of the box.  We only need this value if
593             // our object was inline originally, since otherwise it would have ended up underneath
594             // the inlines.
595             m_staticX = box->xPos();
596         }
597         else if (!wasInline && hasStaticY())
598             // Our object was a block originally, so we make our normal flow position be
599             // just below the line box (as though all the inlines that came before us got
600             // wrapped in an anonymous block, which is what would have happened had we been
601             // in flow).  This value was cached in the yPos() of the box.
602             m_staticY = box->yPos();
603
604         // Nuke the box.
605         box->remove();
606         box->detach(renderArena());
607     }
608     else if (isReplaced()) {
609         m_x = box->xPos();
610         m_y = box->yPos();
611         m_inlineBoxWrapper = box;
612     }
613 }
614
615 // For inline replaced elements, this function returns the inline box that owns us.  Enables
616 // the replaced RenderObject to quickly determine what line it is contained on and to easily
617 // iterate over structures on the line.
618 InlineBox* RenderBox::inlineBoxWrapper() const
619 {
620     return m_inlineBoxWrapper;
621 }
622
623 void RenderBox::deleteLineBoxWrapper()
624 {
625     if (m_inlineBoxWrapper)
626         m_inlineBoxWrapper->detach(renderArena());
627 }
628
629 void RenderBox::setInlineBoxWrapper(InlineBox* b)
630 {
631     m_inlineBoxWrapper = b;
632 }
633
634 QRect RenderBox::getAbsoluteRepaintRect()
635 {
636     int ow = style() ? style()->outlineSize() : 0;
637     QRect r(-ow, -ow, overflowWidth(false)+ow*2, overflowHeight(false)+ow*2);
638     computeAbsoluteRepaintRect(r);
639     return r;
640 }
641
642 void RenderBox::computeAbsoluteRepaintRect(QRect& r, bool f)
643 {
644     int x = r.x() + m_x;
645     int y = r.y() + m_y;
646      
647     // Apply the relative position offset when invalidating a rectangle.  The layer
648     // is translated, but the render box isn't, so we need to do this to get the
649     // right dirty rect.  Since this is called from RenderObject::setStyle, the relative position
650     // flag on the RenderObject has been cleared, so use the one on the style().
651     if (style()->position() == RELATIVE && m_layer)
652         m_layer->relativePositionOffset(x,y);
653     
654     if (style()->position()==FIXED)
655         f = true;
656
657     RenderObject* o = container();
658     if (o) {
659         // <body> may not have overflow, since it might be applying its overflow value to the
660         // scrollbars.
661         if (o->hasOverflowClip()) {
662             // o->height() is inaccurate if we're in the middle of a layout of |o|, so use the
663             // layer's size instead.  Even if the layer's size is wrong, the layer itself will repaint
664             // anyway if its size does change.
665             QRect boxRect(0, 0, o->layer()->width(), o->layer()->height());
666             o->layer()->subtractScrollOffset(x,y); // For overflow:auto/scroll/hidden.
667             QRect repaintRect(x, y, r.width(), r.height());
668             r = repaintRect.intersect(boxRect);
669             if (r.isEmpty())
670                 return;
671         }
672         else {
673             r.setX(x);
674             r.setY(y);
675         }
676         o->computeAbsoluteRepaintRect(r, f);
677     }
678 }
679
680 void RenderBox::repaintDuringLayoutIfMoved(int oldX, int oldY)
681 {
682     int newX = m_x;
683     int newY = m_y;
684     if (oldX != newX || oldY != newY) {
685         // The child moved.  Invalidate the object's old and new positions.  We have to do this
686         // since the object may not have gotten a layout.
687         m_x = oldX; m_y = oldY;
688         repaint();
689         repaintFloatingDescendants();
690         m_x = newX; m_y = newY;
691         repaint();
692         repaintFloatingDescendants();
693     }
694 }
695
696 void RenderBox::relativePositionOffset(int &tx, int &ty)
697 {
698     if(!style()->left().isVariable())
699         tx += style()->left().width(containingBlockWidth());
700     else if(!style()->right().isVariable())
701         tx -= style()->right().width(containingBlockWidth());
702     if(!style()->top().isVariable())
703     {
704         if (!style()->top().isPercent()
705                 || containingBlock()->style()->height().isFixed())
706             ty += style()->top().width(containingBlockHeight());
707     }
708     else if(!style()->bottom().isVariable())
709     {
710         if (!style()->bottom().isPercent()
711                 || containingBlock()->style()->height().isFixed())
712             ty -= style()->bottom().width(containingBlockHeight());
713     }
714 }
715
716 void RenderBox::calcWidth()
717 {
718 #ifdef DEBUG_LAYOUT
719     kdDebug( 6040 ) << "RenderBox("<<renderName()<<")::calcWidth()" << endl;
720 #endif
721     if (isPositioned())
722     {
723         calcAbsoluteHorizontal();
724     }
725     else
726     {
727         // The parent box is flexing us, so it has increased or decreased our width.  Use the width
728         // from the style context.
729         if (m_overrideSize != -1 && parent()->isFlexibleBox() && parent()->style()->boxOrient() == HORIZONTAL
730             && parent()->isFlexingChildren()) {
731             m_width = m_overrideSize;
732             return;
733         }
734
735         bool inVerticalBox = parent()->isFlexibleBox() && parent()->style()->boxOrient() == VERTICAL;
736         bool stretching = parent()->style()->boxAlign() == BSTRETCH;
737         bool treatAsReplaced = isReplaced() && !isInlineBlockOrInlineTable() &&
738             (!inVerticalBox || !stretching);
739         Length w;
740         if (treatAsReplaced)
741             w = Length( calcReplacedWidth(), Fixed );
742         else
743             w = style()->width();
744
745         Length ml = style()->marginLeft();
746         Length mr = style()->marginRight();
747
748         RenderBlock *cb = containingBlock();
749         int cw = containingBlockWidth();
750
751         if (cw<0) cw = 0;
752
753         m_marginLeft = 0;
754         m_marginRight = 0;
755
756         if (isInline() && !isInlineBlockOrInlineTable())
757         {
758             // just calculate margins
759             m_marginLeft = ml.minWidth(cw);
760             m_marginRight = mr.minWidth(cw);
761             if (treatAsReplaced)
762             {
763                 m_width = w.width(cw);
764                 m_width += paddingLeft() + paddingRight() + borderLeft() + borderRight();
765                 if(m_width < m_minWidth) m_width = m_minWidth;
766             }
767
768             return;
769         }
770         else {
771             LengthType widthType, minWidthType, maxWidthType;
772             if (treatAsReplaced) {
773                 m_width = w.width(cw);
774                 m_width += paddingLeft() + paddingRight() + borderLeft() + borderRight();
775                 widthType = w.type;
776             } else {
777                 m_width = calcWidthUsing(Width, cw, widthType);
778                 int minW = calcWidthUsing(MinWidth, cw, minWidthType);
779                 int maxW = style()->maxWidth().value == UNDEFINED ?
780                              m_width : calcWidthUsing(MaxWidth, cw, maxWidthType);
781                 
782                 if (m_width > maxW) {
783                     m_width = maxW;
784                     widthType = maxWidthType;
785                 }
786                 if (m_width < minW) {
787                     m_width = minW;
788                     widthType = minWidthType;
789                 }
790             }
791             
792             if (widthType == Variable) {
793     //          kdDebug( 6040 ) << "variable" << endl;
794                 m_marginLeft = ml.minWidth(cw);
795                 m_marginRight = mr.minWidth(cw);
796             }
797             else
798             {
799 //              kdDebug( 6040 ) << "non-variable " << w.type << ","<< w.value << endl;
800                 calcHorizontalMargins(ml,mr,cw);
801             }
802         }
803
804         if (cw && cw != m_width + m_marginLeft + m_marginRight && !isFloating() && !isInline() &&
805             !cb->isFlexibleBox())
806         {
807             if (cb->style()->direction()==LTR)
808                 m_marginRight = cw - m_width - m_marginLeft;
809             else
810                 m_marginLeft = cw - m_width - m_marginRight;
811         }
812     }
813
814 #ifdef DEBUG_LAYOUT
815     kdDebug( 6040 ) << "RenderBox::calcWidth(): m_width=" << m_width << " containingBlockWidth()=" << containingBlockWidth() << endl;
816     kdDebug( 6040 ) << "m_marginLeft=" << m_marginLeft << " m_marginRight=" << m_marginRight << endl;
817 #endif
818 }
819
820 int RenderBox::calcWidthUsing(WidthType widthType, int cw, LengthType& lengthType)
821 {
822     int width = m_width;
823     Length w;
824     if (widthType == Width)
825         w = style()->width();
826     else if (widthType == MinWidth)
827         w = style()->minWidth();
828     else
829         w = style()->maxWidth();
830         
831     lengthType = w.type;
832     
833     if (lengthType == Variable) {
834         int marginLeft = style()->marginLeft().minWidth(cw);
835         int marginRight = style()->marginRight().minWidth(cw);
836         if (cw) width = cw - marginLeft - marginRight;
837         
838         if (sizesToMaxWidth()) {
839             if (width < m_minWidth) 
840                 width = m_minWidth;
841             if (width > m_maxWidth) 
842                 width = m_maxWidth;
843         }
844     }
845     else
846     {
847         width = w.width(cw);
848         width += paddingLeft() + paddingRight() + borderLeft() + borderRight();
849     }
850     
851     return width;
852 }
853
854 void RenderBox::calcHorizontalMargins(const Length& ml, const Length& mr, int cw)
855 {
856     if (isFloating() || isInline()) // Inline blocks/tables and floats don't have their margins increased.
857     {
858         m_marginLeft = ml.minWidth(cw);
859         m_marginRight = mr.minWidth(cw);
860     }
861     else
862     {
863         if ( (ml.type == Variable && mr.type == Variable) ||
864              (ml.type != Variable && mr.type != Variable &&
865                 containingBlock()->style()->textAlign() == KHTML_CENTER) )
866         {
867             m_marginLeft = (cw - m_width)/2;
868             if (m_marginLeft<0) m_marginLeft=0;
869             m_marginRight = cw - m_width - m_marginLeft;
870         }
871         else if (mr.type == Variable ||
872                  (ml.type != Variable && containingBlock()->style()->direction() == RTL &&
873                   containingBlock()->style()->textAlign() == KHTML_LEFT))
874         {
875             m_marginLeft = ml.width(cw);
876             m_marginRight = cw - m_width - m_marginLeft;
877         }
878         else if (ml.type == Variable ||
879                  (mr.type != Variable && containingBlock()->style()->direction() == LTR &&
880                   containingBlock()->style()->textAlign() == KHTML_RIGHT))
881         {
882             m_marginRight = mr.width(cw);
883             m_marginLeft = cw - m_width - m_marginRight;
884         }
885         else
886         {
887             m_marginLeft = ml.minWidth(cw);
888             m_marginRight = mr.minWidth(cw);
889         }
890     }
891 }
892
893 void RenderBox::calcHeight()
894 {
895
896 #ifdef DEBUG_LAYOUT
897     kdDebug( 6040 ) << "RenderBox::calcHeight()" << endl;
898 #endif
899
900     // Cell height is managed by the table and inline non-replaced elements do not support a height property.
901     if (isTableCell() || (isInline() && !isReplaced()))
902         return;
903
904     if (isPositioned())
905         calcAbsoluteVertical();
906     else
907     {
908         calcVerticalMargins();
909         
910         // For tables, calculate margins only
911         if (isTable())
912             return;
913         
914         Length h;
915         bool inHorizontalBox = parent()->isFlexibleBox() && parent()->style()->boxOrient() == HORIZONTAL;
916         bool stretching = parent()->style()->boxAlign() == BSTRETCH;
917         bool treatAsReplaced = isReplaced() && !isInlineBlockOrInlineTable() && (!inHorizontalBox || !stretching);
918         bool checkMinMaxHeight = false;
919         
920         // The parent box is flexing us, so it has increased or decreased our height.  We have to
921         // grab our cached flexible height.
922         if (m_overrideSize != -1 && parent()->isFlexibleBox() && parent()->style()->boxOrient() == VERTICAL
923             && parent()->isFlexingChildren())
924             h = Length(m_overrideSize - borderTop() - borderBottom() - paddingTop() - paddingBottom(), Fixed);
925         else if (treatAsReplaced)
926             h = Length(calcReplacedHeight(), Fixed);
927         else {
928             h = style()->height();
929             checkMinMaxHeight = true;
930         }
931         
932         // Block children of horizontal flexible boxes fill the height of the box.
933         if (h.isVariable() && parent()->isFlexibleBox() && parent()->style()->boxOrient() == HORIZONTAL
934             && parent()->isStretchingChildren()) {
935             h = Length(parent()->contentHeight() - marginTop() - marginBottom() -
936                        borderTop() - paddingTop() - borderBottom() - paddingBottom(), Fixed);
937             checkMinMaxHeight = false;
938         }
939
940         int height;
941         if (checkMinMaxHeight) {
942             height = calcHeightUsing(style()->height());
943             int minH = calcHeightUsing(style()->minHeight());
944             int maxH = style()->maxHeight().value == UNDEFINED ? height : calcHeightUsing(style()->maxHeight());
945             height = kMin(maxH, height);
946             height = kMax(minH, height);
947         }
948         else
949             // The only times we don't check min/max height are when a fixed length has 
950             // been given as an override.  Just use that.
951             height = h.value + borderTop() + paddingTop() + borderBottom() + paddingBottom(); 
952         m_height = height;
953     }
954     
955     // Unfurling marquees override with the furled height.
956     if (style()->overflow() == OMARQUEE && m_layer && m_layer->marquee() && 
957         m_layer->marquee()->isUnfurlMarquee() && !m_layer->marquee()->isHorizontal()) {
958         m_layer->marquee()->setEnd(m_height);
959         m_height = kMin(m_height, m_layer->marquee()->unfurlPos());
960     }
961     
962     // WinIE quirk: The <html> block always fills the entire canvas in quirks mode.  The <body> always fills the
963     // <html> block in quirks mode.  Only apply this quirk if the block is normal flow and no height
964     // is specified.
965     if (style()->htmlHacks() && style()->height().isVariable() &&
966         !isFloatingOrPositioned() && (isRoot() || isBody())) {
967         int margins = collapsedMarginTop() + collapsedMarginBottom();
968         int visHeight = canvas()->view()->visibleHeight();
969         if (isRoot())
970             m_height = kMax(m_height, visHeight - margins);
971         else
972             m_height = kMax(m_height, visHeight - 
973                             (margins + parent()->marginTop() + parent()->marginBottom() + 
974                              parent()->borderTop() + parent()->borderBottom() +
975                              parent()->paddingTop() + parent()->paddingBottom()));
976     }
977 }
978
979 int RenderBox::calcHeightUsing(const Length& h)
980 {
981     if (!h.isVariable()) {
982         int height = -1;
983         if (h.isFixed())
984             height = h.value;
985         else if (h.isPercent())
986             height = calcPercentageHeight(h);
987         if (height != -1) {
988             height += borderTop() + paddingTop() + borderBottom() + paddingBottom();
989             return height;
990         }
991     }
992     return m_height;
993 }
994
995 int RenderBox::calcPercentageHeight(const Length& height)
996 {
997     int result = -1;
998     RenderBlock* cb = containingBlock();
999     // Table cells violate what the CSS spec says to do with heights.  Basically we
1000     // don't care if the cell specified a height or not.  We just always make ourselves
1001     // be a percentage of the cell's current content height.
1002     if (cb->isTableCell()) {
1003         result = cb->overrideSize();
1004         if (result == -1)
1005             return -1;
1006         // It is necessary to use the border-box to match WinIE's broken
1007         // box model.  This is essential for sizing inside
1008         // table cells using percentage heights.
1009         result -= (borderTop() + paddingTop() + borderBottom() + paddingBottom());
1010         result = kMax(0, result);
1011     }
1012
1013     // Otherwise we only use our percentage height if our containing block had a specified
1014     // height.
1015     else if (cb->style()->height().isFixed())
1016         result = cb->style()->height().value;
1017     else if (cb->style()->height().isPercent())
1018         // We need to recur and compute the percentage height for our containing block.
1019         result = cb->calcPercentageHeight(cb->style()->height());
1020     else if (cb->isCanvas() || (cb->isBody() && style()->htmlHacks())) {
1021         // Don't allow this to affect the block' m_height member variable, since this
1022         // can get called while the block is still laying out its kids.
1023         int oldHeight = cb->height();
1024         cb->calcHeight();
1025         result = cb->contentHeight();
1026         cb->setHeight(oldHeight);
1027     }
1028     if (result != -1)
1029         result = height.width(result);
1030     return result;
1031 }
1032
1033 int RenderBox::calcReplacedWidth() const
1034 {
1035     int width = calcReplacedWidthUsing(Width);
1036     int minW = calcReplacedWidthUsing(MinWidth);
1037     int maxW = style()->maxWidth().value == UNDEFINED ? width : calcReplacedWidthUsing(MaxWidth);
1038
1039     if (width > maxW)
1040         width = maxW;
1041     
1042     if (width < minW)
1043         width = minW;
1044
1045     return width;
1046 }
1047
1048 int RenderBox::calcReplacedWidthUsing(WidthType widthType) const
1049 {
1050     Length w;
1051     if (widthType == Width)
1052         w = style()->width();
1053     else if (widthType == MinWidth)
1054         w = style()->minWidth();
1055     else
1056         w = style()->maxWidth();
1057     
1058     switch (w.type) {
1059     case Fixed:
1060         return w.value;
1061     case Percent:
1062     {
1063         const int cw = containingBlockWidth();
1064         if (cw > 0) {
1065             int result = w.minWidth(cw);
1066             return result;
1067         }
1068     }
1069     // fall through
1070     default:
1071         return intrinsicWidth();
1072     }
1073 }
1074
1075 int RenderBox::calcReplacedHeight() const
1076 {
1077     int height = calcReplacedHeightUsing(Height);
1078     int minH = calcReplacedHeightUsing(MinHeight);
1079     int maxH = style()->maxHeight().value == UNDEFINED ? height : calcReplacedHeightUsing(MaxHeight);
1080
1081     if (height > maxH)
1082         height = maxH;
1083
1084     if (height < minH)
1085         height = minH;
1086
1087     return height;
1088 }
1089
1090 int RenderBox::calcReplacedHeightUsing(HeightType heightType) const
1091 {
1092     Length h;
1093     if (heightType == Height)
1094         h = style()->height();
1095     else if (heightType == MinHeight)
1096         h = style()->minHeight();
1097     else
1098         h = style()->maxHeight();
1099     switch( h.type ) {
1100     case Percent:
1101         return availableHeightUsing(h);
1102     case Fixed:
1103         return h.value;
1104     default:
1105         return intrinsicHeight();
1106     };
1107 }
1108
1109 int RenderBox::availableHeight() const
1110 {
1111     return availableHeightUsing(style()->height());
1112 }
1113
1114 int RenderBox::availableHeightUsing(const Length& h) const
1115 {
1116     if (h.isFixed())
1117         return h.value;
1118
1119     if (isCanvas())
1120         return static_cast<const RenderCanvas*>(this)->viewportHeight();
1121
1122     // We need to stop here, since we don't want to increase the height of the table
1123     // artificially.  We're going to rely on this cell getting expanded to some new
1124     // height, and then when we lay out again we'll use the calculation below.
1125     if (isTableCell() && (h.isVariable() || h.isPercent())) {
1126         return overrideSize() - (borderLeft()+borderRight()+paddingLeft()+paddingRight());
1127     }
1128     
1129     if (h.isPercent())
1130        return h.width(containingBlock()->availableHeight());
1131        
1132     return containingBlock()->availableHeight();
1133 }
1134
1135 void RenderBox::calcVerticalMargins()
1136 {
1137     if( isTableCell() ) {
1138         // table margins are basically infinite
1139         m_marginTop = TABLECELLMARGIN;
1140         m_marginBottom = TABLECELLMARGIN;
1141         return;
1142     }
1143
1144     Length tm = style()->marginTop();
1145     Length bm = style()->marginBottom();
1146
1147     // margins are calculated with respect to the _width_ of
1148     // the containing block (8.3)
1149     int cw = containingBlock()->contentWidth();
1150
1151     m_marginTop = tm.minWidth(cw);
1152     m_marginBottom = bm.minWidth(cw);
1153 }
1154
1155 void RenderBox::setStaticX(int staticX)
1156 {
1157     m_staticX = staticX;
1158 }
1159
1160 void RenderBox::setStaticY(int staticY)
1161 {
1162     m_staticY = staticY;
1163 }
1164
1165 void RenderBox::calcAbsoluteHorizontal()
1166 {
1167     const int AUTO = -666666;
1168     int l,r,w,ml,mr,cw;
1169
1170     int pab = borderLeft()+ borderRight()+ paddingLeft()+ paddingRight();
1171
1172     l=r=ml=mr=w=AUTO;
1173  
1174     // We don't use containingBlock(), since we may be positioned by an enclosing relpositioned inline.
1175     RenderObject* cb = container();
1176     cw = containingBlockWidth() + cb->paddingLeft() + cb->paddingRight();
1177
1178     if(!style()->left().isVariable())
1179         l = style()->left().width(cw);
1180     if(!style()->right().isVariable())
1181         r = style()->right().width(cw);
1182     if(!style()->width().isVariable())
1183         w = style()->width().width(cw);
1184     else if (isReplaced())
1185         w = intrinsicWidth();
1186     if(!style()->marginLeft().isVariable())
1187         ml = style()->marginLeft().width(cw);
1188     if(!style()->marginRight().isVariable())
1189         mr = style()->marginRight().width(cw);
1190
1191
1192 //    printf("h1: w=%d, l=%d, r=%d, ml=%d, mr=%d\n",w,l,r,ml,mr);
1193
1194     int static_distance=0;
1195     if ((parent()->style()->direction()==LTR && (l==AUTO && r==AUTO ))
1196             || style()->left().isStatic())
1197     {
1198         static_distance = m_staticX - cb->borderLeft(); // Should already have been set through layout of the parent().
1199         RenderObject* po = parent();
1200         for (; po && po != cb; po = po->parent())
1201             static_distance += po->xPos();
1202
1203         if (l==AUTO || style()->left().isStatic())
1204             l = static_distance;
1205     }
1206
1207     else if ((parent()->style()->direction()==RTL && (l==AUTO && r==AUTO ))
1208             || style()->right().isStatic())
1209     {
1210         RenderObject* po = parent();
1211         static_distance = m_staticX - cb->borderLeft(); // Should already have been set through layout of the parent().
1212         while (po && po!=containingBlock()) {
1213             static_distance+=po->xPos();
1214             po=po->parent();
1215         }
1216
1217         if (r==AUTO || style()->right().isStatic())
1218             r = static_distance;
1219     }
1220
1221
1222     if (l!=AUTO && w!=AUTO && r!=AUTO)
1223     {
1224         // left, width, right all given, play with margins
1225         int ot = l + w + r + pab;
1226
1227         if (ml==AUTO && mr==AUTO)
1228         {
1229             // both margins auto, solve for equality
1230             ml = (cw - ot)/2;
1231             mr = cw - ot - ml;
1232         }
1233         else if (ml==AUTO)
1234             // solve for left margin
1235             ml = cw - ot - mr;
1236         else if (mr==AUTO)
1237             // solve for right margin
1238             mr = cw - ot - ml;
1239         else
1240         {
1241             // overconstrained, solve according to dir
1242             if (style()->direction()==LTR)
1243                 r = cw - ( l + w + ml + mr + pab);
1244             else
1245                 l = cw - ( r + w + ml + mr + pab);
1246         }
1247     }
1248     else
1249     {
1250         // one or two of (left, width, right) missing, solve
1251
1252         // auto margins are ignored
1253         if (ml==AUTO) ml = 0;
1254         if (mr==AUTO) mr = 0;
1255
1256         //1. solve left & width.
1257         if (l==AUTO && w==AUTO && r!=AUTO)
1258         {
1259             // From section 10.3.7 of the CSS2.1 specification.
1260             // "The shrink-to-fit width is: min(max(preferred minimum width, available width), preferred width)."
1261             w = QMIN(QMAX(m_minWidth-pab, cw - ( r + ml + mr + pab)), m_maxWidth-pab);
1262             l = cw - ( r + w + ml + mr + pab);
1263         }
1264         else
1265
1266         //2. solve left & right. use static positioning.
1267         if (l==AUTO && w!=AUTO && r==AUTO)
1268         {
1269             if (style()->direction()==RTL)
1270             {
1271                 r = static_distance;
1272                 l = cw - ( r + w + ml + mr + pab);
1273             }
1274             else
1275             {
1276                 l = static_distance;
1277                 r = cw - ( l + w + ml + mr + pab);
1278             }
1279
1280         }
1281         else
1282
1283         //3. solve width & right.
1284         if (l!=AUTO && w==AUTO && r==AUTO)
1285         {
1286             // From section 10.3.7 of the CSS2.1 specification.
1287             // "The shrink-to-fit width is: min(max(preferred minimum width, available width), preferred width)."
1288             w = QMIN(QMAX(m_minWidth-pab, cw - ( l + ml + mr + pab)), m_maxWidth-pab);
1289             r = cw - ( l + w + ml + mr + pab);
1290         }
1291         else
1292
1293         //4. solve left
1294         if (l==AUTO && w!=AUTO && r!=AUTO)
1295             l = cw - ( r + w + ml + mr + pab);
1296         else
1297
1298         //5. solve width
1299         if (l!=AUTO && w==AUTO && r!=AUTO)
1300             w = cw - ( r + l + ml + mr + pab);
1301         else
1302
1303         //6. solve right
1304         if (l!=AUTO && w!=AUTO && r==AUTO)
1305             r = cw - ( l + w + ml + mr + pab);
1306     }
1307
1308     m_width = w + pab;
1309     m_marginLeft = ml;
1310     m_marginRight = mr;
1311     m_x = l + ml + cb->borderLeft();
1312 //    printf("h: w=%d, l=%d, r=%d, ml=%d, mr=%d\n",w,l,r,ml,mr);
1313 }
1314
1315
1316 void RenderBox::calcAbsoluteVertical()
1317 {
1318     // css2 spec 10.6.4 & 10.6.5
1319
1320     // based on
1321     // http://www.w3.org/Style/css2-updates/REC-CSS2-19980512-errata
1322     // (actually updated 2000-10-24)
1323     // that introduces static-position value for top, left & right
1324
1325     const int AUTO = -666666;
1326     int t,b,h,mt,mb,ch;
1327
1328     t=b=h=mt=mb=AUTO;
1329
1330     int pab = borderTop()+borderBottom()+paddingTop()+paddingBottom();
1331
1332     // We don't use containingBlock(), since we may be positioned by an enclosing relpositioned inline.
1333     RenderObject* cb = container();
1334     Length hl = cb->style()->height();
1335     if (hl.isFixed())
1336         ch = hl.value + cb->paddingTop() + cb->paddingBottom();
1337     else if (cb->isRoot())
1338         ch = cb->availableHeight();
1339     else
1340         ch = cb->height() - cb->borderTop() - cb->borderBottom();
1341
1342     if(!style()->top().isVariable())
1343         t = style()->top().width(ch);
1344     if(!style()->bottom().isVariable())
1345         b = style()->bottom().width(ch);
1346     if (isTable() && style()->height().isVariable())
1347         // Height is never unsolved for tables. "auto" means shrink to fit.  Use our
1348         // height instead.
1349         h = m_height - pab;
1350     else if(!style()->height().isVariable())
1351     {
1352         h = style()->height().width(ch);
1353         
1354         if (m_height-pab > h) {
1355             setOverflowHeight(m_height + pab - (paddingBottom() + borderBottom()));
1356             m_height = h+pab;
1357         }
1358     }
1359     else if (isReplaced())
1360         h = intrinsicHeight();
1361
1362     if(!style()->marginTop().isVariable())
1363         mt = style()->marginTop().width(ch);
1364     if(!style()->marginBottom().isVariable())
1365         mb = style()->marginBottom().width(ch);
1366
1367     int static_top=0;
1368     if ((t==AUTO && b==AUTO ) || style()->top().isStatic())
1369     {
1370         // calc hypothetical location in the normal flow
1371         // used for 1) top=static-position
1372         //          2) top, bottom, height are all auto -> calc top -> 3.
1373         //          3) precalc for case 2 below
1374         static_top = m_staticY - cb->borderTop(); // Should already have been set through layout of the parent().
1375         RenderObject* po = parent();
1376         for (; po && po != cb; po = po->parent())
1377             static_top += po->yPos();
1378
1379         if (h==AUTO || style()->top().isStatic())
1380             t = static_top;
1381     }
1382
1383     if (t!=AUTO && h!=AUTO && b!=AUTO)
1384     {
1385         // top, height, bottom all given, play with margins
1386         int ot = h + t + b + pab;
1387
1388         if (mt==AUTO && mb==AUTO)
1389         {
1390             // both margins auto, solve for equality
1391             mt = (ch - ot)/2;
1392             mb = ch - ot - mt;
1393         }
1394         else if (mt==AUTO)
1395             // solve for top margin
1396             mt = ch - ot - mb;
1397         else if (mb==AUTO)
1398             // solve for bottom margin
1399             mb = ch - ot - mt;
1400         else
1401             // overconstrained, solve for bottom
1402             b = ch - ( h+t+mt+mb+pab);
1403     }
1404     else
1405     {
1406         // one or two of (top, height, bottom) missing, solve
1407
1408         // auto margins are ignored
1409         if (mt==AUTO) mt = 0;
1410         if (mb==AUTO) mb = 0;
1411
1412         //1. solve top & height. use content height.
1413         if (t==AUTO && h==AUTO && b!=AUTO)
1414         {
1415             h = m_height-pab;
1416             t = ch - ( h+b+mt+mb+pab);
1417         }
1418         else
1419
1420         //2. solve top & bottom. use static positioning.
1421         if (t==AUTO && h!=AUTO && b==AUTO)
1422         {
1423             t = static_top;
1424             b = ch - ( h+t+mt+mb+pab);
1425         }
1426         else
1427
1428         //3. solve height & bottom. use content height.
1429         if (t!=AUTO && h==AUTO && b==AUTO)
1430         {
1431             h = m_height-pab;
1432             b = ch - ( h+t+mt+mb+pab);
1433         }
1434         else
1435
1436         //4. solve top
1437         if (t==AUTO && h!=AUTO && b!=AUTO)
1438             t = ch - ( h+b+mt+mb+pab);
1439         else
1440
1441         //5. solve height
1442         if (t!=AUTO && h==AUTO && b!=AUTO)
1443             h = ch - ( t+b+mt+mb+pab);
1444         else
1445
1446         //6. solve bottom
1447         if (t!=AUTO && h!=AUTO && b==AUTO)
1448             b = ch - ( h+t+mt+mb+pab);
1449     }
1450
1451     if (m_height<h+pab) //content must still fit
1452         m_height = h+pab;
1453
1454     if (hasOverflowClip() && m_height > h+pab)
1455         m_height = h+pab;
1456     
1457     // Do not allow the height to be negative.  This can happen when someone specifies both top and bottom
1458     // but the containing block height is less than top, e.g., top:20px, bottom:0, containing block height 16.
1459     m_height = kMax(0, m_height);
1460     
1461     m_marginTop = mt;
1462     m_marginBottom = mb;
1463     m_y = t + mt + cb->borderTop();
1464     
1465 //    printf("v: h=%d, t=%d, b=%d, mt=%d, mb=%d, m_y=%d\n",h,t,b,mt,mb,m_y);
1466
1467 }
1468
1469 void RenderBox::caretPos(int offset, bool override, int &_x, int &_y, int &width, int &height)
1470 {
1471     _x = -1;
1472     
1473     // propagate it downwards to its children, someone will feel responsible
1474     RenderObject *child = firstChild();
1475     if (child) 
1476         child->caretPos(offset, override, _x, _y, width, height);
1477     
1478     // if not, use the extents of this box 
1479     // offset 0 means left, offset 1 means right
1480     if (_x == -1) {
1481         _x = xPos() + (offset == 0 ? 0 : m_width);
1482         InlineBox *box = inlineBoxWrapper();
1483         if (box) {
1484             height = box->root()->bottomOverflow() - box->root()->topOverflow();
1485             _y = box->root()->topOverflow();
1486         }
1487         else {
1488             _y = yPos();
1489             height = m_height;
1490         }
1491         width = override && offset == 0 ? m_width : 1;
1492         // If height of box is smaller than font height, use the latter one,
1493         // otherwise the caret might become invisible.
1494         // 
1495         // Also, if the box is not a replaced element, always use the font height.
1496         // This prevents the "big caret" bug described in:
1497         // <rdar://problem/3777804> Deleting all content in a document can result in giant tall-as-window insertion point
1498         //
1499         // FIXME: ignoring :first-line, missing good reason to take care of
1500         int fontHeight = style()->fontMetrics().height();
1501         if (fontHeight > height || !isReplaced())
1502             height = fontHeight;
1503         
1504         int absx, absy;
1505         RenderObject *cb = containingBlock();
1506         if (cb && cb != this && cb->absolutePosition(absx,absy)) {
1507             _x += absx;
1508             _y += absy;
1509         } 
1510         else {
1511             // we don't know our absolute position, and there is no point returning
1512             // just a relative one
1513             _x = _y = -1;
1514         }
1515     }
1516 }
1517
1518 int RenderBox::lowestPosition(bool includeOverflowInterior, bool includeSelf) const
1519 {
1520     return includeSelf ? m_height : 0;
1521 }
1522
1523 int RenderBox::rightmostPosition(bool includeOverflowInterior, bool includeSelf) const
1524 {
1525     return includeSelf ? m_width : 0;
1526 }
1527
1528 int RenderBox::leftmostPosition(bool includeOverflowInterior, bool includeSelf) const
1529 {
1530     return includeSelf ? 0 : m_width;
1531 }
1532
1533 #undef DEBUG_LAYOUT