diff options
Diffstat (limited to 'tdehtml/rendering')
61 files changed, 37464 insertions, 0 deletions
diff --git a/tdehtml/rendering/CMakeLists.txt b/tdehtml/rendering/CMakeLists.txt new file mode 100644 index 000000000..757e9a72a --- /dev/null +++ b/tdehtml/rendering/CMakeLists.txt @@ -0,0 +1,46 @@ +################################################# +# +# (C) 2010 Serghei Amelian +# serghei (DOT) amelian (AT) gmail.com +# +# Improvements and feedback are welcome +# +# This file is released under GPL >= 2 +# +################################################# + +include_directories( + ${TQT_INCLUDE_DIRS} + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_BINARY_DIR}/tdecore + ${CMAKE_SOURCE_DIR} + ${CMAKE_SOURCE_DIR}/tdehtml + ${CMAKE_SOURCE_DIR}/tdecore + ${CMAKE_SOURCE_DIR}/tdeui + ${CMAKE_SOURCE_DIR}/kio + ${CMAKE_SOURCE_DIR}/kio/kio + ${CMAKE_SOURCE_DIR}/kio/kfile + ${CMAKE_SOURCE_DIR}/tdeutils +) + + +##### tdehtmlrender-static ######################### + +set( target tdehtmlrender ) + +set( ${target}_SRCS + bidi.cpp break_lines.cpp render_block.cpp render_inline.cpp + render_style.cpp render_object.cpp render_container.cpp render_box.cpp + render_flow.cpp render_text.cpp render_arena.cpp render_layer.cpp + render_image.cpp render_table.cpp table_layout.cpp + render_replaced.cpp render_form.cpp render_list.cpp + render_canvas.cpp render_frames.cpp render_br.cpp + render_body.cpp font.cpp render_line.cpp render_generated.cpp + enumerate.cpp counter_tree.cpp +) + +tde_add_library( ${target} STATIC_PIC AUTOMOC + SOURCES ${${target}_SRCS} +) diff --git a/tdehtml/rendering/Makefile.am b/tdehtml/rendering/Makefile.am new file mode 100644 index 000000000..605788764 --- /dev/null +++ b/tdehtml/rendering/Makefile.am @@ -0,0 +1,57 @@ +# This file is part of the KDE libraries +# Copyright (C) 1997 Martin Jones (mjones@kde.org) +# (C) 1997 Torben Weis (weis@kde.org) + +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Library General Public +# License as published by the Free Software Foundation; either +# version 2 of the License, or (at your option) any later version. + +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Library General Public License for more details. + +# You should have received a copy of the GNU Library General Public License +# along with this library; see the file COPYING.LIB. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +# Boston, MA 02110-1301, USA. + +KDE_CXXFLAGS = $(WOVERLOADED_VIRTUAL) + +noinst_LTLIBRARIES = libtdehtmlrender.la +libtdehtmlrender_la_SOURCES = \ + bidi.cpp break_lines.cpp render_block.cpp render_inline.cpp \ + render_style.cpp render_object.cpp render_container.cpp render_box.cpp \ + render_flow.cpp render_text.cpp render_arena.cpp render_layer.cpp \ + render_image.cpp render_table.cpp table_layout.cpp \ + render_replaced.cpp render_form.cpp render_list.cpp \ + render_canvas.cpp render_frames.cpp render_br.cpp \ + render_body.cpp font.cpp render_line.cpp render_generated.cpp \ + enumerate.cpp counter_tree.cpp + +libtdehtmlrender_la_METASOURCES = AUTO + +noinst_HEADERS = \ + bidi.h break_lines.h \ + render_arena.h render_layer.h \ + render_style.h render_object.h render_container.h render_box.h \ + render_flow.h render_text.h render_table.h render_replaced.h \ + render_form.h render_list.h render_canvas.h render_frames.h \ + render_br.h render_applet.h font.h table_layout.h render_line.h \ + render_generated.h enumerate.h + +INCLUDES = -I$(top_srcdir)/kimgio -I$(top_srcdir)/kio -I$(top_srcdir)/dcop \ + -I$(top_srcdir)/kfile -I$(top_srcdir)/tdehtml -I$(top_srcdir)/tdeutils -I$(top_srcdir) $(all_includes) + +SRCDOC_DEST=$(kde_htmldir)/en/tdelibs/tdehtml + +## generate lib documentation +srcdoc: + $(mkinstalldirs) $(SRCDOC_DEST) + kdoc -H -d $(SRCDOC_DEST) tdecore -lqt + +## maintainer: regen loading icon +loading-icon: + bin2c -sploading_icon $(srcdir)/img-loading.png > $(srcdir)/loading_icon.cpp + diff --git a/tdehtml/rendering/bidi.cpp b/tdehtml/rendering/bidi.cpp new file mode 100644 index 000000000..a79ac9854 --- /dev/null +++ b/tdehtml/rendering/bidi.cpp @@ -0,0 +1,2250 @@ +/** + * This file is part of the html renderer for KDE. + * + * Copyright (C) 2000-2003 Lars Knoll (knoll@kde.org) + * (C) 2003-2005 Apple Computer, Inc. + * (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#include "rendering/bidi.h" +#include "rendering/break_lines.h" +#include "rendering/render_block.h" +#include "rendering/render_text.h" +#include "rendering/render_arena.h" +#include "rendering/render_layer.h" +#include "rendering/render_canvas.h" +#include "xml/dom_docimpl.h" + +#include "kdebug.h" +#include "tqdatetime.h" +#include "tqfontmetrics.h" + +#define BIDI_DEBUG 0 +//#define DEBUG_LINEBREAKS +//#define PAGE_DEBUG + +namespace tdehtml { + + +// an iterator which goes through a BidiParagraph +struct BidiIterator +{ + BidiIterator() : par(0), obj(0), pos(0), endOfInline(0) {} + BidiIterator(RenderBlock *_par, RenderObject *_obj, unsigned int _pos, bool eoi=false) : par(_par), obj(_obj), pos(_pos), endOfInline(eoi) {} + + void increment( BidiState &bidi, bool skipInlines=true ); + + bool atEnd() const; + + const TQChar ¤t() const; + TQChar::Direction direction() const; + + RenderBlock *par; + RenderObject *obj; + unsigned int pos; + bool endOfInline; +}; + + +struct BidiStatus { + BidiStatus() : eor(TQChar::DirON), lastStrong(TQChar::DirON), last(TQChar::DirON) {} + + TQChar::Direction eor; + TQChar::Direction lastStrong; + TQChar::Direction last; +}; + +struct BidiState { + BidiState() : context(0) {} + + BidiIterator sor; + BidiIterator eor; + BidiIterator last; + BidiIterator current; + BidiContext *context; + BidiStatus status; +}; + +// Used to track a list of chained bidi runs. +static BidiRun* sFirstBidiRun; +static BidiRun* sLastBidiRun; +static int sBidiRunCount; +static BidiRun* sCompactFirstBidiRun; +static BidiRun* sCompactLastBidiRun; +static int sCompactBidiRunCount; +static bool sBuildingCompactRuns; + +// Midpoint globals. The goal is not to do any allocation when dealing with +// these midpoints, so we just keep an array around and never clear it. We track +// the number of items and position using the two other variables. +static TQMemArray<BidiIterator> *smidpoints; +static uint sNumMidpoints; +static uint sCurrMidpoint; +static bool betweenMidpoints; + +static bool isLineEmpty = true; +static bool previousLineBrokeAtBR = true; +static TQChar::Direction dir; +static bool adjustEmbedding; +static bool emptyRun = true; +static int numSpaces; + +static void embed( TQChar::Direction d, BidiState &bidi ); +static void appendRun( BidiState &bidi ); + +static int getBPMWidth(int childValue, Length cssUnit) +{ + if (!cssUnit.isVariable()) + return (cssUnit.isFixed() ? cssUnit.value() : childValue); + return 0; +} + +static int getBorderPaddingMargin(RenderObject* child, bool endOfInline) +{ + RenderStyle* cstyle = child->style(); + int result = 0; + bool leftSide = (cstyle->direction() == LTR) ? !endOfInline : endOfInline; + result += getBPMWidth((leftSide ? child->marginLeft() : child->marginRight()), + (leftSide ? cstyle->marginLeft() : + cstyle->marginRight())); + result += getBPMWidth((leftSide ? child->paddingLeft() : child->paddingRight()), + (leftSide ? cstyle->paddingLeft() : + cstyle->paddingRight())); + result += leftSide ? child->borderLeft() : child->borderRight(); + return result; +} + +#ifndef NDEBUG +static bool inBidiRunDetach; +#endif + +void BidiRun::detach(RenderArena* renderArena) +{ +#ifndef NDEBUG + inBidiRunDetach = true; +#endif + delete this; +#ifndef NDEBUG + inBidiRunDetach = false; +#endif + + // Recover the size left there for us by operator delete and free the memory. + renderArena->free(*(size_t *)this, this); +} + +void* BidiRun::operator new(size_t sz, RenderArena* renderArena) throw() +{ + return renderArena->allocate(sz); +} + +void BidiRun::operator delete(void* ptr, size_t sz) +{ + assert(inBidiRunDetach); + + // Stash size where detach can find it. + *(size_t*)ptr = sz; +} + +static void deleteBidiRuns(RenderArena* arena) +{ + if (!sFirstBidiRun) + return; + + BidiRun* curr = sFirstBidiRun; + while (curr) { + BidiRun* s = curr->nextRun; + curr->detach(arena); + curr = s; + } + + sFirstBidiRun = 0; + sLastBidiRun = 0; + sBidiRunCount = 0; +} + +// --------------------------------------------------------------------- + +/* a small helper class used internally to resolve Bidi embedding levels. + Each line of text caches the embedding level at the start of the line for faster + relayouting +*/ +BidiContext::BidiContext(unsigned char l, TQChar::Direction e, BidiContext *p, bool o) + : level(l) , override(o), dir(e) +{ + parent = p; + if(p) { + p->ref(); + basicDir = p->basicDir; + } else + basicDir = e; + count = 0; +} + +BidiContext::~BidiContext() +{ + if(parent) parent->deref(); +} + +void BidiContext::ref() const +{ + count++; +} + +void BidiContext::deref() const +{ + count--; + if(count <= 0) delete this; +} + +// --------------------------------------------------------------------- + +inline bool operator==( const BidiIterator &it1, const BidiIterator &it2 ) +{ + if(it1.pos != it2.pos) return false; + if(it1.obj != it2.obj) return false; + return true; +} + +inline bool operator!=( const BidiIterator &it1, const BidiIterator &it2 ) +{ + if(it1.pos != it2.pos) return true; + if(it1.obj != it2.obj) return true; + return false; +} + +// when modifying this function, make sure you check InlineMinMaxIterator::next() as well. +static inline RenderObject *Bidinext(RenderObject *par, RenderObject *current, BidiState &bidi, + bool skipInlines = true, bool *endOfInline = 0 ) +{ + RenderObject *next = 0; + bool oldEndOfInline = endOfInline ? *endOfInline : false; + if (oldEndOfInline) + *endOfInline = false; + + while(current != 0) + { + //kdDebug( 6040 ) << "current = " << current << endl; + if (!oldEndOfInline && !current->isFloating() && !current->isReplaced() && !current->isPositioned()) { + next = current->firstChild(); + if ( next && adjustEmbedding ) { + EUnicodeBidi ub = next->style()->unicodeBidi(); + if ( ub != UBNormal && !emptyRun ) { + EDirection dir = next->style()->direction(); + TQChar::Direction d = ( ub == Embed ? ( dir == RTL ? TQChar::DirRLE : TQChar::DirLRE ) + : ( dir == RTL ? TQChar::DirRLO : TQChar::DirLRO ) ); + embed( d, bidi ); + } + } + } + if (!next) { + if (!skipInlines && !oldEndOfInline && current->isInlineFlow() && endOfInline) { + next = current; + *endOfInline = true; + break; + } + + while (current && current != par) { + next = current->nextSibling(); + if (next) break; + if ( adjustEmbedding && current->style()->unicodeBidi() != UBNormal && !emptyRun ) { + embed( TQChar::DirPDF, bidi ); + } + current = current->parent(); + if (!skipInlines && current && current != par && current->isInlineFlow() && endOfInline) { + next = current; + *endOfInline = true; + break; + } + } + } + + if (!next) break; + + if (next->isText() || next->isBR() || next->isFloating() || next->isReplaced() || next->isPositioned() || next->isGlyph() + || ((!skipInlines || !next->firstChild()) // Always return EMPTY inlines. + && next->isInlineFlow())) + break; + current = next; + } + return next; +} + +static RenderObject *first( RenderObject *par, BidiState &bidi, bool skipInlines = true ) +{ + if(!par->firstChild()) return 0; + RenderObject *o = par->firstChild(); + + if (o->isInlineFlow()) { + if (skipInlines && o->firstChild()) + o = Bidinext( par, o, bidi, skipInlines ); + else + return o; // Never skip empty inlines. + } + + if (o && !o->isText() && !o->isBR() && !o->isReplaced() && !o->isFloating() && !o->isPositioned() && !o->isGlyph()) + o = Bidinext( par, o, bidi, skipInlines ); + return o; +} + +inline void BidiIterator::increment (BidiState &bidi, bool skipInlines) +{ + if(!obj) return; + if(obj->isText()) { + pos++; + if(pos >= static_cast<RenderText *>(obj)->stringLength()) { + obj = Bidinext( par, obj, bidi, skipInlines ); + pos = 0; + } + } else { + obj = Bidinext( par, obj, bidi, skipInlines, &endOfInline ); + pos = 0; + } +} + +inline bool BidiIterator::atEnd() const +{ + if(!obj) return true; + return false; +} + +const TQChar &BidiIterator::current() const +{ + static TQChar nonBreakingSpace(0xA0); + + if (!obj || !obj->isText()) + return nonBreakingSpace; + + RenderText* text = static_cast<RenderText*>(obj); + if (!text->text()) + return nonBreakingSpace; + + return text->text()[pos]; +} + +inline TQChar::Direction BidiIterator::direction() const +{ + if(!obj || !obj->isText() ) return TQChar::DirON; + + RenderText *renderTxt = static_cast<RenderText *>( obj ); + if ( pos >= renderTxt->stringLength() ) + return TQChar::DirON; + return renderTxt->text()[pos].direction(); +} + +// ------------------------------------------------------------------------------------------------- + +static void addRun(BidiRun* bidiRun) +{ + if (!sFirstBidiRun) + sFirstBidiRun = sLastBidiRun = bidiRun; + else { + sLastBidiRun->nextRun = bidiRun; + sLastBidiRun = bidiRun; + } + sBidiRunCount++; + bidiRun->compact = sBuildingCompactRuns; + + // Compute the number of spaces in this run, + if (bidiRun->obj && bidiRun->obj->isText()) { + RenderText* text = static_cast<RenderText*>(bidiRun->obj); + if (text->text()) { + for (int i = bidiRun->start; i < bidiRun->stop; i++) { + const TQChar c = text->text()[i]; + if (c.category() == TQChar::Separator_Space || c == '\n') + numSpaces++; + } + } + } +} + +static void reverseRuns(int start, int end) +{ + if (start >= end) + return; + + assert(start >= 0 && end < sBidiRunCount); + + // Get the item before the start of the runs to reverse and put it in + // |beforeStart|. |curr| should point to the first run to reverse. + BidiRun* curr = sFirstBidiRun; + BidiRun* beforeStart = 0; + int i = 0; + while (i < start) { + i++; + beforeStart = curr; + curr = curr->nextRun; + } + + BidiRun* startRun = curr; + while (i < end) { + i++; + curr = curr->nextRun; + } + BidiRun* endRun = curr; + BidiRun* afterEnd = curr->nextRun; + + i = start; + curr = startRun; + BidiRun* newNext = afterEnd; + while (i <= end) { + // Do the reversal. + BidiRun* next = curr->nextRun; + curr->nextRun = newNext; + newNext = curr; + curr = next; + i++; + } + + // Now hook up beforeStart and afterEnd to the newStart and newEnd. + if (beforeStart) + beforeStart->nextRun = endRun; + else + sFirstBidiRun = endRun; + + startRun->nextRun = afterEnd; + if (!afterEnd) + sLastBidiRun = startRun; +} + +static void chopMidpointsAt(RenderObject* obj, uint pos) +{ + if (!sNumMidpoints) return; + BidiIterator* midpoints = smidpoints->data(); + for (uint i = 0; i < sNumMidpoints; i++) { + const BidiIterator& point = midpoints[i]; + if (point.obj == obj && point.pos == pos) { + sNumMidpoints = i; + break; + } + } +} + +static void checkMidpoints(BidiIterator& lBreak, BidiState &bidi) +{ + // Check to see if our last midpoint is a start point beyond the line break. If so, + // shave it off the list, and shave off a trailing space if the previous end point isn't + // white-space: pre. + if (lBreak.obj && sNumMidpoints && sNumMidpoints%2 == 0) { + BidiIterator* midpoints = smidpoints->data(); + BidiIterator& endpoint = midpoints[sNumMidpoints-2]; + const BidiIterator& startpoint = midpoints[sNumMidpoints-1]; + BidiIterator currpoint = endpoint; + while (!currpoint.atEnd() && currpoint != startpoint && currpoint != lBreak) + currpoint.increment( bidi ); + if (currpoint == lBreak) { + // We hit the line break before the start point. Shave off the start point. + sNumMidpoints--; + if (!endpoint.obj->style()->preserveWS()) { + if (endpoint.obj->isText()) { + // Don't shave a character off the endpoint if it was from a soft hyphen. + RenderText* textObj = static_cast<RenderText*>(endpoint.obj); + if (endpoint.pos+1 < textObj->length() && + textObj->text()[endpoint.pos+1].unicode() == SOFT_HYPHEN) + return; + } + endpoint.pos--; + } + } + } +} + +static void addMidpoint(const BidiIterator& midpoint) +{ + if (!smidpoints) + return; + + if (smidpoints->size() <= sNumMidpoints) + smidpoints->resize(sNumMidpoints+10); + + BidiIterator* midpoints = smidpoints->data(); + midpoints[sNumMidpoints++] = midpoint; +} + +static void appendRunsForObject(int start, int end, RenderObject* obj, BidiState &bidi) +{ + if (start > end || obj->isFloating() || + (obj->isPositioned() && !obj->hasStaticX() && !obj->hasStaticY())) + return; + + bool haveNextMidpoint = (smidpoints && sCurrMidpoint < sNumMidpoints); + BidiIterator nextMidpoint; + if (haveNextMidpoint) + nextMidpoint = smidpoints->at(sCurrMidpoint); + if (betweenMidpoints) { + if (!(haveNextMidpoint && nextMidpoint.obj == obj)) + return; + // This is a new start point. Stop ignoring objects and + // adjust our start. + betweenMidpoints = false; + start = nextMidpoint.pos; + sCurrMidpoint++; + if (start < end) + return appendRunsForObject(start, end, obj, bidi); + } + else { + if (!smidpoints || !haveNextMidpoint || (obj != nextMidpoint.obj)) { + addRun(new (obj->renderArena()) BidiRun(start, end, obj, bidi.context, dir)); + return; + } + + // An end midpoint has been encountered within our object. We + // need to go ahead and append a run with our endpoint. + if (int(nextMidpoint.pos+1) <= end) { + betweenMidpoints = true; + sCurrMidpoint++; + if (nextMidpoint.pos != UINT_MAX) { // UINT_MAX means stop at the object and don't include any of it. + addRun(new (obj->renderArena()) + BidiRun(start, nextMidpoint.pos+1, obj, bidi.context, dir)); + return appendRunsForObject(nextMidpoint.pos+1, end, obj, bidi); + } + } + else + addRun(new (obj->renderArena()) BidiRun(start, end, obj, bidi.context, dir)); + } +} + +static void appendRun( BidiState &bidi ) +{ + if ( emptyRun ) return; +#if BIDI_DEBUG > 1 + kdDebug(6041) << "appendRun: dir="<<(int)dir<<endl; +#endif + + bool b = adjustEmbedding; + adjustEmbedding = false; + + int start = bidi.sor.pos; + RenderObject *obj = bidi.sor.obj; + while( obj && obj != bidi.eor.obj ) { + appendRunsForObject(start, obj->length(), obj, bidi); + start = 0; + obj = Bidinext( bidi.sor.par, obj, bidi ); + } + if (obj) + appendRunsForObject(start, bidi.eor.pos+1, obj, bidi); + + bidi.eor.increment( bidi ); + bidi.sor = bidi.eor; + dir = TQChar::DirON; + bidi.status.eor = TQChar::DirON; + adjustEmbedding = b; +} + +static void embed( TQChar::Direction d, BidiState &bidi ) +{ +#if BIDI_DEBUG > 1 + tqDebug("*** embed dir=%d emptyrun=%d", d, emptyRun ); +#endif + bool b = adjustEmbedding ; + adjustEmbedding = false; + if ( d == TQChar::DirPDF ) { + BidiContext *c = bidi.context->parent; + if (c) { + if ( bidi.eor != bidi.last ) { + appendRun( bidi ); + bidi.eor = bidi.last; + } + appendRun( bidi ); + emptyRun = true; + bidi.status.last = bidi.context->dir; + bidi.context->deref(); + bidi.context = c; + if(bidi.context->override) + dir = bidi.context->dir; + else + dir = TQChar::DirON; + bidi.status.lastStrong = bidi.context->dir; + } + } else { + TQChar::Direction runDir; + if( d == TQChar::DirRLE || d == TQChar::DirRLO ) + runDir = TQChar::DirR; + else + runDir = TQChar::DirL; + bool override; + if( d == TQChar::DirLRO || d == TQChar::DirRLO ) + override = true; + else + override = false; + + unsigned char level = bidi.context->level; + if ( runDir == TQChar::DirR ) { + if(level%2) // we have an odd level + level += 2; + else + level++; + } else { + if(level%2) // we have an odd level + level++; + else + level += 2; + } + + if(level < 61) { + if ( bidi.eor != bidi.last ) { + appendRun( bidi ); + bidi.eor = bidi.last; + } + appendRun( bidi ); + emptyRun = true; + + bidi.context = new BidiContext(level, runDir, bidi.context, override); + bidi.context->ref(); + dir = runDir; + bidi.status.last = runDir; + bidi.status.lastStrong = runDir; + bidi.status.eor = runDir; + } + } + adjustEmbedding = b; +} + +InlineFlowBox* RenderBlock::createLineBoxes(RenderObject* obj) +{ + // See if we have an unconstructed line box for this object that is also + // the last item on the line. + KHTMLAssert(obj->isInlineFlow() || obj == this); + RenderFlow* flow = static_cast<RenderFlow*>(obj); + + // Get the last box we made for this render object. + InlineFlowBox* box = flow->lastLineBox(); + + // If this box is constructed then it is from a previous line, and we need + // to make a new box for our line. If this box is unconstructed but it has + // something following it on the line, then we know we have to make a new box + // as well. In this situation our inline has actually been split in two on + // the same line (this can happen with very fancy language mixtures). + if (!box || box->isConstructed() || box->nextOnLine()) { + // We need to make a new box for this render object. Once + // made, we need to place it at the end of the current line. + InlineBox* newBox = obj->createInlineBox(false, obj == this); + KHTMLAssert(newBox->isInlineFlowBox()); + box = static_cast<InlineFlowBox*>(newBox); + box->setFirstLineStyleBit(m_firstLine); + + // We have a new box. Append it to the inline box we get by constructing our + // parent. If we have hit the block itself, then |box| represents the root + // inline box for the line, and it doesn't have to be appended to any parent + // inline. + if (obj != this) { + InlineFlowBox* parentBox = createLineBoxes(obj->parent()); + parentBox->addToLine(box); + } + } + + return box; +} + +InlineFlowBox* RenderBlock::constructLine(const BidiIterator &/*start*/, const BidiIterator &end) +{ + if (!sFirstBidiRun) + return 0; // We had no runs. Don't make a root inline box at all. The line is empty. + + InlineFlowBox* parentBox = 0; + for (BidiRun* r = sFirstBidiRun; r; r = r->nextRun) { + // Create a box for our object. + r->box = r->obj->createInlineBox(r->obj->isPositioned(), false); + + // If we have no parent box yet, or if the run is not simply a sibling, + // then we need to construct inline boxes as necessary to properly enclose the + // run's inline box. + if (!parentBox || (parentBox->object() != r->obj->parent())) + // Create new inline boxes all the way back to the appropriate insertion point. + parentBox = createLineBoxes(r->obj->parent()); + + // Append the inline box to this line. + parentBox->addToLine(r->box); + } + + // We should have a root inline box. It should be unconstructed and + // be the last continuation of our line list. + KHTMLAssert(lastLineBox() && !lastLineBox()->isConstructed()); + + // Set bits on our inline flow boxes that indicate which sides should + // paint borders/margins/padding. This knowledge will ultimately be used when + // we determine the horizontal positions and widths of all the inline boxes on + // the line. + RenderObject* endObject = 0; + bool lastLine = !end.obj; + if (end.obj && end.pos == 0) + endObject = end.obj; + lastLineBox()->determineSpacingForFlowBoxes(lastLine, endObject); + + // Now mark the line boxes as being constructed. + lastLineBox()->setConstructed(); + + // Return the last line. + return lastLineBox(); +} + +void RenderBlock::computeHorizontalPositionsForLine(InlineFlowBox* lineBox, BidiState &bidi) +{ + // First determine our total width. + int totWidth = lineBox->getFlowSpacingWidth(); + BidiRun* r = 0; + for (r = sFirstBidiRun; r; r = r->nextRun) { + if (r->obj->isPositioned()) + continue; // Positioned objects are only participating to figure out their + // correct static x position. They have no effect on the width. + if (r->obj->isText()) + r->box->setWidth(static_cast<RenderText *>(r->obj)->width(r->start, r->stop-r->start, m_firstLine)); + else if (!r->obj->isInlineFlow()) { + r->obj->calcWidth(); + r->box->setWidth(r->obj->width()); + totWidth += r->obj->marginLeft() + r->obj->marginRight(); + } + totWidth += r->box->width(); + } + + // Armed with the total width of the line (without justification), + // we now examine our text-align property in order to determine where to position the + // objects horizontally. The total width of the line can be increased if we end up + // justifying text. + int x = leftOffset(m_height); + int availableWidth = lineWidth(m_height); + switch(style()->textAlign()) { + case LEFT: + case KHTML_LEFT: + numSpaces = 0; + break; + case JUSTIFY: + if (numSpaces != 0 && !bidi.current.atEnd() && !bidi.current.obj->isBR() ) + break; + // fall through + case TAAUTO: + numSpaces = 0; + // for right to left fall through to right aligned + if (bidi.context->basicDir == TQChar::DirL) + break; + case RIGHT: + case KHTML_RIGHT: + x += availableWidth - totWidth; + numSpaces = 0; + break; + case CENTER: + case KHTML_CENTER: + int xd = (availableWidth - totWidth)/2; + x += xd >0 ? xd : 0; + numSpaces = 0; + break; + } + + if (numSpaces > 0) { + for (r = sFirstBidiRun; r; r = r->nextRun) { + int spaceAdd = 0; + if (numSpaces > 0 && r->obj->isText()) { + // get the number of spaces in the run + int spaces = 0; + for ( int i = r->start; i < r->stop; i++ ) { + const TQChar c = static_cast<RenderText *>(r->obj)->text()[i]; + if (c.category() == TQChar::Separator_Space || c == '\n') + spaces++; + } + + KHTMLAssert(spaces <= numSpaces); + + // Only justify text with white-space: normal. + if (r->obj->style()->whiteSpace() == NORMAL) { + spaceAdd = (availableWidth - totWidth)*spaces/numSpaces; + static_cast<InlineTextBox*>(r->box)->setSpaceAdd(spaceAdd); + totWidth += spaceAdd; + } + numSpaces -= spaces; + } + } + } + + // The widths of all runs are now known. We can now place every inline box (and + // compute accurate widths for the inline flow boxes). + int rightPos = lineBox->placeBoxesHorizontally(x); + if (rightPos > m_overflowWidth) + m_overflowWidth = rightPos; // FIXME: Work for rtl overflow also. + if (x < 0) + m_overflowLeft = kMin(m_overflowLeft, x); +} + +void RenderBlock::computeVerticalPositionsForLine(InlineFlowBox* lineBox) +{ + lineBox->verticallyAlignBoxes(m_height); +// lineBox->setBlockHeight(m_height); + + // Check for page-breaks + if (canvas()->pagedMode() && !lineBox->afterPageBreak()) + // If we get a page-break we might need to redo the line-break + if (clearLineOfPageBreaks(lineBox) && hasFloats()) return; + + // See if the line spilled out. If so set overflow height accordingly. + int bottomOfLine = lineBox->bottomOverflow(); + if (bottomOfLine > m_height && bottomOfLine > m_overflowHeight) + m_overflowHeight = bottomOfLine; + + bool beforeContent = true; + + // Now make sure we place replaced render objects correctly. + for (BidiRun* r = sFirstBidiRun; r; r = r->nextRun) { + + // For positioned placeholders, cache the static Y position an object with non-inline display would have. + // Either it is unchanged if it comes before any real linebox, or it must clear the current line (already accounted in m_height). + // This value will be picked up by position() if relevant. + if (r->obj->isPositioned()) + r->box->setYPos( beforeContent && r->obj->isBox() ? static_cast<RenderBox*>(r->obj)->staticY() : m_height ); + else if (beforeContent) + beforeContent = false; + + // Position is used to properly position both replaced elements and + // to update the static normal flow x/y of positioned elements. + r->obj->position(r->box, r->start, r->stop - r->start, r->level%2); + } +} + +bool RenderBlock::clearLineOfPageBreaks(InlineFlowBox* lineBox) +{ + bool doPageBreak = false; + // Check for physical page-breaks + int xpage = crossesPageBreak(lineBox->topOverflow(), lineBox->bottomOverflow()); + if (xpage) { +#ifdef PAGE_DEBUG + kdDebug(6040) << renderName() << " Line crosses to page " << xpage << endl; + kdDebug(6040) << renderName() << " at pos " << lineBox->yPos() << " height " << lineBox->height() << endl; +#endif + + doPageBreak = true; + // check page-break-inside + if (!style()->pageBreakInside()) { + if (parent()->canClear(this, PageBreakNormal)) { + setNeedsPageClear(true); + doPageBreak = false; + } +#ifdef PAGE_DEBUG + else + kdDebug(6040) << "Ignoring page-break-inside: avoid" << endl; +#endif + } + // check orphans + int orphans = 0; + InlineRunBox* box = lineBox->prevLineBox(); + while (box && orphans < style()->orphans()) { + orphans++; + box = box->prevLineBox(); + } + + if (orphans == 0) { + setNeedsPageClear(true); + doPageBreak = false; + } else + if (orphans < style()->orphans() ) { +#ifdef PAGE_DEBUG + kdDebug(6040) << "Orphans: " << orphans << endl; +#endif + // Orphans is a level 2 page-break rule and can be broken only + // if the break is physically required. + if (parent()->canClear(this, PageBreakHarder)) { + // move block instead + setNeedsPageClear(true); + doPageBreak = false; + } +#ifdef PAGE_DEBUG + else + kdDebug(6040) << "Ignoring violated orphans" << endl; +#endif + } + if (doPageBreak) { + int pTop = pageTopAfter(lineBox->yPos()); + + m_height = pTop; + lineBox->setAfterPageBreak(true); + lineBox->verticallyAlignBoxes(m_height); + if (lineBox->yPos() < pTop) { + // ### serious crap. render_line is sometimes placing lines too high + kdDebug(6040) << "page top overflow by repositioned line" << endl; + int heightIncrease = pTop - lineBox->yPos(); + m_height = pTop + heightIncrease; + lineBox->verticallyAlignBoxes(m_height); + } +#ifdef PAGE_DEBUG + kdDebug(6040) << "Cleared line " << lineBox->yPos() - oldYPos << "px" << endl; +#endif + setContainsPageBreak(true); + } + } + return doPageBreak; +} + +// collects one line of the paragraph and transforms it to visual order +void RenderBlock::bidiReorderLine(const BidiIterator &start, const BidiIterator &end, BidiState &bidi) +{ + if ( start == end ) { + if ( start.current() == '\n' ) { + m_height += lineHeight( m_firstLine ); + } + return; + } + +#if BIDI_DEBUG > 1 + kdDebug(6041) << "reordering Line from " << start.obj << "/" << start.pos << " to " << end.obj << "/" << end.pos << endl; +#endif + + sFirstBidiRun = 0; + sLastBidiRun = 0; + sBidiRunCount = 0; + + // context->ref(); + + dir = TQChar::DirON; + emptyRun = true; + + numSpaces = 0; + + bidi.current = start; + bidi.last = bidi.current; + bool atEnd = false; + while( 1 ) { + + TQChar::Direction dirCurrent; + if (atEnd) { + //kdDebug(6041) << "atEnd" << endl; + BidiContext *c = bidi.context; + if ( bidi.current.atEnd()) + while ( c->parent ) + c = c->parent; + dirCurrent = c->dir; + } else { + dirCurrent = bidi.current.direction(); + } + +#ifndef QT_NO_UNICODETABLES + +#if BIDI_DEBUG > 1 + 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; +#endif + + switch(dirCurrent) { + + // embedding and overrides (X1-X9 in the Bidi specs) + case TQChar::DirRLE: + case TQChar::DirLRE: + case TQChar::DirRLO: + case TQChar::DirLRO: + case TQChar::DirPDF: + embed( dirCurrent, bidi ); + break; + + // strong types + case TQChar::DirL: + if(dir == TQChar::DirON) + dir = TQChar::DirL; + switch(bidi.status.last) + { + case TQChar::DirL: + bidi.eor = bidi.current; bidi.status.eor = TQChar::DirL; break; + case TQChar::DirR: + case TQChar::DirAL: + case TQChar::DirEN: + case TQChar::DirAN: + appendRun( bidi ); + break; + case TQChar::DirES: + case TQChar::DirET: + case TQChar::DirCS: + case TQChar::DirBN: + case TQChar::DirB: + case TQChar::DirS: + case TQChar::DirWS: + case TQChar::DirON: + if( bidi.status.eor != TQChar::DirL ) { + //last stuff takes embedding dir + if(bidi.context->dir == TQChar::DirL || bidi.status.lastStrong == TQChar::DirL) { + if ( bidi.status.eor != TQChar::DirEN && bidi.status.eor != TQChar::DirAN && bidi.status.eor != TQChar::DirON ) + appendRun( bidi ); + dir = TQChar::DirL; + bidi.eor = bidi.current; + bidi.status.eor = TQChar::DirL; + } else { + if ( bidi.status.eor == TQChar::DirEN || bidi.status.eor == TQChar::DirAN ) + { + dir = bidi.status.eor; + appendRun( bidi ); + } + dir = TQChar::DirR; + bidi.eor = bidi.last; + appendRun( bidi ); + dir = TQChar::DirL; + bidi.status.eor = TQChar::DirL; + } + } else { + bidi.eor = bidi.current; bidi.status.eor = TQChar::DirL; + } + default: + break; + } + bidi.status.lastStrong = TQChar::DirL; + break; + case TQChar::DirAL: + case TQChar::DirR: + if(dir == TQChar::DirON) dir = TQChar::DirR; + switch(bidi.status.last) + { + case TQChar::DirR: + case TQChar::DirAL: + bidi.eor = bidi.current; bidi.status.eor = TQChar::DirR; break; + case TQChar::DirL: + case TQChar::DirEN: + case TQChar::DirAN: + appendRun( bidi ); + dir = TQChar::DirR; + bidi.eor = bidi.current; + bidi.status.eor = TQChar::DirR; + break; + case TQChar::DirES: + case TQChar::DirET: + case TQChar::DirCS: + case TQChar::DirBN: + case TQChar::DirB: + case TQChar::DirS: + case TQChar::DirWS: + case TQChar::DirON: + if( !(bidi.status.eor == TQChar::DirR) && !(bidi.status.eor == TQChar::DirAL) ) { + //last stuff takes embedding dir + if(bidi.context->dir == TQChar::DirR || bidi.status.lastStrong == TQChar::DirR + || bidi.status.lastStrong == TQChar::DirAL) { + appendRun( bidi ); + dir = TQChar::DirR; + bidi.eor = bidi.current; + bidi.status.eor = TQChar::DirR; + } else { + dir = TQChar::DirL; + bidi.eor = bidi.last; + appendRun( bidi ); + dir = TQChar::DirR; + bidi.status.eor = TQChar::DirR; + } + } else { + bidi.eor = bidi.current; bidi.status.eor = TQChar::DirR; + } + default: + break; + } + bidi.status.lastStrong = dirCurrent; + break; + + // weak types: + + case TQChar::DirNSM: + // ### if @sor, set dir to dirSor + break; + case TQChar::DirEN: + if(!(bidi.status.lastStrong == TQChar::DirAL)) { + // if last strong was AL change EN to AN + if(dir == TQChar::DirON) { + dir = TQChar::DirL; + } + switch(bidi.status.last) + { + case TQChar::DirET: + if ( bidi.status.lastStrong == TQChar::DirR || bidi.status.lastStrong == TQChar::DirAL ) { + appendRun( bidi ); + dir = TQChar::DirEN; + bidi.status.eor = TQChar::DirEN; + } + // fall through + case TQChar::DirEN: + case TQChar::DirL: + bidi.eor = bidi.current; + bidi.status.eor = dirCurrent; + break; + case TQChar::DirR: + case TQChar::DirAL: + case TQChar::DirAN: + appendRun( bidi ); + bidi.status.eor = TQChar::DirEN; + dir = TQChar::DirEN; break; + case TQChar::DirES: + case TQChar::DirCS: + if(bidi.status.eor == TQChar::DirEN) { + bidi.eor = bidi.current; break; + } + case TQChar::DirBN: + case TQChar::DirB: + case TQChar::DirS: + case TQChar::DirWS: + case TQChar::DirON: + if(bidi.status.eor == TQChar::DirR) { + // neutrals go to R + bidi.eor = bidi.last; + appendRun( bidi ); + dir = TQChar::DirEN; + bidi.status.eor = TQChar::DirEN; + } + else if( bidi.status.eor == TQChar::DirL || + (bidi.status.eor == TQChar::DirEN && bidi.status.lastStrong == TQChar::DirL)) { + bidi.eor = bidi.current; bidi.status.eor = dirCurrent; + } else { + // numbers on both sides, neutrals get right to left direction + if(dir != TQChar::DirL) { + appendRun( bidi ); + bidi.eor = bidi.last; + dir = TQChar::DirR; + appendRun( bidi ); + dir = TQChar::DirEN; + bidi.status.eor = TQChar::DirEN; + } else { + bidi.eor = bidi.current; bidi.status.eor = dirCurrent; + } + } + default: + break; + } + break; + } + case TQChar::DirAN: + dirCurrent = TQChar::DirAN; + if(dir == TQChar::DirON) dir = TQChar::DirAN; + switch(bidi.status.last) + { + case TQChar::DirL: + case TQChar::DirAN: + bidi.eor = bidi.current; bidi.status.eor = TQChar::DirAN; break; + case TQChar::DirR: + case TQChar::DirAL: + case TQChar::DirEN: + appendRun( bidi ); + dir = TQChar::DirAN; bidi.status.eor = TQChar::DirAN; + break; + case TQChar::DirCS: + if(bidi.status.eor == TQChar::DirAN) { + bidi.eor = bidi.current; break; + } + case TQChar::DirES: + case TQChar::DirET: + case TQChar::DirBN: + case TQChar::DirB: + case TQChar::DirS: + case TQChar::DirWS: + case TQChar::DirON: + if(bidi.status.eor == TQChar::DirR) { + // neutrals go to R + bidi.eor = bidi.last; + appendRun( bidi ); + dir = TQChar::DirAN; + bidi.status.eor = TQChar::DirAN; + } else if( bidi.status.eor == TQChar::DirL || + (bidi.status.eor == TQChar::DirEN && bidi.status.lastStrong == TQChar::DirL)) { + bidi.eor = bidi.current; bidi.status.eor = dirCurrent; + } else { + // numbers on both sides, neutrals get right to left direction + if(dir != TQChar::DirL) { + appendRun( bidi ); + bidi.eor = bidi.last; + dir = TQChar::DirR; + appendRun( bidi ); + dir = TQChar::DirAN; + bidi.status.eor = TQChar::DirAN; + } else { + bidi.eor = bidi.current; bidi.status.eor = dirCurrent; + } + } + default: + break; + } + break; + case TQChar::DirES: + case TQChar::DirCS: + break; + case TQChar::DirET: + if(bidi.status.last == TQChar::DirEN) { + dirCurrent = TQChar::DirEN; + bidi.eor = bidi.current; bidi.status.eor = dirCurrent; + break; + } + break; + + // boundary neutrals should be ignored + case TQChar::DirBN: + break; + // neutrals + case TQChar::DirB: + // ### what do we do with newline and paragraph seperators that come to here? + break; + case TQChar::DirS: + // ### implement rule L1 + break; + case TQChar::DirWS: + break; + case TQChar::DirON: + break; + default: + break; + } + + //cout << " after: dir=" << // dir << " current=" << dirCurrent << " last=" << status.last << " eor=" << status.eor << " lastStrong=" << status.lastStrong << " embedding=" << context->dir << endl; + + if(bidi.current.atEnd()) break; + + // set status.last as needed. + switch(dirCurrent) + { + case TQChar::DirET: + case TQChar::DirES: + case TQChar::DirCS: + case TQChar::DirS: + case TQChar::DirWS: + case TQChar::DirON: + switch(bidi.status.last) + { + case TQChar::DirL: + case TQChar::DirR: + case TQChar::DirAL: + case TQChar::DirEN: + case TQChar::DirAN: + bidi.status.last = dirCurrent; + break; + default: + bidi.status.last = TQChar::DirON; + } + break; + case TQChar::DirNSM: + case TQChar::DirBN: + // ignore these + break; + case TQChar::DirEN: + if ( bidi.status.last == TQChar::DirL ) { + break; + } + // fall through + default: + bidi.status.last = dirCurrent; + } +#endif + + if ( atEnd ) break; + bidi.last = bidi.current; + + if ( emptyRun ) { + bidi.sor = bidi.current; + bidi.eor = bidi.current; + emptyRun = false; + } + + // this causes the operator ++ to open and close embedding levels as needed + // for the CSS unicode-bidi property + adjustEmbedding = true; + bidi.current.increment( bidi ); + adjustEmbedding = false; + + if ( bidi.current == end ) { + if ( emptyRun ) + break; + atEnd = true; + } + } + +#if BIDI_DEBUG > 0 + kdDebug(6041) << "reached end of line current=" << current.obj << "/" << current.pos + << ", eor=" << eor.obj << "/" << eor.pos << endl; +#endif + if ( !emptyRun && bidi.sor != bidi.current ) { + bidi.eor = bidi.last; + appendRun( bidi ); + } + + // reorder line according to run structure... + + // first find highest and lowest levels + uchar levelLow = 128; + uchar levelHigh = 0; + BidiRun *r = sFirstBidiRun; + while ( r ) { + if ( r->level > levelHigh ) + levelHigh = r->level; + if ( r->level < levelLow ) + levelLow = r->level; + r = r->nextRun; + } + + // implements reordering of the line (L2 according to Bidi spec): + // L2. From the highest level found in the text to the lowest odd level on each line, + // reverse any contiguous sequence of characters that are at that level or higher. + + // reversing is only done up to the lowest odd level + if( !(levelLow%2) ) levelLow++; + +#if BIDI_DEBUG > 0 + kdDebug(6041) << "lineLow = " << (uint)levelLow << ", lineHigh = " << (uint)levelHigh << endl; + kdDebug(6041) << "logical order is:" << endl; + TQPtrListIterator<BidiRun> it2(runs); + BidiRun *r2; + for ( ; (r2 = it2.current()); ++it2 ) + kdDebug(6041) << " " << r2 << " start=" << r2->start << " stop=" << r2->stop << " level=" << (uint)r2->level << endl; +#endif + + int count = sBidiRunCount - 1; + + // do not reverse for visually ordered web sites + if(!style()->visuallyOrdered()) { + while(levelHigh >= levelLow) { + int i = 0; + BidiRun* currRun = sFirstBidiRun; + while ( i < count ) { + while(i < count && currRun && currRun->level < levelHigh) { + i++; + currRun = currRun->nextRun; + } + int start = i; + while(i <= count && currRun && currRun->level >= levelHigh) { + i++; + currRun = currRun->nextRun; + } + int end = i-1; + reverseRuns(start, end); + } + levelHigh--; + } + } + +#if BIDI_DEBUG > 0 + kdDebug(6041) << "visual order is:" << endl; + for (BidiRun* curr = sFirstRun; curr; curr = curr->nextRun) + kdDebug(6041) << " " << curr << endl; +#endif +} + +void RenderBlock::layoutInlineChildren(bool relayoutChildren, int breakBeforeLine) +{ + BidiState bidi; + + m_overflowHeight = 0; + + invalidateVerticalPositions(); +#ifdef DEBUG_LAYOUT + TQTime qt; + qt.start(); + kdDebug( 6040 ) << renderName() << " layoutInlineChildren( " << this <<" )" << endl; +#endif +#if BIDI_DEBUG > 1 || defined( DEBUG_LINEBREAKS ) + kdDebug(6041) << " ------- bidi start " << this << " -------" << endl; +#endif + + m_height = borderTop() + paddingTop(); + int toAdd = borderBottom() + paddingBottom(); + if (m_layer && scrollsOverflowX() && style()->height().isVariable()) + toAdd += m_layer->horizontalScrollbarHeight(); + + // Clear out our line boxes. + deleteInlineBoxes(); + + // Text truncation only kicks in if your overflow isn't visible and your + // text-overflow-mode isn't clip. + bool hasTextOverflow = style()->textOverflow() && hasOverflowClip(); + + // Walk all the lines and delete our ellipsis line boxes if they exist. + if (hasTextOverflow) + deleteEllipsisLineBoxes(); + + if (firstChild()) { + // layout replaced elements + RenderObject *o = first( this, bidi, false ); + while ( o ) { + if (o->markedForRepaint()) { + o->repaintDuringLayout(); + o->setMarkedForRepaint(false); + } + if (o->isReplaced() || o->isFloating() || o->isPositioned()) { + // clear the placeHolderBox + if (o->isBox()) + static_cast<RenderBox*>(o)->RenderBox::deleteInlineBoxes(); + + //kdDebug(6041) << "layouting replaced or floating child" << endl; + if (relayoutChildren || o->style()->width().isPercent() || o->style()->height().isPercent()) + o->setChildNeedsLayout(true, false); + if (o->isPositioned()) + o->containingBlock()->insertPositionedObject(o); + else + o->layoutIfNeeded(); + } + else { + o->deleteInlineBoxes(); + o->setNeedsLayout(false); + } + o = Bidinext( this, o, bidi, false ); + } + + BidiContext *startEmbed; + if( style()->direction() == LTR ) { + startEmbed = new BidiContext( 0, TQChar::DirL ); + bidi.status.eor = TQChar::DirL; + } else { + startEmbed = new BidiContext( 1, TQChar::DirR ); + bidi.status.eor = TQChar::DirR; + } + startEmbed->ref(); + + bidi.status.lastStrong = TQChar::DirON; + bidi.status.last = TQChar::DirON; + + bidi.context = startEmbed; + adjustEmbedding = true; + BidiIterator start(this, first(this, bidi), 0); + adjustEmbedding = false; + BidiIterator end = start; + + m_firstLine = true; + + if (!smidpoints) + smidpoints = new TQMemArray<BidiIterator>; + + sNumMidpoints = 0; + sCurrMidpoint = 0; + sCompactFirstBidiRun = sCompactLastBidiRun = 0; + sCompactBidiRunCount = 0; + + previousLineBrokeAtBR = true; + + int lineCount = 0; + bool pagebreakHint = false; + int oldPos = 0; + BidiIterator oldStart; + BidiState oldBidi; + const bool pagedMode = canvas()->pagedMode(); +// + while( !end.atEnd() ) { + start = end; + lineCount++; + betweenMidpoints = false; + isLineEmpty = true; + pagebreakHint = false; + if (pagedMode) { + oldPos = m_height; + oldStart = start; + oldBidi = bidi; + } + if (lineCount == breakBeforeLine) { + m_height = pageTopAfter(oldPos); + pagebreakHint = true; + } +redo_linebreak: + end = findNextLineBreak(start, bidi); + if( start.atEnd() ) break; + if (!isLineEmpty) { + bidiReorderLine(start, end, bidi); + + // Now that the runs have been ordered, we create the line boxes. + // At the same time we figure out where border/padding/margin should be applied for + // inline flow boxes. + + if (sBidiRunCount) { + InlineFlowBox* lineBox = constructLine(start, end); + if (lineBox) { + if (pagebreakHint) lineBox->setAfterPageBreak(true); + + // Now we position all of our text runs horizontally. + computeHorizontalPositionsForLine(lineBox, bidi); + + // Now position our text runs vertically. + computeVerticalPositionsForLine(lineBox); + + deleteBidiRuns(renderArena()); + + if (lineBox->afterPageBreak() && hasFloats() && !pagebreakHint) { + start = end = oldStart; + bidi = oldBidi; + m_height = pageTopAfter(oldPos); + deleteLastLineBox(renderArena()); + pagebreakHint = true; + goto redo_linebreak; + } + } + } + + if( end == start || (end.obj && end.obj->isBR() && !start.obj->isBR() ) ) { + adjustEmbedding = true; + end.increment(bidi); + adjustEmbedding = false; + } else if (end.obj && end.obj->style()->preserveLF() && end.current() == TQChar('\n')) { + adjustEmbedding = true; + end.increment(bidi); + adjustEmbedding = false; + } + + m_firstLine = false; + newLine(); + } + + sNumMidpoints = 0; + sCurrMidpoint = 0; + sCompactFirstBidiRun = sCompactLastBidiRun = 0; + sCompactBidiRunCount = 0; + } + startEmbed->deref(); + //embed->deref(); + } + + sNumMidpoints = 0; + sCurrMidpoint = 0; + + // If we violate widows page-breaking rules, we set a hint and relayout. + // Note that the widows rule might still be violated afterwards if the lines have become wider + if (canvas()->pagedMode() && containsPageBreak() && breakBeforeLine == 0) + { + int orphans = 0; + int widows = 0; + // find breaking line + InlineRunBox* lineBox = firstLineBox(); + while (lineBox) { + if (lineBox->isInlineFlowBox()) { + InlineFlowBox* flowBox = static_cast<InlineFlowBox*>(lineBox); + if (flowBox->afterPageBreak()) break; + } + orphans++; + lineBox = lineBox->nextLineBox(); + } + InlineFlowBox* pageBreaker = static_cast<InlineFlowBox*>(lineBox); + if (!pageBreaker) goto no_break; + // count widows + while (lineBox && widows < style()->widows()) { + if (lineBox->hasTextChildren()) + widows++; + lineBox = lineBox->nextLineBox(); + } + // Widows rule broken and more orphans left to use + if (widows < style()->widows() && orphans > 0) { + kdDebug( 6040 ) << "Widows: " << widows << endl; + // Check if we have enough orphans after respecting widows count + int newOrphans = orphans - (style()->widows() - widows); + if (newOrphans < style()->orphans()) { + if (parent()->canClear(this,PageBreakHarder)) { + // Relayout to remove incorrect page-break + setNeedsPageClear(true); + setContainsPageBreak(false); + layoutInlineChildren(relayoutChildren, -1); + return; + } + } else { + // Set hint and try again + layoutInlineChildren(relayoutChildren, newOrphans+1); + return; + } + } + } + no_break: + + // in case we have a float on the last line, it might not be positioned up to now. + // This has to be done before adding in the bottom border/padding, or the float will + // include the padding incorrectly. -dwh + positionNewFloats(); + + // Now add in the bottom border/padding. + m_height += toAdd; + + // Always make sure this is at least our height. + m_overflowHeight = kMax(m_height, m_overflowHeight); + + // See if any lines spill out of the block. If so, we need to update our overflow width. + checkLinesForOverflow(); + + // See if we have any lines that spill out of our block. If we do, then we will + // possibly need to truncate text. + if (hasTextOverflow) + checkLinesForTextOverflow(); + +#if BIDI_DEBUG > 1 + kdDebug(6041) << " ------- bidi end " << this << " -------" << endl; +#endif + //kdDebug() << "RenderBlock::layoutInlineChildren time used " << qt.elapsed() << endl; + //kdDebug(6040) << "height = " << m_height <<endl; +} + +static void setStaticPosition( RenderBlock* p, RenderObject *o, bool *needToSetStaticX = 0, bool *needToSetStaticY = 0 ) +{ + // If our original display wasn't an inline type, then we can + // determine our static x position now. + bool nssx, nssy; + bool isInlineType = o->style()->isOriginalDisplayInlineType(); + nssx = o->hasStaticX(); + if (nssx && !isInlineType && o->isBox()) { + static_cast<RenderBox*>(o)->setStaticX(o->parent()->style()->direction() == LTR ? + p->borderLeft()+p->paddingLeft() : + p->borderRight()+p->paddingRight()); + nssx = false; + } + + // If our original display was an INLINE type, then we can + // determine our static y position now. + nssy = o->hasStaticY(); + if (nssy && o->isBox()) { + static_cast<RenderBox*>(o)->setStaticY(p->height()); + nssy = !isInlineType; + } + if (needToSetStaticX) *needToSetStaticX = nssx; + if (needToSetStaticY) *needToSetStaticY = nssy; +} + +BidiIterator RenderBlock::findNextLineBreak(BidiIterator &start, BidiState &bidi) +{ + int width = lineWidth(m_height); + int w = 0; + int tmpW = 0; +#ifdef DEBUG_LINEBREAKS + kdDebug(6041) << "findNextLineBreak: line at " << m_height << " line width " << width << endl; + kdDebug(6041) << "sol: " << start.obj << " " << start.pos << endl; +#endif + + BidiIterator posStart = start; + bool hadPosStart = false; + + // eliminate spaces at beginning of line + // remove leading spaces. Any inline flows we encounter will be empty and should also + // be skipped. + while (!start.atEnd() && (start.obj->isInlineFlow() || (!start.obj->style()->preserveWS() && !start.obj->isBR() && +#ifndef QT_NO_UNICODETABLES + ( (start.current().unicode() == (ushort)0x0020) || // ASCII space + (start.current().unicode() == (ushort)0x0009) || // ASCII tab + (start.current().unicode() == (ushort)0x000A) || // ASCII line feed + (start.current().unicode() == (ushort)0x000C) || // ASCII form feed + (start.current().unicode() == (ushort)0x200B) || // Zero-width space + start.obj->isFloatingOrPositioned() ) +#else + ( start.current() == ' ' || start.current() == '\n' || start.obj->isFloatingOrPositioned() ) +#endif + ))) { + if( start.obj->isFloatingOrPositioned() ) { + RenderObject *o = start.obj; + // add to special objects... + if (o->isFloating()) { + insertFloatingObject(o); + positionNewFloats(); + width = lineWidth(m_height); + } + else if (o->isBox() && o->isPositioned()) { + if (!hadPosStart) { + hadPosStart = true; + posStart = start; + // end + addMidpoint(BidiIterator(0, o, 0)); + } else { + // start/end + addMidpoint(BidiIterator(0, o, 0)); + addMidpoint(BidiIterator(0, o, 0)); + } + setStaticPosition(this, o); + } + } + adjustEmbedding = true; + start.increment(bidi, false /*skipInlines*/); + adjustEmbedding = false; + } + + if (hadPosStart && !start.atEnd()) + addMidpoint(start); + + if ( start.atEnd() ){ + if (hadPosStart) { + start = posStart; + posStart.increment(bidi); + return posStart; + } + return start; + } + + // This variable says we have encountered an object after which initial whitespace should be ignored (e.g. InlineFlows at the begining of a line). + // Either we have nothing to do, if there is no whitespace after the object... or we have to enter the ignoringSpaces state. + // This dilemma will be resolved when we have a peek at the next object. + bool checkShouldIgnoreInitialWhitespace = false; + + // This variable is used only if whitespace isn't set to PRE, and it tells us whether + // or not we are currently ignoring whitespace. + bool ignoringSpaces = false; + BidiIterator ignoreStart; + + // This variable tracks whether the very last character we saw was a space. We use + // this to detect when we encounter a second space so we know we have to terminate + // a run. + bool currentCharacterIsSpace = false; + RenderObject* trailingSpaceObject = 0; + + BidiIterator lBreak = start; + + InlineMinMaxIterator it(start.par, start.obj, start.endOfInline, false /*skipPositioned*/); + InlineMinMaxIterator lastIt = it; + int pos = start.pos; + + bool prevLineBrokeCleanly = previousLineBrokeAtBR; + previousLineBrokeAtBR = false; + + RenderObject* o = it.current; + while( o ) { +#ifdef DEBUG_LINEBREAKS + kdDebug(6041) << "new object "<< o <<" width = " << w <<" tmpw = " << tmpW << endl; +#endif + if(o->isBR()) { + if( w + tmpW <= width ) { + lBreak.obj = o; + lBreak.pos = 0; + lBreak.endOfInline = it.endOfInline; + + // A <br> always breaks a line, so don't let the line be collapsed + // away. Also, the space at the end of a line with a <br> does not + // get collapsed away. It only does this if the previous line broke + // cleanly. Otherwise the <br> has no effect on whether the line is + // empty or not. + if (prevLineBrokeCleanly) + isLineEmpty = false; + trailingSpaceObject = 0; + previousLineBrokeAtBR = true; + + if (!isLineEmpty) { + // only check the clear status for non-empty lines. + EClear clear = o->style()->clear(); + if(clear != CNONE) + m_clearStatus = (EClear) (m_clearStatus | clear); + } + } + goto end; + } + if( o->isFloatingOrPositioned() ) { + // add to special objects... + if(o->isFloating()) { + insertFloatingObject(o); + // check if it fits in the current line. + // If it does, position it now, otherwise, position + // it after moving to next line (in newLine() func) + if (o->width()+o->marginLeft()+o->marginRight()+w+tmpW <= width) { + positionNewFloats(); + width = lineWidth(m_height); + } + } + else if (o->isPositioned()) { + bool needToSetStaticX; + bool needToSetStaticY; + setStaticPosition(this, o, &needToSetStaticX, &needToSetStaticY); + + // If we're ignoring spaces, we have to stop and include this object and + // then start ignoring spaces again. + if (needToSetStaticX || needToSetStaticY) { + trailingSpaceObject = 0; + ignoreStart.obj = o; + ignoreStart.pos = 0; + if (ignoringSpaces) { + addMidpoint(ignoreStart); // Stop ignoring spaces. + addMidpoint(ignoreStart); // Start ignoring again. + } + } + } + } else if (o->isInlineFlow()) { + tmpW += getBorderPaddingMargin(o, it.endOfInline); + if (isLineEmpty) isLineEmpty = !tmpW; + if (o->isWordBreak()) { // #### shouldn't be an InlineFlow! + w += tmpW; + tmpW = 0; + lBreak.obj = o; + lBreak.pos = 0; + lBreak.endOfInline = it.endOfInline; + } else if (!it.endOfInline) { + // this is the beginning of the line (other non-initial inline flows are handled directly when + // incrementing the iterator below). We want to skip initial whitespace as much as possible. + checkShouldIgnoreInitialWhitespace = true; + } + } else if ( o->isReplaced() || o->isGlyph() ) { + EWhiteSpace currWS = o->style()->whiteSpace(); + EWhiteSpace lastWS = lastIt.current->style()->whiteSpace(); + + // WinIE marquees have different whitespace characteristics by default when viewed from + // the outside vs. the inside. Text inside is NOWRAP, and so we altered the marquee's + // style to reflect this, but we now have to get back to the original whitespace value + // for the marquee when checking for line breaking. + if (o->isHTMLMarquee() && o->layer() && o->layer()->marquee()) + currWS = o->layer()->marquee()->whiteSpace(); + if (lastIt.current->isHTMLMarquee() && lastIt.current->layer() && lastIt.current->layer()->marquee()) + lastWS = lastIt.current->layer()->marquee()->whiteSpace(); + + // Break on replaced elements if either has normal white-space. + if (currWS == NORMAL || lastWS == NORMAL) { + w += tmpW; + tmpW = 0; + lBreak.obj = o; + lBreak.pos = 0; + lBreak.endOfInline = false; + } + + tmpW += o->width()+o->marginLeft()+o->marginRight(); + if (ignoringSpaces) { + BidiIterator startMid( 0, o, 0 ); + addMidpoint(startMid); + } + isLineEmpty = false; + ignoringSpaces = false; + currentCharacterIsSpace = false; + trailingSpaceObject = 0; + + if (o->isListMarker() && o->style()->listStylePosition() == OUTSIDE) { + checkShouldIgnoreInitialWhitespace = true; + } + } else if ( o->isText() ) { + RenderText *t = static_cast<RenderText *>(o); + int strlen = t->stringLength(); + int len = strlen - pos; + TQChar *str = t->text(); + + const Font *f = t->htmlFont( m_firstLine ); + // proportional font, needs a bit more work. + int lastSpace = pos; + bool autoWrap = o->style()->autoWrap(); + bool preserveWS = o->style()->preserveWS(); + bool preserveLF = o->style()->preserveLF(); +#ifdef APPLE_CHANGES + int wordSpacing = o->style()->wordSpacing(); +#endif + bool nextIsSoftBreakable = false; + bool checkBreakWord = autoWrap && (o->style()->wordWrap() == WWBREAKWORD); + + while(len) { + bool previousCharacterIsSpace = currentCharacterIsSpace; + bool isSoftBreakable = nextIsSoftBreakable; + nextIsSoftBreakable = false; + const TQChar c = str[pos]; + currentCharacterIsSpace = c == ' '; + checkBreakWord &= !w; // only break words when no other breaking opportunity exists earlier + // on the line (even within the text object we are currently processing) + + if (preserveWS || !currentCharacterIsSpace) + isLineEmpty = false; + + // Check for soft hyphens. Go ahead and ignore them. + if (c.unicode() == SOFT_HYPHEN && pos > 0) { + nextIsSoftBreakable = true; + if (!ignoringSpaces) { + // Ignore soft hyphens + BidiIterator endMid(0, o, pos-1); + addMidpoint(endMid); + + // Add the width up to but not including the hyphen. + tmpW += t->width(lastSpace, pos - lastSpace, f); + + // For wrapping text only, include the hyphen. We need to ensure it will fit + // on the line if it shows when we break. + if (o->style()->autoWrap()) + tmpW += t->width(pos, 1, f); + + BidiIterator startMid(0, o, pos+1); + addMidpoint(startMid); + } + + pos++; + len--; + lastSpace = pos; // Cheesy hack to prevent adding in widths of the run twice. + continue; + } +#ifdef APPLE_CHANGES // KDE applies wordspacing differently + bool applyWordSpacing = false; +#endif + if (ignoringSpaces) { + // We need to stop ignoring spaces, if we encounter a non-space or + // a run that doesn't collapse spaces. + if (!currentCharacterIsSpace || preserveWS) { + // Stop ignoring spaces and begin at this + // new point. + ignoringSpaces = false; + lastSpace = pos; // e.g., "Foo goo", don't add in any of the ignored spaces. + BidiIterator startMid ( 0, o, pos ); + addMidpoint(startMid); + } + else { + // Just keep ignoring these spaces. + pos++; + len--; + continue; + } + } + + const bool isbreakablePosition = (preserveLF && c == '\n') || (autoWrap && + (isBreakable( str, pos, strlen ) || isSoftBreakable)); + if ( isbreakablePosition || checkBreakWord ) { + + tmpW += t->width(lastSpace, pos - lastSpace, f); +#ifdef APPLE_CHANGES + applyWordSpacing = (wordSpacing && currentCharacterIsSpace && !previousCharacterIsSpace && + !t->containsOnlyWhitespace(pos+1, strlen-(pos+1))); +#endif +#ifdef DEBUG_LINEBREAKS + kdDebug(6041) << "found space at " << pos << " in string '" << TQString( str, strlen ).latin1() << "' adding " << tmpW << " new width = " << w << endl; +#endif + if ( autoWrap && w + tmpW > width && w == 0 ) { + int fb = nearestFloatBottom(m_height); + int newLineWidth = lineWidth(fb); + // See if |tmpW| will fit on the new line. As long as it does not, + // keep adjusting our float bottom until we find some room. + int lastFloatBottom = m_height; + while (lastFloatBottom < fb && tmpW > newLineWidth) { + lastFloatBottom = fb; + fb = nearestFloatBottom(fb); + newLineWidth = lineWidth(fb); + } + + if(!w && m_height < fb && width < newLineWidth) { + m_height = fb; + width = newLineWidth; +#ifdef DEBUG_LINEBREAKS + kdDebug() << "RenderBlock::findNextLineBreak new position at " << m_height << " newWidth " << width << endl; +#endif + } + } + + if (autoWrap) { + if (w+tmpW > width) { + if (checkBreakWord && pos) { + lBreak.obj = o; + lBreak.pos = pos-1; + lBreak.endOfInline = false; + } + goto end; + } else if ( (pos > 1 && str[pos-1].unicode() == SOFT_HYPHEN) ) + // Subtract the width of the soft hyphen out since we fit on a line. + tmpW -= t->width(pos-1, 1, f); + } + + if( preserveLF && *(str+pos) == '\n' ) { + lBreak.obj = o; + lBreak.pos = pos; + lBreak.endOfInline = false; + +#ifdef DEBUG_LINEBREAKS + kdDebug(6041) << "forced break sol: " << start.obj << " " << start.pos << " end: " << lBreak.obj << " " << lBreak.pos << " width=" << w << endl; +#endif + return lBreak; + } + + if ( autoWrap && isbreakablePosition ) { + w += tmpW; + tmpW = 0; + lBreak.obj = o; + lBreak.pos = pos; + lBreak.endOfInline = false; + } + + lastSpace = pos; +#ifdef APPLE_CHANGES + if (applyWordSpacing) + w += wordSpacing; +#endif + } + + if (!ignoringSpaces && !preserveWS) { + // If we encounter a second space, we need to go ahead and break up this run + // and enter a mode where we start collapsing spaces. + if (currentCharacterIsSpace && previousCharacterIsSpace) { + ignoringSpaces = true; + + // We just entered a mode where we are ignoring + // spaces. Create a midpoint to terminate the run + // before the second space. + addMidpoint(ignoreStart); + lastSpace = pos; + } + } + + if (currentCharacterIsSpace && !previousCharacterIsSpace) { + ignoreStart.obj = o; + ignoreStart.pos = pos; + } + + if (!preserveWS && currentCharacterIsSpace && !ignoringSpaces) + trailingSpaceObject = o; + else if (preserveWS || !currentCharacterIsSpace) + trailingSpaceObject = 0; + + pos++; + len--; + } + + if (!ignoringSpaces) { + // We didn't find any space that would be beyond the line |width|. + // Lets add to |tmpW| the remaining width since the last space we found. + // Before we test this new |tmpW| however, we will have to look ahead to check + // if the next object/position can serve as a line breaking opportunity. + tmpW += t->width(lastSpace, pos - lastSpace, f); + if (checkBreakWord && !w && pos && tmpW > width) { + // Avoid doing the costly lookahead for break-word, + // since we know we are allowed to break. + lBreak.obj = o; + lBreak.pos = pos-1; + lBreak.endOfInline = false; + goto end; + } + } + } else + KHTMLAssert( false ); + + InlineMinMaxIterator savedIt = lastIt; + lastIt = it; + o = it.next(); + + // advance the iterator to the next non-inline-flow + while (o && o->isInlineFlow() && !o->isWordBreak()) { + tmpW += getBorderPaddingMargin(o, it.endOfInline); + if (isLineEmpty) isLineEmpty = !tmpW; + o = it.next(); + } + + if (checkShouldIgnoreInitialWhitespace) { + // Check if we should switch to ignoringSpaces state + if (!style()->preserveWS() && it.current && it.current->isText()) { + const RenderText* rt = static_cast<RenderText*>(it.current); + if (rt->stringLength() > 0 && (rt->text()[0].category() == TQChar::Separator_Space || rt->text()[0] == '\n')) { + currentCharacterIsSpace = true; + ignoringSpaces = true; + BidiIterator endMid( 0, lastIt.current, 0 ); + addMidpoint(endMid); + } + } + checkShouldIgnoreInitialWhitespace = false; + } + + bool autoWrap = lastIt.current->style()->autoWrap(); + bool checkForBreak = autoWrap; + if (w && w + tmpW > width && lBreak.obj && !lastIt.current->style()->preserveLF() && !autoWrap) + checkForBreak = true; + else if (it.current && lastIt.current->isText() && it.current->isText() && !it.current->isBR()) { + if (autoWrap || it.current->style()->autoWrap()) { + if (currentCharacterIsSpace) + checkForBreak = true; + else { + checkForBreak = false; + RenderText* nextText = static_cast<RenderText*>(it.current); + if (nextText->stringLength() != 0) { + TQChar c = nextText->text()[0]; + if (c == ' ' || c == '\t' || (c == '\n' && !it.current->style()->preserveLF())) { + // If the next item on the line is text, and if we did not end with + // a space, then the next text run continues our word (and so it needs to + // keep adding to |tmpW|. Just update and continue. + checkForBreak = true; + } + } + + bool canPlaceOnLine = (w + tmpW <= width) || !autoWrap; + if (canPlaceOnLine && checkForBreak) { + w += tmpW; + tmpW = 0; + lBreak.obj = it.current; + lBreak.pos = 0; + lBreak.endOfInline = it.endOfInline; + } + } + } + } + + if (checkForBreak && (w + tmpW > width)) { + //kdDebug() << " too wide w=" << w << " tmpW = " << tmpW << " width = " << width << endl; + //kdDebug() << "start=" << start.obj << " current=" << o << endl; + // if we have floats, try to get below them. + if (currentCharacterIsSpace && !ignoringSpaces && !lastIt.current->style()->preserveWS()) + trailingSpaceObject = 0; + + int fb = nearestFloatBottom(m_height); + int newLineWidth = lineWidth(fb); + // See if |tmpW| will fit on the new line. As long as it does not, + // keep adjusting our float bottom until we find some room. + int lastFloatBottom = m_height; + while (lastFloatBottom < fb && tmpW > newLineWidth) { + lastFloatBottom = fb; + fb = nearestFloatBottom(fb); + newLineWidth = lineWidth(fb); + } + if( !w && m_height < fb && width < newLineWidth ) { + m_height = fb; + width = newLineWidth; +#ifdef DEBUG_LINEBREAKS + kdDebug() << "RenderBlock::findNextLineBreak new position at " << m_height << " newWidth " << width << endl; +#endif + } + + // |width| may have been adjusted because we got shoved down past a float (thus + // giving us more room), so we need to retest, and only jump to + // the end label if we still don't fit on the line. -dwh + if (w + tmpW > width) { + it = lastIt; + lastIt = savedIt; + o = it.current; + goto end; + } + } + + if (!lastIt.current->isFloatingOrPositioned() && lastIt.current->isReplaced() && lastIt.current->style()->autoWrap()) { + // Go ahead and add in tmpW. + w += tmpW; + tmpW = 0; + lBreak.obj = o; + lBreak.pos = 0; + lBreak.endOfInline = it.endOfInline; + } + + // Clear out our character space bool, since inline <pre>s don't collapse whitespace + // with adjacent inline normal/nowrap spans. + if (lastIt.current->style()->preserveWS()) + currentCharacterIsSpace = false; + + pos = 0; + } + +#ifdef DEBUG_LINEBREAKS + kdDebug( 6041 ) << "end of par, width = " << width << " linewidth = " << w + tmpW << endl; +#endif + if( w + tmpW <= width || (lastIt.current && !lastIt.current->style()->autoWrap())) { + lBreak.obj = 0; + lBreak.pos = 0; + lBreak.endOfInline = false; + } + + end: + + if( lBreak == start && !lBreak.obj->isBR() ) { + // we just add as much as possible + if ( style()->whiteSpace() == PRE ) { + // FIXME: Don't really understand this case. + if(pos != 0) { + lBreak.obj = o; + lBreak.pos = pos - 1; + lBreak.endOfInline = it.endOfInline; + } else { + lBreak.obj = lastIt.current; + lBreak.pos = lastIt.current->isText() ? lastIt.current->length() : 0; + lBreak.endOfInline = lastIt.endOfInline; + } + } else if( lBreak.obj ) { + if( lastIt.current != o ) { + // better to break between object boundaries than in the middle of a word + lBreak.obj = o; + lBreak.pos = 0; + lBreak.endOfInline = it.endOfInline; + } else { + // Don't ever break in the middle of a word if we can help it. + // There's no room at all. We just have to be on this line, + // even though we'll spill out. + lBreak.obj = o; + lBreak.pos = pos; + lBreak.endOfInline = it.endOfInline; + } + } + } + + if (hadPosStart) + start = posStart; + + // make sure we consume at least one char/object. + // and avoid returning an InlineFlow + // (FIXME: turn those wordbreaks into empty text objects - they shouldn't be inline flows!) + if( lBreak == start || (lBreak.obj && lBreak.obj->isInlineFlow() && !lBreak.obj->isWordBreak())) { + lBreak.increment(bidi); + } + +#ifdef DEBUG_LINEBREAKS + kdDebug(6041) << "regular break sol: " << start.obj << " " << start.pos << " end: " << lBreak.obj << " " << lBreak.pos << " width=" << w << endl; +#endif + + // Sanity check our midpoints. + checkMidpoints(lBreak, bidi); + + if (trailingSpaceObject) { + // This object is either going to be part of the last midpoint, or it is going + // to be the actual endpoint. In both cases we just decrease our pos by 1 level to + // exclude the space, allowing it to - in effect - collapse into the newline. + if (sNumMidpoints%2==1) { + BidiIterator* midpoints = smidpoints->data(); + midpoints[sNumMidpoints-1].pos--; + } + //else if (lBreak.pos > 0) + // lBreak.pos--; + else if (lBreak.obj == 0 && trailingSpaceObject->isText()) { + // Add a new end midpoint that stops right at the very end. + RenderText* text = static_cast<RenderText *>(trailingSpaceObject); + unsigned pos = text->length() >=2 ? text->length() - 2 : UINT_MAX; + BidiIterator endMid ( 0, trailingSpaceObject, pos ); + addMidpoint(endMid); + } + } + + // We might have made lBreak an iterator that points past the end + // of the object. Do this adjustment to make it point to the start + // of the next object instead to avoid confusing the rest of the + // code. + if (lBreak.pos > 0) { + lBreak.pos--; + lBreak.increment(bidi); + } + + if (lBreak.obj && lBreak.pos >= 2 && lBreak.obj->isText()) { + // For soft hyphens on line breaks, we have to chop out the midpoints that made us + // ignore the hyphen so that it will render at the end of the line. + TQChar c = static_cast<RenderText*>(lBreak.obj)->text()[lBreak.pos-1]; + if (c.unicode() == SOFT_HYPHEN) + chopMidpointsAt(lBreak.obj, lBreak.pos-2); + } + + return lBreak; +} + +void RenderBlock::checkLinesForOverflow() +{ + for (RootInlineBox* curr = static_cast<tdehtml::RootInlineBox*>(firstLineBox()); curr; curr = static_cast<tdehtml::RootInlineBox*>(curr->nextLineBox())) { +// m_overflowLeft = min(curr->leftOverflow(), m_overflowLeft); + m_overflowTop = kMin(curr->topOverflow(), m_overflowTop); +// m_overflowWidth = max(curr->rightOverflow(), m_overflowWidth); + m_overflowHeight = kMax(curr->bottomOverflow(), m_overflowHeight); + } +} + +void RenderBlock::deleteEllipsisLineBoxes() +{ + for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) + curr->clearTruncation(); +} + +void RenderBlock::checkLinesForTextOverflow() +{ + // Determine the width of the ellipsis using the current font. + TQChar ellipsis = 0x2026; // FIXME: CSS3 says this is configurable, also need to use 0x002E (FULL STOP) if 0x2026 not renderable + static TQString ellipsisStr(ellipsis); + const Font& firstLineFont = style(true)->htmlFont(); + const Font& font = style()->htmlFont(); + int firstLineEllipsisWidth = firstLineFont.width(&ellipsis, 1, 0); + int ellipsisWidth = (font == firstLineFont) ? firstLineEllipsisWidth : font.width(&ellipsis, 1, 0); + + // For LTR text truncation, we want to get the right edge of our padding box, and then we want to see + // if the right edge of a line box exceeds that. For RTL, we use the left edge of the padding box and + // check the left edge of the line box to see if it is less + // Include the scrollbar for overflow blocks, which means we want to use "contentWidth()" + bool ltr = style()->direction() == LTR; + for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) { + int blockEdge = ltr ? rightOffset(curr->yPos()) : leftOffset(curr->yPos()); + int lineBoxEdge = ltr ? curr->xPos() + curr->width() : curr->xPos(); + if ((ltr && lineBoxEdge > blockEdge) || (!ltr && lineBoxEdge < blockEdge)) { + // This line spills out of our box in the appropriate direction. Now we need to see if the line + // can be truncated. In order for truncation to be possible, the line must have sufficient space to + // accommodate our truncation string, and no replaced elements (images, tables) can overlap the ellipsis + // space. + int width = curr == firstRootBox() ? firstLineEllipsisWidth : ellipsisWidth; + if (curr->canAccommodateEllipsis(ltr, blockEdge, lineBoxEdge, width)) + curr->placeEllipsis(ellipsisStr, ltr, blockEdge, width); + } + } +} + +// For --enable-final +#undef BIDI_DEBUG +#undef DEBUG_LINEBREAKS +#undef DEBUG_LAYOUT + +} diff --git a/tdehtml/rendering/bidi.h b/tdehtml/rendering/bidi.h new file mode 100644 index 000000000..ec926d99a --- /dev/null +++ b/tdehtml/rendering/bidi.h @@ -0,0 +1,172 @@ +/* + * This file is part of the html renderer for KDE. + * + * Copyright (C) 2000 Lars Knoll (knoll@kde.org) + * Copyright (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef BIDI_H +#define BIDI_H + +#include <tqstring.h> +#include "rendering/render_object.h" + +namespace tdehtml { + class RenderArena; + class RenderBlock; + class RenderObject; + class InlineBox; + + class BidiContext { + public: + BidiContext(unsigned char level, TQChar::Direction embedding, BidiContext *parent = 0, bool override = false); + ~BidiContext(); + + void ref() const; + void deref() const; + + unsigned char level; + bool override : 1; + TQChar::Direction dir : 5; + TQChar::Direction basicDir : 5; + + BidiContext *parent; + + + // refcounting.... + mutable int count; + }; + + struct BidiRun { + BidiRun(int _start, int _stop, RenderObject *_obj, BidiContext *context, TQChar::Direction dir) + : start( _start ), stop( _stop ), obj( _obj ), box(0), nextRun(0) + { + if(dir == TQChar::DirON) dir = context->dir; + + level = context->level; + + // add level of run (cases I1 & I2) + if( level % 2 ) { + if(dir == TQChar::DirL || dir == TQChar::DirAN || dir == TQChar::DirEN) + level++; + } else { + if( dir == TQChar::DirR ) + level++; + else if( dir == TQChar::DirAN || dir == TQChar::DirEN) + level += 2; + } + } + + void detach(RenderArena* renderArena); + + // Overloaded new operator. + void* operator new(size_t sz, RenderArena* renderArena) throw(); + + // Overridden to prevent the normal delete from being called. + void operator delete(void* ptr, size_t sz); + +private: + // The normal operator new is disallowed. + void* operator new(size_t sz) throw(); + +public: + int start; + int stop; + + RenderObject *obj; + InlineBox* box; + + // explicit + implicit levels here + uchar level; + + bool compact : 1; + + BidiRun* nextRun; + }; + + struct BidiIterator; + struct BidiState; + + struct InlineMinMaxIterator + { + /* InlineMinMaxIterator is a class that will iterate over all render objects that contribute to + inline min/max width calculations. Note the following about the way it walks: + (1) Positioned content is skipped (since it does not contribute to min/max width of a block) + (2) We do not drill into the children of floats or replaced elements, since you can't break + in the middle of such an element. + (3) Inline flows (e.g., <a>, <span>, <i>) are walked twice, since each side can have + distinct borders/margin/padding that contribute to the min/max width. + */ + RenderObject* parent; + RenderObject* current; + bool endOfInline; + bool skipPositioned; + InlineMinMaxIterator(RenderObject* p, RenderObject* o, bool eOI=false, bool skipPos=true) + :parent(p), current(o), endOfInline(eOI), skipPositioned(skipPos) {} + inline RenderObject* next(); + }; + + inline RenderObject* InlineMinMaxIterator::next() + { + RenderObject* result = 0; + bool oldEndOfInline = endOfInline; + endOfInline = false; + while (current != 0 || (current == parent)) + { + //kDebug( 6040 ) << "current = " << current; + if (!oldEndOfInline && + (current == parent || + (!current->isFloating() && !current->isReplaced() && !current->isPositioned()))) + result = current->firstChild(); + if (!result) { + // We hit the end of our inline. (It was empty, e.g., <span></span>.) + if (!oldEndOfInline && current->isInlineFlow()) { + result = current; + endOfInline = true; + break; + } + while (current && current != parent) { + result = current->nextSibling(); + if (result) break; + current = current->parent(); + if (current && current != parent && current->isInlineFlow()) { + result = current; + endOfInline = true; + break; + } + } + } + + if (!result) break; + + if ((!skipPositioned || !result->isPositioned()) && (result->isText() || result->isBR() || + result->isFloatingOrPositioned() || result->isReplaced() || result->isGlyph() || result->isInlineFlow())) + break; + + current = result; + result = 0; + } + + // Update our position. + current = result; + return current; + } + +} + +#endif diff --git a/tdehtml/rendering/break_lines.cpp b/tdehtml/rendering/break_lines.cpp new file mode 100644 index 000000000..e82787eb8 --- /dev/null +++ b/tdehtml/rendering/break_lines.cpp @@ -0,0 +1,126 @@ +#include <break_lines.h> +#include <klibloader.h> +#include "tqcstring.h" +#include <tqtextcodec.h> +#include <tqcleanuphandler.h> +#include <config.h> + + +/* If HAVE_LIBTHAI is defined, libtdehtml will link against + * libthai since compile time. Otherwise it will try to + * dlopen at run-time + * + * Ott Pattara Nov 14, 2004 + */ + +#ifndef HAVE_LIBTHAI +typedef int (*th_brk_def)(const unsigned char*, int[], int); +static th_brk_def th_brk; +#else +#include <thai/thailib.h> +#include <thai/thbrk.h> +#endif + +namespace tdehtml { + struct ThaiCache + { + ThaiCache() { + string = 0; + allocated = 0x400; + wbrpos = (int *) malloc(allocated*sizeof(int)); + numwbrpos = 0; + numisbreakable = 0x400; + isbreakable = (int *) malloc(numisbreakable*sizeof(int)); + library = 0; + } + ~ThaiCache() { + free(wbrpos); + free(isbreakable); + if (library) library->unload(); + } + const TQChar *string; + int *wbrpos; + int *isbreakable; + int allocated; + int numwbrpos,numisbreakable; + KLibrary *library; + }; + static ThaiCache *cache = 0; + + void cleanup_thaibreaks() + { + delete cache; + cache = 0; +#ifndef HAVE_LIBTHAI + th_brk = 0; +#endif + } + + bool isBreakableThai( const TQChar *string, const int pos, const int len) + { + static TQTextCodec *thaiCodec = TQTextCodec::codecForMib(2259); + //printf("Entering isBreakableThai with pos = %d\n", pos); + +#ifndef HAVE_LIBTHAI + + KLibrary *lib = 0; + + /* load libthai dynamically */ + if (( !th_brk ) && thaiCodec ) { + printf("Try to load libthai dynamically...\n"); + KLibLoader *loader = KLibLoader::self(); + lib = loader->library("libthai"); + if (lib && lib->hasSymbol("th_brk")) { + th_brk = (th_brk_def) lib->symbol("th_brk"); + } else { + // indication that loading failed and we shouldn't try to load again + printf("Error, can't load libthai...\n"); + thaiCodec = 0; + if (lib) + lib->unload(); + } + } + + if (!th_brk ) { + return true; + } +#endif + + if (!cache ) { + cache = new ThaiCache; +#ifndef HAVE_LIBTHAI + cache->library = lib; +#endif + } + + // build up string of thai chars + if ( string != cache->string ) { + //fprintf(stderr,"new string found (not in cache), calling libthai\n"); + TQCString cstr = thaiCodec->fromUnicode( TQConstString(string,len).string()); + //printf("About to call libthai::th_brk with str: %s",cstr.data()); + + cache->numwbrpos = th_brk((const unsigned char*) cstr.data(), cache->wbrpos, cache->allocated); + //fprintf(stderr,"libthai returns with value %d\n",cache->numwbrpos); + if (cache->numwbrpos > cache->allocated) { + cache->allocated = cache->numwbrpos; + cache->wbrpos = (int *)realloc(cache->wbrpos, cache->allocated*sizeof(int)); + cache->numwbrpos = th_brk((const unsigned char*) cstr.data(), cache->wbrpos, cache->allocated); + } + if ( len > cache->numisbreakable ) { + cache->numisbreakable=len; + cache->isbreakable = (int *)realloc(cache->isbreakable, cache->numisbreakable*sizeof(int)); + } + for (int i = 0 ; i < len ; ++i) { + cache->isbreakable[i] = 0; + } + if ( cache->numwbrpos > 0 ) { + for (int i = cache->numwbrpos-1; i >= 0; --i) { + cache->isbreakable[cache->wbrpos[i]] = 1; + } + } + cache->string = string; + } + //printf("Returning %d\n", cache->isbreakable[pos]); + return cache->isbreakable[pos]; + } +} diff --git a/tdehtml/rendering/break_lines.h b/tdehtml/rendering/break_lines.h new file mode 100644 index 000000000..34b733121 --- /dev/null +++ b/tdehtml/rendering/break_lines.h @@ -0,0 +1,163 @@ +#ifndef BREAK_LINES_H +#define BREAK_LINES_H + +#include <tqstring.h> + +namespace tdehtml { + + /* + array of unicode codes where breaking shouldn't occur. + (in sorted order because of using with binary search) + these are currently for Japanese, though simply adding + Korean, Chinese ones should work as well + */ + /* + dontbreakbefore[] contains characters not covered by TQChar::Punctuation_Close that shouldn't be broken before. + chars included in TQChar::Punctuation_Close are listed below.(look at UAX #14) + - 3001 ideographic comma + - 3002 ideographic full stop + - FE50 small comma + - FF52 small full stop + - FF0C fullwidth comma + - FF0E fullwidth full stop + - FF61 halfwidth ideographic full stop + - FF64 halfwidth ideographic comma + these character is commented out. + */ + const ushort dontbreakbefore[] = { + //0x3001, //ideographic comma + //0x3002, //ideographic full stop + 0x3005, //ideographic iteration mark + 0x3009, //right angle bracket + 0x300b, //right double angle bracket + 0x300d, //right corner bracket + 0x300f, //right white corner bracket + 0x3011, //right black lenticular bracket + 0x3015, //right tortoise shell bracket + 0x3041, //small a hiragana + 0x3043, //small i hiragana + 0x3045, //small u hiragana + 0x3047, //small e hiragana + 0x3049, //small o hiragana + 0x3063, //small tsu hiragana + 0x3083, //small ya hiragana + 0x3085, //small yu hiragana + 0x3087, //small yo hiragana + 0x308E, //small wa hiragana + 0x309B, //jap voiced sound mark + 0x309C, //jap semi-voiced sound mark + 0x309D, //jap iteration mark hiragana + 0x309E, //jap voiced iteration mark hiragana + 0x30A1, //small a katakana + 0x30A3, //small i katakana + 0x30A5, //small u katakana + 0x30A7, //small e katakana + 0x30A9, //small o katakana + 0x30C3, //small tsu katakana + 0x30E3, //small ya katakana + 0x30E5, //small yu katakana + 0x30E7, //small yo katakana + 0x30EE, //small wa katakana + 0x30F5, //small ka katakana + 0x30F6, //small ke katakana + 0x30FC, //jap prolonged sound mark + 0x30FD, //jap iteration mark katakana + 0x30FE, //jap voiced iteration mark katakana + //0xFE50, //small comma + //0xFF52, //small full stop + 0xFF01, //fullwidth exclamation mark + 0xFF09, //fullwidth right parenthesis + //0xFF0C, //fullwidth comma + 0xFF0D, //fullwidth hypen-minus + //0xFF0E, //fullwidth full stop + 0xFF1F, //fullwidth question mark + 0xFF3D, //fullwidth right square bracket + 0xFF5D, //fullwidth right curly bracket + //0xFF61, //halfwidth ideographic full stop + 0xFF63, //halfwidth right corner bracket + //0xFF64, //halfwidth ideographic comma + 0xFF67, //halfwidth katakana letter small a + 0xFF68, //halfwidth katakana letter small i + 0xFF69, //halfwidth katakana letter small u + 0xFF6a, //halfwidth katakana letter small e + 0xFF6b, //halfwidth katakana letter small o + 0xFF6c, //halfwidth katakana letter small ya + 0xFF6d, //halfwidth katakana letter small yu + 0xFF6e, //halfwidth katakana letter small yo + 0xFF6f, //halfwidth katakana letter small tu + 0xFF70 //halfwidth katakana-hiragana prolonged sound mark + }; + + // characters that aren't covered by TQChar::Punctuation_Open + const ushort dontbreakafter[] = { + 0x3012, //postal mark + 0xFF03, //full width pound mark + 0xFF04, //full width dollar sign + 0xFF20, //full width @ + 0xFFE1, //full width british pound sign + 0xFFE5 //full width yen sign + }; + + inline bool break_bsearch( const ushort* arr, const ushort val ) { + int left = 0; + int right = (sizeof(arr) / sizeof(ushort)) - 1; + + while (1) { + if (left == right) + return val != arr[left]; + + int i = (left + right) >> 1; + if ( val == arr[i] ) + return false; + if ( val < arr[i] ) + right = i; + else + left = i + 1; + } + } + + bool isBreakableThai( const TQChar *string, const int pos, const int len); + void cleanup_thaibreaks(); + + inline bool isBreakable( const TQChar *str, const int pos, int len ) + { + const TQChar *c = str+pos; + unsigned short ch = c->unicode(); + if ( ch > 0xff ) { + // not latin1, need to do more sophisticated checks for asian fonts + unsigned char row = c->row(); + if ( row == 0x0e ) { + // 0e00 - 0e7f == Thai + if ( c->cell() < 0x80 ) { + // consult libthai + return isBreakableThai(str, pos, len); + } else + return false; + } + if ( row > 0x2d && row < 0xfb || row == 0x11 ) { + /* asian line breaking. */ + if ( pos == 0 ) + return false; // never break before first character + + // check for simple punctuation cases + TQChar::Category cat = c->category(); + if ( cat == TQChar::Punctuation_Close || + cat == TQChar::Punctuation_Other || + (str+(pos-1))->category() == TQChar::Punctuation_Open ) + return false; + + // do binary search in dontbreak[] + return break_bsearch(dontbreakbefore, c->unicode()) && + break_bsearch(dontbreakafter, (str+(pos-1))->unicode()); + } else // no asian font + return c->isSpace(); + } else { + if ( ch == ' ' || ch == '\n' ) + return true; + } + return false; + } + +} + +#endif diff --git a/tdehtml/rendering/counter_tree.cpp b/tdehtml/rendering/counter_tree.cpp new file mode 100644 index 000000000..931c54332 --- /dev/null +++ b/tdehtml/rendering/counter_tree.cpp @@ -0,0 +1,222 @@ +/* + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "rendering/counter_tree.h" +#include "rendering/render_object.h" + +namespace tdehtml { + +CounterNode::CounterNode(RenderObject *o) + : m_hasCounters(false), m_isVisual(false), + m_value(0), m_count(0), m_parent(0), m_previous(0), m_next(0), + m_renderer(o) {} + +CounterNode::~CounterNode() +{ + if (m_parent) m_parent->removeChild(this); +} + +void CounterNode::insertAfter ( CounterNode *, CounterNode *) +{ + Q_ASSERT( false); +} + +void CounterNode::removeChild ( CounterNode *) +{ + Q_ASSERT( false); +} + +void CounterNode::remove () +{ + if (m_parent) m_parent->removeChild(this); + else { + Q_ASSERT(isReset()); + Q_ASSERT(!firstChild()); + Q_ASSERT(!lastChild()); + } +} + +void CounterNode::setHasCounters () +{ + m_hasCounters = true; + if (parent()) + parent()->setHasCounters(); +} + +void CounterNode::recount (bool first) +{ + int old_count = m_count; + if (m_previous) + m_count = m_previous->count() + m_value; + else { + assert(m_parent->firstChild() == this); + m_count = m_parent->value() + m_value; + } + if (old_count != m_count && !first) + setSelfDirty(); + if (old_count != m_count || first) { + if (m_parent) m_parent->updateTotal(m_count); + if (m_next) m_next->recount(); + } +} + +void CounterNode::setSelfDirty () +{ + if (m_renderer && m_isVisual) + m_renderer->setNeedsLayoutAndMinMaxRecalc(); +} + +void CounterNode::setParentDirty () +{ + if (m_renderer && m_isVisual && m_hasCounters) + m_renderer->setNeedsLayoutAndMinMaxRecalc(); +} + +CounterReset::CounterReset(RenderObject *o) : CounterNode(o), m_total(0), m_first(0), m_last(0) {} +CounterReset::~CounterReset() {} + +void CounterReset::insertAfter ( CounterNode *newChild, CounterNode *refChild ) +{ + Q_ASSERT( newChild ); + Q_ASSERT( !refChild || refChild->parent() == this ); + + newChild->m_parent = this; + newChild->m_previous = refChild; + + if (refChild) { + newChild->m_next = refChild->m_next; + refChild->m_next = newChild; + } else { + newChild->m_next = m_first; + m_first = newChild; + } + + if (newChild->m_next) { + assert(newChild->m_next->m_previous == refChild); + newChild->m_next->m_previous = newChild; + } + else { + assert (m_last == refChild); + m_last = newChild; + } + + newChild->recount(true); +} + +void CounterReset::removeChild ( CounterNode *oldChild ) +{ + Q_ASSERT( oldChild ); + + CounterNode* next = oldChild->m_next; + CounterNode* prev = oldChild->m_previous; + + if (oldChild->firstChild()) { + CounterNode* first = oldChild->firstChild(); + CounterNode* last = oldChild->lastChild(); + if (prev) { + prev->m_next = first; + first->m_previous = prev; + } + else { + assert ( m_first == oldChild ); + m_first = first; + } + + if (next) { + next->m_previous = last; + last->m_next = next; + } + else { + assert ( m_last == oldChild ); + m_last = last; + } + + next = first; + while (next) { + next->m_parent = this; + if (next == last) break; + next = next->m_next; + } + + first->recount(true); + } + else { + if (prev) prev->m_next = next; + else { + assert ( m_first == oldChild ); + m_first = next; + } + if (next) next->m_previous = prev; + else { + assert ( m_last == oldChild ); + m_last = prev; + } + if (next) + next->recount(); + } + + + oldChild->m_next = 0; + oldChild->m_previous = 0; + oldChild->m_parent = 0; +} + +void CounterReset::recount (bool first) +{ + int old_count = m_count; + if (m_previous) + m_count = m_previous->count(); + else if (m_parent) + m_count = m_parent->value(); + else + m_count = 0; + + updateTotal(m_value); + if (!first) setSelfDirty(); + if (first || m_count != old_count) { + if (m_next) m_next->recount(); + } +} + +void CounterReset::setSelfDirty () +{ + setParentDirty(); +} + +void CounterReset::setParentDirty () +{ + if (hasCounters()) { + if (m_renderer && m_isVisual) m_renderer->setNeedsLayoutAndMinMaxRecalc(); + CounterNode* n = firstChild(); + for(; n; n = n->nextSibling()) + { + n->setParentDirty(); + } + } +} + +void CounterReset::updateTotal (int value) +{ + if (value > m_total) m_total = value; +} + +} // namespace diff --git a/tdehtml/rendering/counter_tree.h b/tdehtml/rendering/counter_tree.h new file mode 100644 index 000000000..0266dcc75 --- /dev/null +++ b/tdehtml/rendering/counter_tree.h @@ -0,0 +1,114 @@ +/* + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef _Counter_Tree_h_ +#define _Counter_Tree_h_ + +#include "misc/shared.h" +#include "rendering/render_object.h" + +namespace tdehtml { + +class CounterReset; + +// This file implements a counter-tree that is used for finding all parents in counters() lookup, +// and for propagating count-changes when nodes are added or removed. +// Please note that only counter-reset and root can be parents here, and that render-tree parents +// are just counter-tree siblings + +// Implementation of counter-increment and counter-content +class CounterNode +{ +public: + CounterNode(RenderObject *o); + virtual ~CounterNode(); + + CounterReset* parent() const { return m_parent; } + CounterNode* previousSibling() const { return m_previous; } + CounterNode* nextSibling() const { return m_next; } + virtual CounterNode* firstChild() const { return 0; } ; + virtual CounterNode* lastChild() const { return 0; }; + virtual void insertAfter ( CounterNode *newChild, CounterNode *refChild ); + virtual void removeChild ( CounterNode *oldChild ); + // Convenient self-refering version of the above + void remove(); + + int value() const { return m_value; }; + void setValue(short v) { m_value = v; }; + int count() const { return m_count; }; + + virtual bool isReset() { return false; }; + virtual void recount( bool first = false ); + virtual void setSelfDirty(); + virtual void setParentDirty(); + + bool hasCounters() const { return m_hasCounters; }; + bool isVisual() const { return m_isVisual; }; + void setHasCounters(); + void setIsVisual() { m_isVisual = true; }; + bool isRoot() { return m_renderer && m_renderer->isRoot(); }; + + void setRenderer(RenderObject *o) { m_renderer = o; }; + RenderObject* renderer() const { return m_renderer; }; + + friend class CounterReset; +protected: + bool m_hasCounters : 1; + bool m_isVisual : 1; + short m_value; + short m_count; + CounterReset *m_parent; + CounterNode *m_previous; + CounterNode *m_next; + RenderObject *m_renderer; +}; + +// Implementation of counter-reset and root +class CounterReset : public CounterNode +{ +public: + CounterReset(RenderObject *o); + virtual ~CounterReset(); + + virtual CounterNode *firstChild() const { return m_first; }; + virtual CounterNode *lastChild() const { return m_last; }; + virtual void insertAfter ( CounterNode *newChild, CounterNode *refChild ); + virtual void removeChild ( CounterNode *oldChild ); + + virtual bool isReset() { return true; }; + virtual void recount( bool first = false ); + virtual void setSelfDirty(); + virtual void setParentDirty(); + + void updateTotal(int value); + // The highest value among children + int total() const { return m_total; }; + +protected: + int m_total; + CounterNode *m_first; + CounterNode *m_last; +}; + +} // namespace + +#endif + diff --git a/tdehtml/rendering/enumerate.cpp b/tdehtml/rendering/enumerate.cpp new file mode 100644 index 000000000..bd2ff3696 --- /dev/null +++ b/tdehtml/rendering/enumerate.cpp @@ -0,0 +1,411 @@ +/** + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * (C) Hebrew algorithm by herouth@netvision.net.il + * and schlpbch@iam.unibe.ch + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "rendering/enumerate.h" + +#include <tqstring.h> +#include <tqvaluelist.h> + +namespace tdehtml { + +namespace Enumerate { + +TQString toRoman( int number, bool upper ) +{ + if (number < 1 || number > 3999) return TQString::number(number); + TQString roman; + static const TQChar ldigits[] = { 'i', 'v', 'x', 'l', 'c', 'd', 'm' }; + static const TQChar udigits[] = { 'I', 'V', 'X', 'L', 'C', 'D', 'M' }; + const TQChar *digits = upper ? udigits : ldigits; + int i, d = 0; + + do + { + int num = number % 10; + + if ( num % 5 < 4 ) + for ( i = num % 5; i > 0; i-- ) + roman.prepend( digits[ d ] ); + + if ( num >= 4 && num <= 8) + roman.prepend( digits[ d+1 ] ); + + if ( num == 9 ) + roman.prepend( digits[ d+2 ] ); + + if ( num % 5 == 4 ) + roman.prepend( digits[ d ] ); + + number /= 10; + d += 2; + } + while ( number ); + + return roman; +} + +TQString toGeorgian( int number ) +{ + TQString georgian; + const TQChar tenthousand = 0x10ef; + static const TQChar thousands[9] = {0x10e8, 0x10e9, 0x10ea, 0x10eb, 0x10ec, + 0x10ed, 0x10ee, 0x10f4, 0x10f5 }; + static const TQChar hundreds[9] = {0x10e0, 0x10e1, 0x10e2, 0x10e3, 0x10f3, + 0x10e4, 0x10e5, 0x10e6, 0x10e7 }; + static const TQChar tens[9] = {0x10d8, 0x10d9, 0x10da, 0x10db, 0x10dc, + 0x10f2, 0x10dd, 0x10de, 0x10df }; + static const TQChar units[9] = {0x10d0, 0x10d1, 0x10d2, 0x10d3, 0x10d4, + 0x10d5, 0x10d6, 0x10f1, 0x10d7 }; + + if (number < 1 || number > 19999) return TQString::number(number); + if (number >= 10000) { + georgian.append(tenthousand); + number = number - 10000; + } + if (number >= 1000) { + georgian.append(thousands[number/1000-1]); + number = number % 1000; + } + if (number >= 100) { + georgian.append(hundreds[number/100-1]); + number = number % 100; + } + if (number >= 10) { + georgian.append(tens[number/10-1]); + number = number % 10; + } + if (number >= 1) { + georgian.append(units[number-1]); + } + + return georgian; +} + +TQString toArmenian( int number ) +{ + TQString armenian; + int onethousand = 0x57c; + int hundreds = 0x572; + int tens = 0x569; + int units = 0x560; + + // The standard defines values over 1999, but 7000 is very hard to render + if (number < 1 || number > 1999) return TQString::number(number); + if (number >= 1000) { + armenian.append(TQChar(onethousand)); + number = number - 1000; + } + if (number >= 100) { + armenian.append(TQChar(hundreds+number/100)); + number = number % 100; + } + if (number >= 10) { + armenian.append(TQChar(tens+number/10)); + number = number % 10; + } + if (number >= 1) { + armenian.append(TQChar(units+number)); + } + + return armenian; +} + +TQString toHebrew( int number ) { + static const TQChar tenDigit[] = {1497, 1499, 1500, 1502, 1504, 1505, 1506, 1508, 1510}; + + TQString letter; + if (number < 1) return TQString::number(number); + if (number>999) { + letter = toHebrew(number/1000) + TQString::fromLatin1("'"); + number = number%1000; + } + + int hunderts = (number/400); + if (hunderts > 0) { + for(int i=0; i<hunderts; i++) { + letter += TQChar(1511 + 3); + } + } + number = number % 400; + if ((number / 100) != 0) { + letter += TQChar (1511 + (number / 100) -1); + } + number = number % 100; + int tens = number/10; + if (tens > 0 && !(number == 15 || number == 16)) { + letter += tenDigit[tens-1]; + } + if (number == 15 || number == 16) { // special because of religious + letter += TQChar(1487 + 9); // reasons + letter += TQChar(1487 + number - 9); + } else { + number = number % 10; + if (number != 0) { + letter += TQChar (1487 + number); + } + } + return letter; +} + +static inline TQString toLatin( int number, int base ) { + if (number < 1) return TQString::number(number); + TQValueList<TQChar> letters; + while(number > 0) { + number--; // number 0 is letter a + TQChar letter = (TQChar) (base + (number % 26)); + letters.prepend(letter); + number /= 26; + } + TQString str; + str.setLength(letters.size()); + int i=0; + while(!letters.isEmpty()) { + str[i++] = letters.front(); + letters.pop_front(); + } + return str; +} + +TQString toLowerLatin( int number ) { + return toLatin( number, 'a' ); +} + +TQString toUpperLatin( int number ) { + return toLatin( number, 'A' ); +} + +static inline TQString toAlphabetic( int number, int base, const TQChar alphabet[] ) { + if (number < 1) return TQString::number(number); + TQValueList<TQChar> letters; + while(number > 0) { + number--; // number 0 is letter 1 + TQChar letter = alphabet[number % base]; + letters.prepend(letter); + number /= base; + } + TQString str; + str.setLength(letters.size()); + int i=0; + while(!letters.isEmpty()) { + str[i++] = letters.front(); + letters.pop_front(); + } + return str; +} + +TQString toHiragana( int number ) { + static const TQChar hiragana[48] = {0x3042, 0x3044, 0x3046, 0x3048, 0x304A, 0x304B, 0x304D, + 0x304F, 0x3051, 0x3053, 0x3055, 0x3057, 0x3059, 0x305B, 0x305D, + 0x305F, 0x3061, 0x3064, 0x3066, 0x3068, 0x306A, 0x306B, + 0x306C, 0x306D, 0x306E, 0x306F, 0x3072, 0x3075, 0x3078, + 0x307B, 0x307E, 0x307F, 0x3080, 0x3081, 0x3082, 0x3084, 0x3086, + 0x3088, 0x3089, 0x308A, 0x308B, 0x308C, 0x308D, 0x308F, + 0x3090, 0x3091, 0x9092, 0x3093}; + return toAlphabetic( number, 48, hiragana ); +} + +TQString toHiraganaIroha( int number ) { + static const TQChar hiragana[47] = {0x3044, 0x308D, 0x306F, 0x306B, 0x307B, 0x3078, 0x3068, + 0x3061, 0x308A, 0x306C, 0x308B, 0x3092, 0x308F, 0x304B, + 0x3088, 0x305F, 0x308C, 0x305D, 0x3064, 0x306D, 0x306A, + 0x3089, 0x3080, 0x3046, 0x3090, 0x306E, 0x304A, 0x304F, 0x3084, + 0x307E, 0x3051, 0x3075, 0x3053, 0x3048, 0x3066, 0x3042, 0x3055, + 0x304D, 0x3086, 0x3081, 0x307F, 0x3057, 0x3091, 0x3072, 0x3082, + 0x305B, 0x3059 }; + return toAlphabetic( number, 47, hiragana ); +} + +TQString toKatakana( int number ) { + static const TQChar katakana[48] = {0x30A2, 0x30A4, 0x30A6, 0x30A8, 0x30AA, 0x30AB, 0x30AD, + 0x30AF, 0x30B1, 0x30B3, 0x30B5, 0x30B7, 0x30B9, 0x30BB, + 0x30BD, 0x30BF, 0x30C1, 0x30C4, 0x30C6, 0x30C8, 0x30CA, + 0x30CB, 0x30CC, 0x30CD, 0x30CE, 0x30CF, 0x30D2, 0x30D5, + 0x30D8, 0x30DB, 0x30DE, 0x30DF, 0x30E0, 0x30E1, 0x30E2, + 0x30E4, 0x30E6, 0x30E8, 0x30E9, 0x30EA, 0x30EB, 0x30EC, + 0x30ED, 0x30EF, 0x30F0, 0x30F1, 0x90F2, 0x30F3}; + return toAlphabetic( number, 48, katakana ); +} + +TQString toKatakanaIroha( int number ) { + static const TQChar katakana[47] = {0x30A4, 0x30ED, 0x30CF, 0x30CB, 0x30DB, 0x30D8, 0x30C8, + 0x30C1, 0x30EA, 0x30CC, 0x30EB, 0x30F2, 0x30EF, 0x30AB, + 0x30E8, 0x30BF, 0x30EC, 0x30ED, 0x30C4, 0x30CD, 0x30CA, + 0x30E9, 0x30E0, 0x30A6, 0x30F0, 0x30CE, 0x30AA, 0x30AF, + 0x30E4, 0x30DE, 0x30B1, 0x30D5, 0x30B3, 0x30A8, 0x30C6, + 0x30A2, 0x30B5, 0x30AD, 0x30E6, 0x30E1, 0x30DF, 0x30B7, + 0x30F1, 0x30D2, 0x30E2, 0x30BB, 0x90B9}; + return toAlphabetic( number, 47, katakana ); +} + +TQString toLowerGreek( int number ) { + static const TQChar greek[24] = { 0x3B1, 0x3B2, 0x3B3, 0x3B4, 0x3B5, 0x3B6, 0x3B7, + 0x3B8, 0x3B9, 0x3BA, 0x3BB, 0x3BC, 0x3BD, 0x3BE, + 0x3BF, 0x3C0, 0x3C1, 0x3C3, 0x3C4, 0x3C5, 0x3C6, + 0x3C7, 0x3C8, 0x3C0}; + + return toAlphabetic( number, 24, greek ); +} + +TQString toUpperGreek( int number ) { + // The standard claims to be base 24, but only lists 19 letters. + static const TQChar greek[19] = { 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, + 0x399, 0x39A, 0x39B, 0x39C, 0x39D, 0x39E, 0x39F, + 0x3A0, 0x3A1, 0x3A3, 0x3A9}; + + return toAlphabetic( number, 19, greek ); +} + +static inline TQString toNumeric( int number, int base ) { + TQString letter = TQString::number(number); + for(unsigned int i = 0; i < letter.length(); i++) { + if (letter[i].isDigit()) + letter[i] = TQChar(letter[i].digitValue()+base); + } + return letter; +} + +TQString toArabicIndic( int number ) { + return toNumeric(number, 0x660); +} + +TQString toPersianUrdu( int number ) { + return toNumeric(number, 0x6F0); +} + +TQString toLao( int number ) { + return toNumeric(number, 0xED0); +} + +TQString toThai( int number ) { + return toNumeric(number, 0xE50); +} + +TQString toTibetan( int number ) { + return toNumeric(number, 0xF20); +} + +static inline TQString toIdeographic(int number, const TQChar digits[], const TQChar digitmarkers[]) { + if (number < 0 || number > 9999) return TQString::number(number); + + TQString grp = TQString::number(number); + + // ### Append group markers to handle numbers > 9999 + + TQString str; + + // special case + if (number < 20 && number >= 10) { + str.append(digitmarkers[0]); + str.append(digits[grp[1].digitValue()]); + return str; + } + + int len = grp.length(); + bool collapseZero = false; + for (int i = 0; i < len ; i++) { + int digit = grp[i].digitValue(); + // Add digit markers to digits > 0 + if ((len-i-1) > 0 && digit > 0) + str.append(digitmarkers[(len-i-2)]); + // Add digit, but collapse consecutive zeros + if (!collapseZero || digit > 0) { + str.append(digits[digit]); + + if (digit == 0) + collapseZero = true; + else + collapseZero = false; + } + } + return str; +} + +TQString toTradChineseFormal( int number ) { +// static const TQChar groupMarkers[3] = {0x4e07, 0x4ebf, 0x5146}; + static const TQChar digitMarkers[3] = {0x4e07, 0x4ebf, 0x5146}; + static const TQChar digits[10] = {0x96f6, 0x4e00, + 0x4ebc, 0x4e09, + 0x56db, 0x4e94, + 0x516d, 0x4e03, + 0x516b, 0x4e5d}; + return toIdeographic(number, digits, digitMarkers); +} + +TQString toTradChineseInformal( int number ) { +// static const TQChar groupMarkers[3] = {0x842c, 0x5104, 0x5146}; + static const TQChar digitMarkers[3] = {0x842c, 0x5104, 0x5146}; + static const TQChar digits[10] = {0x96f6, 0x4e00, + 0x4ebc, 0x4e09, + 0x56db, 0x4e94, + 0x516d, 0x4e03, + 0x516b, 0x4e5d}; + return toIdeographic(number, digits, digitMarkers); +} + +TQString toSimpChineseFormal( int number ) { +// static const TQChar groupMarkers[3] = {0x4e07, 0x5104, 0x5146}; + static const TQChar digitMarkers[3] = {0x4e07, 0x4ebf, 0x5146}; + static const TQChar digits[10] = {0x96f6, 0x58f9, + 0x8cb3, 0x53c3, + 0x8086, 0x4f0d, + 0x9678, 0x67d2, + 0x634c, 0x7396}; + return toIdeographic(number, digits, digitMarkers); +} + +TQString toSimpChineseInformal( int number ) { +// static const TQChar groupMarkers[3] = {0x842c, 0x5104, 0x5146}; + static const TQChar digitMarkers[3] = {0x842c, 0x5104, 0x5146}; + static const TQChar digits[10] = {0x96f6, 0x58f9, + 0x8cb3, 0x53c3, + 0x8086, 0x4f0d, + 0x9678, 0x67d2, + 0x634c, 0x7396}; + return toIdeographic(number, digits, digitMarkers); +} + +TQString toJapaneseFormal( int number ) { +// static const TQChar groupMarkers[3] = {0x4e07, 0x5104, 0x5146}; + static const TQChar digitMarkers[3] = {0x62fe, 0x4f70, 0x4edf}; + static const TQChar digits[10] = {0x96f6, 0x58f9, + 0x8cb3, 0x53c3, + 0x8086, 0x4f0d, + 0x9678, 0x67d2, + 0x634c, 0x7396}; + return toIdeographic(number, digits, digitMarkers); +} + +TQString toJapaneseInformal( int number ) { +// static const TQChar groupMarkers[3] = {0x842c, 0x5104, 0x5146}; + static const TQChar digitMarkers[3] = {0x842c, 0x5104, 0x5146}; + static const TQChar digits[10] = {0x96f6, 0x58f9, + 0x8d30, 0x53c1, + 0x8086, 0x4f0d, + 0x9646, 0x67d2, + 0x634c, 0x7396}; + return toIdeographic(number, digits, digitMarkers); +} + +}} // namespace diff --git a/tdehtml/rendering/enumerate.h b/tdehtml/rendering/enumerate.h new file mode 100644 index 000000000..16b92f43c --- /dev/null +++ b/tdehtml/rendering/enumerate.h @@ -0,0 +1,66 @@ +/** + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#ifndef ENUMERATE_H +#define ENUMERATE_H + +class TQChar; +class TQString; + +namespace tdehtml { + +namespace Enumerate { + +// Numeric + TQString toArabicIndic( int number ); + TQString toLao( int number ); + TQString toPersianUrdu( int number ); + TQString toThai( int number ); + TQString toTibetan( int number ); + +// Alphabetic + TQString toLowerLatin( int number ); + TQString toUpperLatin( int number ); + TQString toLowerGreek( int number ); + TQString toUpperGreek( int number ); + TQString toHiragana( int number ); + TQString toHiraganaIroha( int number ); + TQString toKatakana( int number ); + TQString toKatakanaIroha( int number ); + +// Algorithmic + TQString toRoman( int number, bool upper ); + TQString toHebrew( int number ); + TQString toGeorgian( int number ); + TQString toArmenian( int number ); + +// Ideographic + TQString toJapaneseFormal ( int number ); + TQString toJapaneseInformal ( int number ); + TQString toSimpChineseFormal ( int number ); + TQString toSimpChineseInformal ( int number ); + TQString toTradChineseFormal ( int number ); + TQString toTradChineseInformal ( int number ); + +}} // namespaces + +#endif diff --git a/tdehtml/rendering/font.cpp b/tdehtml/rendering/font.cpp new file mode 100644 index 000000000..3ace5ddd1 --- /dev/null +++ b/tdehtml/rendering/font.cpp @@ -0,0 +1,502 @@ +/** + * This file is part of the html renderer for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2000 Dirk Mueller (mueller@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "config.h" + +#ifdef HAVE_ALLOCA_H +#include <alloca.h> +#endif + +#include "font.h" +#include "tdehtml_factory.h" +#include "tdehtml_settings.h" + +#include <kdebug.h> +#include <kglobal.h> + +#include <tqpainter.h> +#include <tqfontdatabase.h> +#include <tqpaintdevicemetrics.h> + +using namespace tdehtml; + +/** closes the current word and returns its width in pixels + * @param fm metrics of font to be used + * @param str string + * @param pos zero-indexed position within @p str upon which all other + * indices are based + * @param wordStart relative index pointing to the position where the word started + * @param wordEnd relative index pointing one position after the word ended + * @return the width in pixels. May be 0 if @p wordStart and @p wordEnd were + * equal. + */ +inline int closeWordAndGetWidth(const TQFontMetrics &fm, const TQChar *str, int pos, + int wordStart, int wordEnd) +{ + if (wordEnd <= wordStart) return 0; + + TQConstString s(str + pos + wordStart, wordEnd - wordStart); + return fm.width(s.string()); +} + +/** closes the current word and draws it + * @param p painter + * @param d text direction + * @param x current x position, will be inc-/decremented correctly according + * to text direction + * @param y baseline of text + * @param widths list of widths; width of word is expected at position + * wordStart + * @param str string + * @param pos zero-indexed position within @p str upon which all other + * indices are based + * @param wordStart relative index pointing to the position where the word started, + * will be set to wordEnd after function + * @param wordEnd relative index pointing one position after the word ended + */ +inline void closeAndDrawWord(TQPainter *p, TQPainter::TextDirection d, + int &x, int y, const short widths[], const TQChar *str, int pos, + int &wordStart, int wordEnd) +{ + if (wordEnd <= wordStart) return; + + int width = widths[wordStart]; + if (d == TQPainter::RTL) + x -= width; + + TQConstString s(str + pos + wordStart, wordEnd - wordStart); + p->drawText(x, y, s.string(), -1, d); + + if (d != TQPainter::RTL) + x += width; + + wordStart = wordEnd; +} + +void Font::drawText( TQPainter *p, int x, int y, TQChar *str, int slen, int pos, int len, + int toAdd, TQPainter::TextDirection d, int from, int to, TQColor bg, int uy, int h, int deco ) const +{ + if (!str) return; + TQConstString cstr = TQConstString(str, slen); + TQString qstr = cstr.string(); + + // ### fixme for RTL + if ( !scFont && !letterSpacing && !wordSpacing && !toAdd && from==-1 ) { + // simply draw it + // Due to some unfounded cause TQPainter::drawText traverses the + // *whole* string when painting, not only the specified + // [pos, pos + len) segment. This makes painting *extremely* slow for + // long render texts (in the order of several megabytes). + // Hence, only hand over the piece of text of the actual inline text box + TQConstString cstr = TQConstString(str + pos, len); + p->drawText( x, y, cstr.string(), 0, len, d ); + } else { + if (from < 0) from = 0; + if (to < 0) to = len; + + int numSpaces = 0; + if ( toAdd ) { + for( int i = 0; i < len; ++i ) + if ( str[i+pos].category() == TQChar::Separator_Space ) + ++numSpaces; + } + + const int totWidth = width( str, slen, pos, len ); + if ( d == TQPainter::RTL ) { + x += totWidth + toAdd; + } + TQString upper = qstr; + TQFontMetrics sc_fm = fm; + if ( scFont ) { + // draw in small caps + upper = qstr.upper(); + sc_fm = TQFontMetrics( *scFont ); + } + + // ### sc could be optimized by only painting uppercase letters extra, + // and treat the rest WordWise, but I think it's not worth it. + // Somebody else may volunteer, and implement this ;-) (LS) + + // The mode determines whether the text is displayed character by + // character, word by word, or as a whole + enum { CharacterWise, WordWise, Whole } + mode = Whole; + if (!letterSpacing && !scFont && (wordSpacing || toAdd > 0)) + mode = WordWise; + else if (letterSpacing || scFont) + mode = CharacterWise; + + if (mode == Whole) { // most likely variant is treated extra + + if (to < 0) to = len; + const TQConstString cstr(str + pos, len); + const TQConstString segStr(str + pos + from, to - from); + const int preSegmentWidth = fm.width(cstr.string(), from); + const int segmentWidth = fm.width(segStr.string()); + const int eff_x = d == TQPainter::RTL ? x - preSegmentWidth - segmentWidth + : x + preSegmentWidth; + + // draw whole string segment, with optional background + if ( bg.isValid() ) + p->fillRect( eff_x, uy, segmentWidth, h, bg ); + p->drawText(eff_x, y, segStr.string(), -1, d); + if (deco) + drawDecoration(p, eff_x, uy, y - uy, segmentWidth - 1, h, deco); + return; + } + + // We are using two passes. In the first pass, the widths are collected, + // and stored. In the second, the actual characters are drawn. + + // For each letter in the text box, save the width of the character. + // When word-wise, only the first letter contains the width, but of the + // whole word. + short* const widthList = (short *)alloca(to*sizeof(short)); + + // First pass: gather widths + int preSegmentWidth = 0; + int segmentWidth = 0; + int lastWordBegin = 0; + bool onSegment = from == 0; + for( int i = 0; i < to; ++i ) { + if (i == from) { + // Also close words on visibility boundary + if (mode == WordWise) { + const int width = closeWordAndGetWidth(fm, str, pos, lastWordBegin, i); + + if (lastWordBegin < i) { + widthList[lastWordBegin] = (short)width; + lastWordBegin = i; + preSegmentWidth += width; + } + } + onSegment = true; + } + + const TQChar ch = str[pos+i]; + bool lowercase = (ch.category() == TQChar::Letter_Lowercase); + bool is_space = (ch.category() == TQChar::Separator_Space); + int chw = 0; + if ( letterSpacing ) + chw += letterSpacing; + if ( (wordSpacing || toAdd) && is_space ) { + if (mode == WordWise) { + const int width = closeWordAndGetWidth(fm, str, pos, lastWordBegin, i); + if (lastWordBegin < i) { + widthList[lastWordBegin] = (short)width; + lastWordBegin = i; + (onSegment ? segmentWidth : preSegmentWidth) += width; + } + ++lastWordBegin; // ignore this space + } + chw += wordSpacing; + if ( numSpaces ) { + const int a = toAdd/numSpaces; + chw += a; + toAdd -= a; + --numSpaces; + } + } + if (is_space || mode == CharacterWise) { + chw += lowercase ? sc_fm.charWidth( upper, pos+i ) : fm.charWidth( qstr, pos+i ); + widthList[i] = (short)chw; + + (onSegment ? segmentWidth : preSegmentWidth) += chw; + } + + } + + // close last word + Q_ASSERT(onSegment); + if (mode == WordWise) { + const int width = closeWordAndGetWidth(fm, str, pos, lastWordBegin, to); + segmentWidth += width; + widthList[lastWordBegin] = (short)width; + } + + if (d == TQPainter::RTL) x -= preSegmentWidth; + else x += preSegmentWidth; + + const int startx = d == TQPainter::RTL ? x-segmentWidth : x; + + // optionally draw background + if ( bg.isValid() ) + p->fillRect( startx, uy, segmentWidth, h, bg ); + + // second pass: do the actual drawing + lastWordBegin = from; + for( int i = from; i < to; ++i ) { + const TQChar ch = str[pos+i]; + bool lowercase = (ch.category() == TQChar::Letter_Lowercase); + bool is_space = ch.category() == TQChar::Separator_Space; + if ( is_space ) { + if (mode == WordWise) { + closeAndDrawWord(p, d, x, y, widthList, str, pos, lastWordBegin, i); + ++lastWordBegin; // jump over space + } + } + if (is_space || mode == CharacterWise) { + const int chw = widthList[i]; + if (d == TQPainter::RTL) + x -= chw; + + if ( scFont ) + p->setFont( lowercase ? *scFont : f ); + p->drawText( x, y, (lowercase ? upper : qstr), pos+i, 1, d ); + + if (d != TQPainter::RTL) + x += chw; + } + + } + + // don't forget to draw last word + if (mode == WordWise) { + closeAndDrawWord(p, d, x, y, widthList, str, pos, lastWordBegin, to); + } + + if (deco) + drawDecoration(p, startx, uy, y - uy, segmentWidth - 1, h, deco); + + if ( scFont ) + p->setFont( f ); + } +} + + +int Font::width( TQChar *chs, int, int pos, int len, int start, int end, int toAdd ) const +{ + const TQConstString cstr(chs+pos, len); + int w = 0; + + const TQString qstr = cstr.string(); + if ( scFont ) { + const TQString upper = qstr.upper(); + const TQChar *uc = qstr.unicode(); + const TQFontMetrics sc_fm( *scFont ); + for ( int i = 0; i < len; ++i ) { + if ( (uc+i)->category() == TQChar::Letter_Lowercase ) + w += sc_fm.charWidth( upper, i ); + else + w += fm.charWidth( qstr, i ); + } + } else { + // ### might be a little inaccurate + w = fm.width( qstr ); + } + + if ( letterSpacing ) + w += len*letterSpacing; + + if ( wordSpacing ) + // add amount + for( int i = 0; i < len; ++i ) { + if( chs[i+pos].category() == TQChar::Separator_Space ) + w += wordSpacing; + } + + if ( toAdd ) { + // first gather count of spaces + int numSpaces = 0; + for( int i = start; i != end; ++i ) + if ( chs[i].category() == TQChar::Separator_Space ) + ++numSpaces; + // distribute pixels evenly among spaces, but count only those within + // [pos, pos+len) + for ( int i = start; numSpaces && i != pos + len; i++ ) + if ( chs[i].category() == TQChar::Separator_Space ) { + const int a = toAdd/numSpaces; + if ( i >= pos ) w += a; + toAdd -= a; + --numSpaces; + } + } + + return w; +} + +int Font::width( TQChar *chs, int slen, int pos ) const +{ + int w; + if ( scFont && chs[pos].category() == TQChar::Letter_Lowercase ) { + TQString str( chs, slen ); + str[pos] = chs[pos].upper(); + w = TQFontMetrics( *scFont ).charWidth( str, pos ); + } else { + const TQConstString cstr( chs, slen ); + w = fm.charWidth( cstr.string(), pos ); + } + if ( letterSpacing ) + w += letterSpacing; + + if ( wordSpacing && (chs+pos)->category() == TQChar::Separator_Space ) + w += wordSpacing; + return w; +} + +/** Querying QFontDB whether something is scalable is expensive, so we cache. */ +struct Font::ScalKey +{ + TQString family; + int weight; + int italic; + + ScalKey(const TQFont& font) : + family(font.family()), weight(font.weight()), italic(font.italic()) + {} + + ScalKey() {} + + bool operator<(const ScalKey& other) const { + if (weight < other.weight) + return true; + if (weight > other.weight) + return false; + + if (italic < other.italic) + return true; + if (italic > other.italic) + return false; + + return family < other.family; + } + + bool operator==(const ScalKey& other) const { + return (weight == other.weight && + italic == other.italic && + family == other.family); + } +}; + +TQMap<Font::ScalKey, Font::ScalInfo>* Font::scalCache; +TQMap<Font::ScalKey, TQValueList<int> >* Font::scalSizesCache; + +bool Font::isFontScalable(TQFontDatabase& db, const TQFont& font) +{ + if (!scalCache) + scalCache = new TQMap<ScalKey, ScalInfo>; + + ScalKey key(font); + + ScalInfo &s = (*scalCache)[key]; + if (s == Unknown) { + s = db.isSmoothlyScalable(font.family(), db.styleString(font)) ? Yes : No; + + if (s == No) { + /* Cache size info */ + if (!scalSizesCache) + scalSizesCache = new TQMap<ScalKey, TQValueList<int> >; + (*scalSizesCache)[key] = db.smoothSizes(font.family(), db.styleString(font)); + } + } + + return (s == Yes); +} + + +void Font::update( TQPaintDeviceMetrics* devMetrics ) const +{ + f.setFamily( fontDef.family.isEmpty() ? KHTMLFactory::defaultHTMLSettings()->stdFontName() : fontDef.family ); + f.setItalic( fontDef.italic ); + f.setWeight( fontDef.weight ); + + TQFontDatabase db; + + int size = fontDef.size; + const int lDpiY = kMax(devMetrics->logicalDpiY(), 96); + + // ok, now some magic to get a nice unscaled font + // all other font properties should be set before this one!!!! + if( !isFontScalable(db, f) ) + { + const TQValueList<int>& pointSizes = (*scalSizesCache)[ScalKey(f)]; + // lets see if we find a nice looking font, which is not too far away + // from the requested one. + // kdDebug(6080) << "tdehtml::setFontSize family = " << f.family() << " size requested=" << size << endl; + + + float diff = 1; // ### 100% deviation + float bestSize = 0; + + TQValueList<int>::ConstIterator it = pointSizes.begin(); + const TQValueList<int>::ConstIterator itEnd = pointSizes.end(); + + for( ; it != itEnd; ++it ) + { + float newDiff = ((*it)*(lDpiY/72.) - float(size))/float(size); + //kdDebug( 6080 ) << "smooth font size: " << *it << " diff=" << newDiff << endl; + if(newDiff < 0) newDiff = -newDiff; + if(newDiff < diff) + { + diff = newDiff; + bestSize = *it; + } + } + //kdDebug( 6080 ) << "best smooth font size: " << bestSize << " diff=" << diff << endl; + if ( bestSize != 0 && diff < 0.2 ) // 20% deviation, otherwise we use a scaled font... + size = (int)((bestSize*lDpiY) / 72); + } + + // make sure we don't bust up X11 + // Also, Qt does not support sizing a TQFont to zero. + size = kMax(1, kMin(255, size)); + +// tqDebug("setting font to %s, italic=%d, weight=%d, size=%d", fontDef.family.latin1(), fontDef.italic, +// fontDef.weight, size ); + + + f.setPixelSize( size ); + + fm = TQFontMetrics( f ); + + // small caps + delete scFont; + scFont = 0; + + if ( fontDef.smallCaps ) { + scFont = new TQFont( f ); + scFont->setPixelSize( kMax(1, f.pixelSize()*7/10) ); + } +} + +void Font::drawDecoration(TQPainter *pt, int _tx, int _ty, int baseline, int width, int height, int deco) const +{ + Q_UNUSED(height); + // thick lines on small fonts look ugly + const int thickness = fm.height() > 20 ? fm.lineWidth() : 1; + const TQBrush brush = pt->pen().color(); + if (deco & UNDERLINE) { + int underlineOffset = ( fm.height() + baseline ) / 2; + if (underlineOffset <= baseline) underlineOffset = baseline+1; + + pt->fillRect(_tx, _ty + underlineOffset, width + 1, thickness, brush ); + } + if (deco & OVERLINE) { + pt->fillRect(_tx, _ty, width + 1, thickness, brush ); + } + if (deco & LINE_THROUGH) { + pt->fillRect(_tx, _ty + 2*baseline/3, width + 1, thickness, brush ); + } +} + diff --git a/tdehtml/rendering/font.h b/tdehtml/rendering/font.h new file mode 100644 index 000000000..81110e0d0 --- /dev/null +++ b/tdehtml/rendering/font.h @@ -0,0 +1,188 @@ +/* + * This file is part of the html renderer for KDE. + * + * Copyright (C) 2000-2003 Lars Knoll (knoll@kde.org) + * (C) 2000 Antti Koivisto (koivisto@kde.org) + * (C) 2000 Dirk Mueller (mueller@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#ifndef KHTMLFONT_H +#define KHTMLFONT_H + +#include <tqfont.h> +#include <tqfontmetrics.h> +#include <tqmap.h> +#include <tqpainter.h> + +class TQFontDatabase; +class TQPaintDeviceMetrics; + +namespace tdehtml +{ +class RenderStyle; +class CSSStyleSelector; + +class FontDef +{ +public: + FontDef() + : size( 0 ), italic( false ), smallCaps( false ), weight( 50 ) {} + bool operator == ( const FontDef &other ) const { + return ( family == other.family && + size == other.size && + italic == other.italic && + smallCaps == other.smallCaps && + weight == other.weight ); + } + + TQString family; + short int size; + bool italic : 1; + bool smallCaps : 1; + unsigned int weight : 8; +}; + + +class Font +{ + friend class RenderStyle; + friend class CSSStyleSelector; + +public: + Font() : fontDef(), f(), fm( f ), scFont( 0 ), letterSpacing( 0 ), wordSpacing( 0 ) {} + Font( const FontDef &fd ) + : fontDef( fd ), f(), fm( f ), scFont( 0 ), letterSpacing( 0 ), wordSpacing( 0 ) + {} + Font(const Font& o) + : fontDef(o.fontDef), f(o.f), fm(o.fm), scFont(o.scFont), letterSpacing(o.letterSpacing), wordSpacing(o.wordSpacing) { if (o.scFont) scFont = new TQFont(*o.scFont); } + ~Font() { delete scFont; } + + bool operator == ( const Font &other ) const { + return (fontDef == other.fontDef && + letterSpacing == other.letterSpacing && + wordSpacing == other.wordSpacing ); + } + + const FontDef& getFontDef() const { return fontDef; } + + void update( TQPaintDeviceMetrics *devMetrics ) const; + + /** + * Draws a piece from the given piece of text. + * @param p painter + * @param x x-coordinate to begin drawing, always denotes leftmost position + * @param y y-coordinate of baseline of text + * @param str string to draw a piece from + * @param slen total length of string + * @param pos zero-based offset of beginning of piece + * @param len length of piece + * @param width additional pixels to be distributed equally among all + * spaces + * @param d text direction + * @param from begin with this position relative to @p pos, -1 to start + * at @p pos + * @param to stop before this position relative to @p pos, -1 to use full + * length of piece + * @param bg if valid, fill the background of the drawn piece with this + * color + * @param uy y-coordinate of top position, used for background and text + * decoration painting + * @param h total height of line, only used for background and text + * decoration painting + * @param deco combined text decoration (see Decoration) + */ + void drawText( TQPainter *p, int x, int y, TQChar *str, int slen, int pos, int len, int width, + TQPainter::TextDirection d, int from=-1, int to=-1, TQColor bg=TQColor(), + int uy=-1, int h=-1, int deco=0 ) const; + + /** returns the width of the given string chunk in pixels. + * + * The method also considers various styles like text-align and font-variant + * @param str pointer to string + * @param slen total length of string + * @param pos zero-based position in string where to start measuring + * @param len count of characters up to which the width should be determined + * @param start starting position of inline text box within str, only + * used when toAdd is specified. + * @param end ending position of inline text box within str, only + * used when toAdd is specified. + * @param toAdd amount of pixels to distribute evenly among all spaces of + * str. Note that toAdd applies to all spaces within str, but only those + * within [pos, pos+len) are counted towards the width. + */ + int width( TQChar *str, int slen, int pos, int len, int start = 0, int end = 0, int toAdd = 0 ) const; + /** return the width of the given char in pixels. + * + * The method also considers various styles like text-align and font-variant + * @param str pointer to string + * @param slen total length of string + * @param pos zero-based position of char in string + */ + int width( TQChar *str, int slen, int pos) const; + + /** Text decoration constants. + * + * The enumeration constant values match those of ETextDecoration, but only + * a subset is supported. + */ + enum Decoration { UNDERLINE = 0x1, OVERLINE = 0x2, LINE_THROUGH= 0x4 }; + // Keep in sync with ETextDecoration + + /** draws text decoration + * @param p painter + * @param x x-coordinate + * @param y top y-coordinate of line box + * @param baseline baseline + * @param width length of decoration in pixels + * @param height height of line box + * @param deco decoration to be drawn (see Decoration). The enumeration + * constants may be combined. + */ + void drawDecoration(TQPainter *p, int x, int y, int baseline, int width, int height, int deco) const; + + /** returns letter spacing + */ + int getLetterSpacing() const { return letterSpacing; } + /** returns word spacing + */ + int getWordSpacing() const { return wordSpacing; } + +private: + mutable FontDef fontDef; + mutable TQFont f; + mutable TQFontMetrics fm; + mutable TQFont *scFont; + short letterSpacing; + short wordSpacing; + + struct ScalKey; + enum ScalInfo { + Unknown, + No, + Yes + }; + + static TQMap<ScalKey, ScalInfo>* scalCache; + static TQMap<ScalKey, TQValueList<int> >* scalSizesCache; + static bool isFontScalable(TQFontDatabase& db, const TQFont& font); +}; + +} // namespace + +#endif diff --git a/tdehtml/rendering/img-loading.png b/tdehtml/rendering/img-loading.png Binary files differnew file mode 100644 index 000000000..ae5a9732f --- /dev/null +++ b/tdehtml/rendering/img-loading.png diff --git a/tdehtml/rendering/loading_icon.cpp b/tdehtml/rendering/loading_icon.cpp new file mode 100644 index 000000000..218befcf8 --- /dev/null +++ b/tdehtml/rendering/loading_icon.cpp @@ -0,0 +1,25 @@ +static const unsigned char loading_icon_data[] = { +0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44, +0x52,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x10,0x08,0x04,0x00,0x00,0x00,0x8c, +0x9d,0x86,0xb1,0x00,0x00,0x00,0x04,0x67,0x41,0x4d,0x41,0x00,0x00,0xb1,0x8f, +0x0b,0xfc,0x61,0x05,0x00,0x00,0x00,0x02,0x62,0x4b,0x47,0x44,0x00,0xff,0x87, +0x8f,0xcc,0xbf,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x12, +0x00,0x00,0x0b,0x12,0x01,0xd2,0xdd,0x7e,0xfc,0x00,0x00,0x00,0x07,0x74,0x49, +0x4d,0x45,0x07,0xd4,0x0c,0x17,0x10,0x00,0x23,0xf3,0x04,0xa4,0xbc,0x00,0x00, +0x00,0xbf,0x49,0x44,0x41,0x54,0x78,0x9c,0x75,0xd1,0x31,0x4e,0x04,0x31,0x0c, +0x85,0xe1,0x2f,0xc9,0x1c,0x63,0xee,0x02,0x82,0x9a,0x23,0x70,0x01,0xba,0xad, +0xe8,0x98,0x0d,0x35,0xab,0xe9,0x10,0xf7,0x80,0x76,0xe0,0x32,0x7b,0x01,0x44, +0x9d,0x84,0x22,0xc3,0x32,0xd2,0x82,0x5d,0xd9,0xbf,0xf5,0xe4,0x67,0x07,0xd9, +0x59,0x4c,0xf2,0x04,0x91,0xf6,0x47,0x3e,0x64,0x18,0xe0,0x1d,0x51,0x15,0x05, +0x05,0xc1,0x5e,0xc8,0x79,0x1a,0xba,0x50,0x54,0x3d,0x49,0x76,0xa2,0xaa,0x61, +0x4f,0x8e,0x1d,0x05,0xb3,0x1b,0xc5,0xb5,0x2a,0x79,0x14,0x04,0xb9,0xcb,0x06, +0x45,0xf1,0x2a,0x21,0x2a,0x16,0x5c,0x09,0x1d,0x16,0xd1,0xbd,0x4b,0x2c,0xaa, +0xa4,0x48,0x4e,0x0b,0xf5,0x58,0x24,0xcd,0x2d,0x38,0x6a,0xdd,0x0a,0xd1,0x41, +0x41,0x01,0xcf,0xa7,0xf1,0x08,0xd5,0x68,0x16,0x11,0x70,0xe7,0x73,0x0b,0x13, +0x46,0x07,0x34,0x47,0x47,0x5f,0x2b,0x1c,0xa0,0x81,0xd1,0x6c,0x67,0xd9,0x9c, +0x71,0xe8,0xb2,0x2f,0x6b,0xf9,0xe6,0x43,0xd0,0xd4,0x5f,0x98,0x2c,0x48,0x9a, +0xba,0xb6,0x37,0x56,0x2e,0xce,0x1f,0xf3,0x03,0xc3,0x3f,0x88,0x6f,0xc1,0xe0, +0x3e,0x9e,0x60,0xe9,0x10,0xaa,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae, +0x42,0x60,0x82 +}; +static const unsigned int loading_icon_len = 318; diff --git a/tdehtml/rendering/render_applet.cpp b/tdehtml/rendering/render_applet.cpp new file mode 100644 index 000000000..1b65ca8de --- /dev/null +++ b/tdehtml/rendering/render_applet.cpp @@ -0,0 +1,145 @@ +/** + * This file is part of the HTML widget for KDE. + * + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#include <config.h> +#include <klocale.h> + +#include <kdebug.h> + +#include "rendering/render_applet.h" +#include "rendering/render_canvas.h" +#include "xml/dom_docimpl.h" +#include "tdehtmlview.h" +#include "tdehtml_part.h" + +#include <tqlabel.h> + +#ifndef Q_WS_QWS // We don't have Java in Qt Embedded + +#include "java/kjavaappletwidget.h" +#include "misc/htmltags.h" +#include "html/html_objectimpl.h" + +using namespace tdehtml; +using namespace DOM; + +RenderApplet::RenderApplet(HTMLElementImpl *applet, const TQMap<TQString, TQString> &args ) + : RenderWidget(applet) +{ + // init RenderObject attributes + setInline(true); + + KJavaAppletContext *context = 0; + KHTMLView *_view = applet->getDocument()->view(); + if ( _view ) { + KHTMLPart *part = _view->part(); + context = part->createJavaContext(); + } + + if ( context ) { + //kdDebug(6100) << "RenderApplet::RenderApplet, setting TQWidget" << endl; + setQWidget( new KJavaAppletWidget(context, _view->viewport()) ); + processArguments(args); + } +} + +RenderApplet::~RenderApplet() +{ +} + +short RenderApplet::intrinsicWidth() const +{ + int rval = 300; + + if( m_widget ) + rval = ((KJavaAppletWidget*)(m_widget))->sizeHint().width(); + + return rval > 10 ? rval : 50; +} + +int RenderApplet::intrinsicHeight() const +{ + int rval = 150; + + if( m_widget ) + rval = m_widget->sizeHint().height(); + + return rval > 10 ? rval : 50; +} + +void RenderApplet::layout() +{ + //kdDebug(6100) << "RenderApplet::layout" << endl; + + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + + calcWidth(); + calcHeight(); + + KJavaAppletWidget *tmp = static_cast<KJavaAppletWidget*>(m_widget); + if ( tmp ) { + NodeImpl *child = element()->firstChild(); + + while(child) { + + if(child->id() == ID_PARAM) { + HTMLParamElementImpl *p = static_cast<HTMLParamElementImpl *>(child); + if(tmp->applet()) + tmp->applet()->setParameter( p->name(), p->value()); + } + child = child->nextSibling(); + } + //kdDebug(6100) << "setting applet widget to size: " << m_width << ", " << m_height << endl; + m_widget->resize(m_width-borderLeft()-borderRight()-paddingLeft()-paddingRight(), + m_height-borderTop()-borderBottom()-paddingTop()-paddingBottom()); + tmp->showApplet(); + } + + setNeedsLayout(false); +} + +void RenderApplet::processArguments(const TQMap<TQString, TQString> &args) +{ + KJavaAppletWidget *w = static_cast<KJavaAppletWidget*>(m_widget); + KJavaApplet* applet = w ? w->applet() : 0; + + if ( applet ) { + applet->setBaseURL( args[TQString::fromLatin1("baseURL") ] ); + applet->setAppletClass( args[TQString::fromLatin1("code") ] ); + + TQString str = args[TQString::fromLatin1("codeBase") ]; + if( !str.isEmpty() ) + applet->setCodeBase( str ); + + str = args[TQString::fromLatin1("name") ]; + if( !str.isNull() ) + applet->setAppletName( str ); + else + applet->setAppletName( args[TQString::fromLatin1("code") ] ); + + str = args[TQString::fromLatin1("archive") ]; + if( !str.isEmpty() ) + applet->setArchives( args[TQString::fromLatin1("archive") ] ); + } +} + +#endif diff --git a/tdehtml/rendering/render_applet.h b/tdehtml/rendering/render_applet.h new file mode 100644 index 000000000..24907edaa --- /dev/null +++ b/tdehtml/rendering/render_applet.h @@ -0,0 +1,60 @@ +/* + * This file is part of the HTML widget for KDE. + * + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef render_applet_h +#define render_applet_h + +#include "rendering/render_replaced.h" +#include "html/html_objectimpl.h" + +#include <tqwidget.h> +#include <tqmap.h> + +class KHTMLView; + +namespace DOM { + class HTMLElementImpl; +} + +namespace tdehtml { + +class RenderApplet : public RenderWidget +{ +public: + RenderApplet(DOM::HTMLElementImpl* node, const TQMap<TQString, TQString> &args); + virtual ~RenderApplet(); + + virtual const char *renderName() const { return "RenderApplet"; } + + virtual void layout(); + virtual short intrinsicWidth() const; + virtual int intrinsicHeight() const; + virtual bool isApplet() const { return true; } + + DOM::HTMLElementImpl *element() const + { return static_cast<DOM::HTMLElementImpl*>(RenderObject::element()); } + +private: + void processArguments( const TQMap<TQString, TQString> &args ); +}; + +} +#endif diff --git a/tdehtml/rendering/render_arena.cpp b/tdehtml/rendering/render_arena.cpp new file mode 100644 index 000000000..14c55ef89 --- /dev/null +++ b/tdehtml/rendering/render_arena.cpp @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2002 Apple Computer, Inc. + * Copyright (C) 2003 Dirk Mueller (mueller@kde.org) + * + * Portions are Copyright (C) 1998 Netscape Communications Corporation. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Alternatively, the contents of this file may be used under the terms + * of either the Mozilla Public License Version 1.1, found at + * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public + * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html + * (the "GPL"), in which case the provisions of the MPL or the GPL are + * applicable instead of those above. If you wish to allow use of your + * version of this file only under the terms of one of those two + * licenses (the MPL or the GPL) and not to allow others to use your + * version of this file under the LGPL, indicate your decision by + * deletingthe provisions above and replace them with the notice and + * other provisions required by the MPL or the GPL, as the case may be. + * If you do not delete the provisions above, a recipient may use your + * version of this file under any of the LGPL, the MPL or the GPL. + */ + +#include "render_arena.h" + +#include <string.h> +#include <assert.h> + +using namespace tdehtml; + +namespace tdehtml { + +//#ifdef NDEBUG +#define KHTML_USE_ARENA_ALLOCATOR +//#endif + +typedef struct { + RenderArena *arena; + size_t size; +} RenderArenaDebugHeader; + +#ifdef VALGRIND_SUPPORT +Arena* findContainingArena(ArenaPool* pool, void* ptr) { + uword ptrBits = reinterpret_cast<uword>(ptr); + for (Arena* a = &pool->first; a; a = a->next) + if (ptrBits >= a->base && ptrBits < a->limit) + return a; + return 0; //Should not happen +} +#endif + +RenderArena::RenderArena(unsigned int arenaSize) +{ + // Initialize the arena pool + INIT_ARENA_POOL(&m_pool, "RenderArena", arenaSize); + + // Zero out the recyclers array + memset(m_recyclers, 0, sizeof(m_recyclers)); +} + +RenderArena::~RenderArena() +{ + // Free the arena in the pool and finish using it + FreeArenaPool(&m_pool); +} + +void* RenderArena::allocate(size_t size) +{ +#ifndef KHTML_USE_ARENA_ALLOCATOR + // Use standard malloc so that memory debugging tools work. + void *block = ::malloc(sizeof(RenderArenaDebugHeader) + size); + RenderArenaDebugHeader *header = (RenderArenaDebugHeader *)block; + header->arena = this; + header->size = size; + return header + 1; +#else + void* result = 0; + + // Ensure we have correct alignment for pointers. Important for Tru64 + size = KHTML_ROUNDUP(size, sizeof(void*)); + + // Check recyclers first + if (size < KHTML_MAX_RECYCLED_SIZE) { + const int index = size >> 2; + + result = m_recyclers[index]; + if (result) { +#ifdef VALGRIND_SUPPORT + VALGRIND_MEMPOOL_ALLOC(findContainingArena(&m_pool, result)->base, result, size); +#endif + // Need to move to the next object + void* next = *((void**)result); + m_recyclers[index] = next; + } + } + + if (!result) { + // Allocate a new chunk from the arena + ARENA_ALLOCATE(result, &m_pool, size); + } + + return result; +#endif +} + +void RenderArena::free(size_t size, void* ptr) +{ +#ifndef KHTML_USE_ARENA_ALLOCATOR + // Use standard free so that memory debugging tools work. + assert(this); + RenderArenaDebugHeader *header = (RenderArenaDebugHeader *)ptr - 1; + assert(header->size == size); + assert(header->arena == this); + ::free(header); +#else + +#ifdef VALGRIND_SUPPORT + VALGRIND_MEMPOOL_FREE(findContainingArena(&m_pool, ptr)->base, ptr); +#endif + + // Ensure we have correct alignment for pointers. Important for Tru64 + size = KHTML_ROUNDUP(size, sizeof(void*)); + + // See if it's a size that we recycle + if (size < KHTML_MAX_RECYCLED_SIZE) { + const int index = size >> 2; + void* currentTop = m_recyclers[index]; + m_recyclers[index] = ptr; + *((void**)ptr) = currentTop; + } +#endif +} + +} diff --git a/tdehtml/rendering/render_arena.h b/tdehtml/rendering/render_arena.h new file mode 100644 index 000000000..1beab6fed --- /dev/null +++ b/tdehtml/rendering/render_arena.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2002 Apple Computer, Inc. + * Copyright (C) 2003 Dirk Mueller (mueller@kde.org) + * + * Portions are Copyright (C) 1998 Netscape Communications Corporation. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Alternatively, the contents of this file may be used under the terms + * of either the Mozilla Public License Version 1.1, found at + * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public + * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html + * (the "GPL"), in which case the provisions of the MPL or the GPL are + * applicable instead of those above. If you wish to allow use of your + * version of this file only under the terms of one of those two + * licenses (the MPL or the GPL) and not to allow others to use your + * version of this file under the LGPL, indicate your decision by + * deletingthe provisions above and replace them with the notice and + * other provisions required by the MPL or the GPL, as the case may be. + * If you do not delete the provisions above, a recipient may use your + * version of this file under any of the LGPL, the MPL or the GPL. + */ + +#ifndef RENDERARENA_H +#define RENDERARENA_H + +#include "misc/arena.h" +#include "misc/shared.h" + +#include <stdlib.h> + +namespace tdehtml { + +#define KHTML_MAX_RECYCLED_SIZE 400 +#define KHTML_ROUNDUP(x,y) ((((x)+((y)-1))/(y))*(y)) + +class RenderArena: public Shared<RenderArena> { +public: + RenderArena(unsigned int arenaSize = 4096); + ~RenderArena(); + + // Memory management functions + void* allocate(size_t size); + void free(size_t size, void* ptr); + +private: + // Underlying arena pool + ArenaPool m_pool; + + // The recycler array is sparse with the indices being multiples of 4, + // i.e., 0, 4, 8, 12, 16, 20, ... + void* m_recyclers[KHTML_MAX_RECYCLED_SIZE >> 2]; +}; + + +} // namespace + + +#endif + diff --git a/tdehtml/rendering/render_block.cpp b/tdehtml/rendering/render_block.cpp new file mode 100644 index 000000000..3c6c79543 --- /dev/null +++ b/tdehtml/rendering/render_block.cpp @@ -0,0 +1,3155 @@ +/* + * This file is part of the render object implementation for KHTML. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999-2003 Antti Koivisto (koivisto@kde.org) + * (C) 2002-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003,2005 Apple Computer, Inc. + * (C) 2004 Germain Garand (germain@ebooksfrance.org) + * (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * (C) 2006 Charles Samuels (charles@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +//#define DEBUG +//#define DEBUG_LAYOUT +//#define BOX_DEBUG +//#define FLOAT_DEBUG +//#define PAGE_DEBUG + +#include <kdebug.h> +#include "rendering/render_text.h" +#include "rendering/render_table.h" +#include "rendering/render_canvas.h" +#include "rendering/render_layer.h" +#include "rendering/render_block.h" + +#include "xml/dom_nodeimpl.h" +#include "xml/dom_docimpl.h" +#include "html/html_formimpl.h" +#include "misc/htmltags.h" + +#include "tdehtmlview.h" + +using namespace DOM; + +namespace tdehtml { + +// ------------------------------------------------------------------------------------------------------- + +// Our MarginInfo state used when laying out block children. +RenderBlock::MarginInfo::MarginInfo(RenderBlock* block, int top, int bottom) +{ + // Whether or not we can collapse our own margins with our children. We don't do this + // if we had any border/padding (obviously), if we're the root or HTML elements, or if + // we're positioned, floating, a table cell. + m_canCollapseWithChildren = !block->isCanvas() && !block->isRoot() && !block->isPositioned() && + !block->isFloating() && !block->isTableCell() && !block->hasOverflowClip() && !block->isInlineBlockOrInlineTable(); + + m_canCollapseTopWithChildren = m_canCollapseWithChildren && (top == 0) /*&& block->style()->marginTopCollapse() != MSEPARATE */; + + // If any height other than auto is specified in CSS, then we don't collapse our bottom + // margins with our children's margins. To do otherwise would be to risk odd visual + // effects when the children overflow out of the parent block and yet still collapse + // with it. We also don't collapse if we have any bottom border/padding. + m_canCollapseBottomWithChildren = m_canCollapseWithChildren && (bottom == 0) && + (block->style()->height().isVariable() && block->style()->height().value() == 0) /*&& block->style()->marginBottomCollapse() != MSEPARATE*/; + + m_quirkContainer = block->isTableCell() || block->isBody() /*|| block->style()->marginTopCollapse() == MDISCARD || + block->style()->marginBottomCollapse() == MDISCARD*/; + + m_atTopOfBlock = true; + m_atBottomOfBlock = false; + + m_posMargin = m_canCollapseTopWithChildren ? block->maxTopMargin(true) : 0; + m_negMargin = m_canCollapseTopWithChildren ? block->maxTopMargin(false) : 0; + + m_selfCollapsingBlockClearedFloat = false; + + m_topQuirk = m_bottomQuirk = m_determinedTopQuirk = false; +} + +// ------------------------------------------------------------------------------------------------------- + +RenderBlock::RenderBlock(DOM::NodeImpl* node) + : RenderFlow(node) +{ + m_childrenInline = true; + m_floatingObjects = 0; + m_positionedObjects = 0; + m_firstLine = false; + m_avoidPageBreak = false; + m_clearStatus = CNONE; + m_maxTopPosMargin = m_maxTopNegMargin = m_maxBottomPosMargin = m_maxBottomNegMargin = 0; + m_topMarginQuirk = m_bottomMarginQuirk = false; + m_overflowHeight = m_overflowWidth = 0; + m_overflowLeft = m_overflowTop = 0; +} + +RenderBlock::~RenderBlock() +{ + delete m_floatingObjects; + delete m_positionedObjects; +} + +void RenderBlock::setStyle(RenderStyle* _style) +{ + setReplaced(_style->isDisplayReplacedType()); + + RenderFlow::setStyle(_style); + + // ### we could save this call when the change only affected + // non inherited properties + RenderObject *child = firstChild(); + while (child != 0) + { + if (child->isAnonymousBlock()) + { + RenderStyle* newStyle = new RenderStyle(); + newStyle->inheritFrom(style()); + newStyle->setDisplay(BLOCK); + child->setStyle(newStyle); + } + child = child->nextSibling(); + } + + if (attached()) { + // Update generated content and ::inside + updateReplacedContent(); + // Update pseudos for :before and :after + updatePseudoChildren(); + } + + // handled by close() during parsing + // ### remove close move upto updatePseudo + if (!document()->parsing()) { + updateFirstLetter(); + } +} + +// Attach handles initial setStyle that requires parent nodes +void RenderBlock::attach() +{ + RenderFlow::attach(); + + updateReplacedContent(); + updatePseudoChildren(); +} + +void RenderBlock::updateFirstLetter() +{ + // Only blocks with inline-children can generate a first-letter + if (!childrenInline() || !firstChild()) return; + + // Don't recurse + if (style()->styleType() == RenderStyle::FIRST_LETTER) return; + + // The first-letter style is inheritable. + RenderStyle *pseudoStyle = style()->getPseudoStyle(RenderStyle::FIRST_LETTER); + RenderObject *o = this; + while (o && !pseudoStyle) { + // ### We should ignore empty preceding siblings + if (o->parent() && o->parent()->firstChild() == this) + o = o->parent(); + else + break; + pseudoStyle = o->style()->getPseudoStyle(RenderStyle::FIRST_LETTER); + }; + + // FIXME: Currently we don't delete first-letters, this is + // handled instead in NodeImpl::diff by issuing Detach on first-letter changes. + if (!pseudoStyle) { + return; + } + + // Drill into inlines looking for our first text child. + RenderObject* firstText = firstChild(); + while (firstText && firstText->needsLayout() && !firstText->isFloating() && !firstText->isRenderBlock() && !firstText->isReplaced() && !firstText->isText()) + // ### We should skip first children with only white-space and punctuation + firstText = firstText->firstChild(); + + if (firstText && firstText->isText() && !firstText->isBR()) { + RenderObject* firstLetterObject = 0; + // Find the old first-letter + if (firstText->parent()->style()->styleType() == RenderStyle::FIRST_LETTER) + firstLetterObject = firstText->parent(); + + // Force inline display (except for floating first-letters) + pseudoStyle->setDisplay( pseudoStyle->isFloating() ? BLOCK : INLINE); + pseudoStyle->setPosition( STATIC ); // CSS2 says first-letter can't be positioned. + + if (firstLetterObject != 0) { + firstLetterObject->setStyle( pseudoStyle ); + RenderStyle* newStyle = new RenderStyle(); + newStyle->inheritFrom( pseudoStyle ); + firstText->setStyle( newStyle ); + return; + } + + RenderText* textObj = static_cast<RenderText*>(firstText); + RenderObject* firstLetterContainer = firstText->parent(); + + firstLetterObject = RenderFlow::createFlow(node(), pseudoStyle, renderArena() ); + firstLetterObject->setIsAnonymous( true ); + firstLetterContainer->addChild(firstLetterObject, firstLetterContainer->firstChild()); + + // if this object is the result of a :begin, then the text may have not been + // generated yet if it is a counter + if (textObj->recalcMinMax()) + textObj->recalcMinMaxWidths(); + + // The original string is going to be either a generated content string or a DOM node's + // string. We want the original string before it got transformed in case first-letter has + // no text-transform or a different text-transform applied to it. + DOMStringImpl* oldText = textObj->originalString(); + if (!oldText) + oldText = textObj->string(); + // ### In theory a first-letter can stretch across multiple text objects, if they only contain + // punctuation and white-space + if(oldText->l >= 1) { + oldText->ref(); + // begin: we need skip leading whitespace so that RenderBlock::findNextLineBreak + // won't think we're continuing from a previous run + unsigned int begin = 0; // the position that first-letter begins + unsigned int length = 0; // the position that "the rest" begins + while ( length < oldText->l && (oldText->s+length)->isSpace() ) + length++; + begin = length; + while ( length < oldText->l && + ( (oldText->s+length)->isPunct()) || (oldText->s+length)->isSpace() ) + length++; + if ( length < oldText->l && + !( (oldText->s+length)->isSpace() || (oldText->s+length)->isPunct() )) + length++; + while ( length < oldText->l && (oldText->s+length)->isMark() ) + length++; + + // we need to generated a remainingText object even if no text is left + // because it holds the place and style for the old textObj + RenderTextFragment* remainingText = + new (renderArena()) RenderTextFragment(textObj->node(), oldText, length, oldText->l-length); + remainingText->setIsAnonymous( textObj->isAnonymous() ); + remainingText->setStyle(textObj->style()); + if (remainingText->element()) + remainingText->element()->setRenderer(remainingText); + + RenderObject* nextObj = textObj->nextSibling(); + textObj->detach(); + firstLetterContainer->addChild(remainingText, nextObj); + + RenderTextFragment* letter = + new (renderArena()) RenderTextFragment(remainingText->node(), oldText, begin, length-begin); + letter->setIsAnonymous( remainingText->isAnonymous() ); + RenderStyle* newStyle = new RenderStyle(); + newStyle->inheritFrom(pseudoStyle); + letter->setStyle(newStyle); + firstLetterObject->addChild(letter); + oldText->deref(); + } + firstLetterObject->close(); + } +} + +void RenderBlock::addChildToFlow(RenderObject* newChild, RenderObject* beforeChild) +{ + // Make sure we don't append things after :after-generated content if we have it. + if ( !beforeChild && lastChild() && lastChild()->style()->styleType() == RenderStyle::AFTER ) + beforeChild = lastChild(); + + bool madeBoxesNonInline = false; + + // If the requested beforeChild is not one of our children, then this is most likely because + // there is an anonymous block box within this object that contains the beforeChild. So + // just insert the child into the anonymous block box instead of here. This may also be + // needed in cases of things like anonymous tables. + if (beforeChild && beforeChild->parent() != this) { + + KHTMLAssert(beforeChild->parent()); + + // In the special case where we are prepending a block-level element before + // something contained inside an anonymous block, we can just prepend it before + // the anonymous block. + if (!newChild->isInline() && beforeChild->parent()->isAnonymousBlock() && + beforeChild->parent()->parent() == this && + beforeChild->parent()->firstChild() == beforeChild) + return addChildToFlow(newChild, beforeChild->parent()); + + // Otherwise find our kid inside which the beforeChild is, and delegate to it. + // This may be many levels deep due to anonymous tables, table sections, etc. + RenderObject* responsible = beforeChild->parent(); + while (responsible->parent() != this) + responsible = responsible->parent(); + + return responsible->addChild(newChild,beforeChild); + } + + // prevent elements that haven't received a layout yet from getting painted by pushing + // them far above the top of the page + if (!newChild->isInline()) + newChild->setPos(newChild->xPos(), -500000); + + if (!newChild->isText() && newChild->style()->position() != STATIC) + setOverhangingContents(); + + // A block has to either have all of its children inline, or all of its children as blocks. + // So, if our children are currently inline and a block child has to be inserted, we move all our + // inline children into anonymous block boxes + if ( m_childrenInline && !newChild->isInline() && !newChild->isFloatingOrPositioned() ) + { + // This is a block with inline content. Wrap the inline content in anonymous blocks. + makeChildrenNonInline(beforeChild); + madeBoxesNonInline = true; + + if (beforeChild && beforeChild->parent() != this) { + beforeChild = beforeChild->parent(); + KHTMLAssert(beforeChild->isAnonymousBlock()); + KHTMLAssert(beforeChild->parent() == this); + } + } + else if (!m_childrenInline && !newChild->isFloatingOrPositioned()) + { + // If we're inserting an inline child but all of our children are blocks, then we have to make sure + // it is put into an anomyous block box. We try to use an existing anonymous box if possible, otherwise + // a new one is created and inserted into our list of children in the appropriate position. + if (newChild->isInline()) { + if (beforeChild) { + if ( beforeChild->previousSibling() && beforeChild->previousSibling()->isAnonymousBlock() ) { + beforeChild->previousSibling()->addChild(newChild); + return; + } + } + else { + if ( m_last && m_last->isAnonymousBlock() ) { + m_last->addChild(newChild); + return; + } + } + + // no suitable existing anonymous box - create a new one + RenderBlock* newBox = createAnonymousBlock(); + RenderBox::addChild(newBox,beforeChild); + newBox->addChild(newChild); + + //the above may actually destroy newBox in case an anonymous + //table got created, and made the anonymous block redundant. + //so look up what to hide indirectly. + RenderObject* toHide = newChild; + while (toHide->parent() != this) + toHide = toHide->parent(); + + toHide->setPos(toHide->xPos(), -500000); + return; + } + else { + // We are adding another block child... if the current last child is an anonymous box + // then it needs to be closed. + // ### get rid of the closing thing altogether this will only work during initial parsing + if (lastChild() && lastChild()->isAnonymous()) { + lastChild()->close(); + } + } + } + + RenderBox::addChild(newChild,beforeChild); + // ### care about aligned stuff + + if ( madeBoxesNonInline ) + removeLeftoverAnonymousBoxes(); +} + +static void getInlineRun(RenderObject* start, RenderObject* stop, + RenderObject*& inlineRunStart, + RenderObject*& inlineRunEnd) +{ + // Beginning at |start| we find the largest contiguous run of inlines that + // we can. We denote the run with start and end points, |inlineRunStart| + // and |inlineRunEnd|. Note that these two values may be the same if + // we encounter only one inline. + // + // We skip any non-inlines we encounter as long as we haven't found any + // inlines yet. + // + // |stop| indicates a non-inclusive stop point. Regardless of whether |stop| + // is inline or not, we will not include it in a run with inlines before it. It's as though we encountered + // a non-inline. + + RenderObject * curr = start; + bool sawInline; + do { + while (curr && !(curr->isInline() || curr->isFloatingOrPositioned())) + curr = curr->nextSibling(); + + inlineRunStart = inlineRunEnd = curr; + + if (!curr) + return; // No more inline children to be found. + + sawInline = curr->isInline(); + + curr = curr->nextSibling(); + while (curr && (curr->isInline() || curr->isFloatingOrPositioned()) && (curr != stop)) { + inlineRunEnd = curr; + if (curr->isInline()) + sawInline = true; + curr = curr->nextSibling(); + } + } while (!sawInline); + +} + +void RenderBlock::makeChildrenNonInline(RenderObject *insertionPoint) +{ + // makeChildrenNonInline takes a block whose children are *all* inline and it + // makes sure that inline children are coalesced under anonymous + // blocks. If |insertionPoint| is defined, then it represents the insertion point for + // the new block child that is causing us to have to wrap all the inlines. This + // means that we cannot coalesce inlines before |insertionPoint| with inlines following + // |insertionPoint|, because the new child is going to be inserted in between the inlines, + // splitting them. + KHTMLAssert(isReplacedBlock() || !isInline()); + KHTMLAssert(!insertionPoint || insertionPoint->parent() == this); + + m_childrenInline = false; + + RenderObject *child = firstChild(); + + while (child) { + RenderObject *inlineRunStart, *inlineRunEnd; + getInlineRun(child, insertionPoint, inlineRunStart, inlineRunEnd); + + if (!inlineRunStart) + break; + + child = inlineRunEnd->nextSibling(); + + RenderBlock* box = createAnonymousBlock(); + insertChildNode(box, inlineRunStart); + RenderObject* o = inlineRunStart; + while(o != inlineRunEnd) + { + RenderObject* no = o; + o = no->nextSibling(); + box->appendChildNode(removeChildNode(no)); + } + box->appendChildNode(removeChildNode(inlineRunEnd)); + box->close(); + box->setPos(box->xPos(), -500000); + } +} + +void RenderBlock::makePageBreakAvoidBlocks() +{ + KHTMLAssert(!childrenInline()); + KHTMLAssert(canvas()->pagedMode()); + + RenderObject *breakAfter = firstChild(); + RenderObject *breakBefore = breakAfter ? breakAfter->nextSibling() : 0; + + RenderBlock* pageRun = 0; + + // ### Should follow margin-collapsing rules, skipping self-collapsing blocks + // and exporting page-breaks from first/last child when collapsing with parent margin. + while (breakAfter) { + if (breakAfter->isRenderBlock() && !breakAfter->childrenInline()) + static_cast<RenderBlock*>(breakAfter)->makePageBreakAvoidBlocks(); + EPageBreak pbafter = breakAfter->style()->pageBreakAfter(); + EPageBreak pbbefore = breakBefore ? breakBefore->style()->pageBreakBefore() : PBALWAYS; + if ((pbafter == PBAVOID && pbbefore == PBAVOID) || + (pbafter == PBAVOID && pbbefore == PBAUTO) || + (pbafter == PBAUTO && pbbefore == PBAVOID)) + { + if (!pageRun) { + pageRun = createAnonymousBlock(); + pageRun->m_avoidPageBreak = true; + pageRun->setChildrenInline(false); + } + pageRun->appendChildNode(removeChildNode(breakAfter)); + } else + { + if (pageRun) { + pageRun->appendChildNode(removeChildNode(breakAfter)); + pageRun->close(); + insertChildNode(pageRun, breakBefore); + pageRun = 0; + } + } + breakAfter = breakBefore; + breakBefore = breakBefore ? breakBefore->nextSibling() : 0; + } + + // recurse into positioned block children as well. + if (m_positionedObjects) { + TQPtrListIterator<RenderObject> it(*m_positionedObjects); + for ( ; it.current(); ++it ) { + if (it.current()->isRenderBlock() && !it.current()->childrenInline()) { + static_cast<RenderBlock*>(it.current())->makePageBreakAvoidBlocks(); + } + } + } + + // recurse into floating block children. + if (m_floatingObjects) { + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; it.current(); ++it ) { + if (it.current()->node->isRenderBlock() && !it.current()->node->childrenInline()) { + static_cast<RenderBlock*>(it.current()->node)->makePageBreakAvoidBlocks(); + } + } + } +} + +void RenderBlock::removeChild(RenderObject *oldChild) +{ + // If this child is a block, and if our previous and next siblings are + // both anonymous blocks with inline content, then we can go ahead and + // fold the inline content back together. + RenderObject* prev = oldChild->previousSibling(); + RenderObject* next = oldChild->nextSibling(); + bool mergedBlocks = false; + if (document()->renderer() && !isInline() && !oldChild->isInline() && !oldChild->continuation() && + prev && prev->isAnonymousBlock() && prev->childrenInline() && + next && next->isAnonymousBlock() && next->childrenInline()) { + // Take all the children out of the |next| block and put them in + // the |prev| block. + RenderObject* o = next->firstChild(); + while (o) { + RenderObject* no = o; + o = no->nextSibling(); + prev->appendChildNode(next->removeChildNode(no)); + no->setNeedsLayoutAndMinMaxRecalc(); + } + prev->setNeedsLayoutAndMinMaxRecalc(); + + // Nuke the now-empty block. + next->detach(); + + mergedBlocks = true; + } + + RenderFlow::removeChild(oldChild); + + if (mergedBlocks && prev && !prev->previousSibling() && !prev->nextSibling()) { + // The remerge has knocked us down to containing only a single anonymous + // box. We can go ahead and pull the content right back up into our + // box. + RenderObject* anonBlock = removeChildNode(prev); + m_childrenInline = true; + RenderObject* o = anonBlock->firstChild(); + while (o) { + RenderObject* no = o; + o = no->nextSibling(); + appendChildNode(anonBlock->removeChildNode(no)); + no->setNeedsLayoutAndMinMaxRecalc(); + } + + // Nuke the now-empty block. + anonBlock->detach(); + } +} + +bool RenderBlock::isSelfCollapsingBlock() const +{ + // We are not self-collapsing if we + // (a) have a non-zero height according to layout (an optimization to avoid wasting time) + // (b) are a table, + // (c) have border/padding, + // (d) have a min-height + if (m_height > 0 || + isTable() || (borderBottom() + paddingBottom() + borderTop() + paddingTop()) != 0 || + style()->minHeight().value() > 0) + return false; + + bool hasAutoHeight = style()->height().isVariable(); + if (style()->height().isPercent() && !style()->htmlHacks()) { + hasAutoHeight = true; + for (RenderBlock* cb = containingBlock(); !cb->isCanvas(); cb = cb->containingBlock()) { + if (cb->style()->height().isFixed() || cb->isTableCell()) + hasAutoHeight = false; + } + } + + // If the height is 0 or auto, then whether or not we are a self-collapsing block depends + // on whether we have content that is all self-collapsing or not. + if (hasAutoHeight || ((style()->height().isFixed() || style()->height().isPercent()) && style()->height().value() == 0)) { + // If the block has inline children, see if we generated any line boxes. If we have any + // line boxes, then we can't be self-collapsing, since we have content. + if (childrenInline()) + return !firstLineBox(); + + // Whether or not we collapse is dependent on whether all our normal flow children + // are also self-collapsing. + for (RenderObject* child = firstChild(); child; child = child->nextSibling()) { + if (child->isFloatingOrPositioned()) + continue; + if (!child->isSelfCollapsingBlock()) + return false; + } + return true; + } + return false; +} + +void RenderBlock::layout() +{ + // Table cells call layoutBlock directly, so don't add any logic here. Put code into + // layoutBlock(). + layoutBlock(false); +} + +void RenderBlock::layoutBlock(bool relayoutChildren) +{ + if (isInline() && !isReplacedBlock()) { + setNeedsLayout(false); + return; + } + // kdDebug( 6040 ) << renderName() << " " << this << "::layoutBlock() start" << endl; + // TQTime t; + // t.start(); + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + + if (canvas()->pagedMode()) relayoutChildren = true; + + if (!relayoutChildren && posChildNeedsLayout() && !normalChildNeedsLayout() && !selfNeedsLayout()) { + // All we have to is lay out our positioned objects. + layoutPositionedObjects(relayoutChildren); + if (hasOverflowClip()) + m_layer->checkScrollbarsAfterLayout(); + setNeedsLayout(false); + return; + } + + if (markedForRepaint()) { + repaintDuringLayout(); + setMarkedForRepaint(false); + } + + int oldWidth = m_width; + + calcWidth(); + m_overflowWidth = m_width; + m_overflowLeft = 0; + if (style()->direction() == LTR ) + { + int cw=0; + if (style()->textIndent().isPercent()) + cw = containingBlock()->contentWidth(); + m_overflowLeft = kMin(0, style()->textIndent().minWidth(cw)); + } + + if ( oldWidth != m_width ) + relayoutChildren = true; + + // kdDebug( 6040 ) << floatingObjects << "," << oldWidth << "," + // << m_width << ","<< needsLayout() << "," << isAnonymousBox() << "," + // << overhangingContents() << "," << isPositioned() << endl; + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(RenderBlock) " << this << " ::layout() width=" << m_width << ", needsLayout=" << needsLayout() << endl; + if(containingBlock() == static_cast<RenderObject *>(this)) + kdDebug( 6040 ) << renderName() << ": containingBlock == this" << endl; +#endif + + clearFloats(); + + int previousHeight = m_height; + m_height = 0; + m_overflowHeight = 0; + m_clearStatus = CNONE; + + // We use four values, maxTopPos, maxPosNeg, maxBottomPos, and maxBottomNeg, to track + // our current maximal positive and negative margins. These values are used when we + // are collapsed with adjacent blocks, so for example, if you have block A and B + // collapsing together, then you'd take the maximal positive margin from both A and B + // and subtract it from the maximal negative margin from both A and B to get the + // true collapsed margin. This algorithm is recursive, so when we finish layout() + // our block knows its current maximal positive/negative values. + // + // Start out by setting our margin values to our current margins. Table cells have + // no margins, so we don't fill in the values for table cells. + if (!isTableCell()) { + initMaxMarginValues(); + + m_topMarginQuirk = style()->marginTop().isQuirk(); + m_bottomMarginQuirk = style()->marginBottom().isQuirk(); + + if (element() && element()->id() == ID_FORM && static_cast<HTMLFormElementImpl*>(element())->isMalformed()) + // See if this form is malformed (i.e., unclosed). If so, don't give the form + // a bottom margin. + m_maxBottomPosMargin = m_maxBottomNegMargin = 0; + } + + if (scrollsOverflow() && m_layer) { + // For overflow:scroll blocks, ensure we have both scrollbars in place always. + if (style()->overflowX() == OSCROLL) + m_layer->showScrollbar( Qt::Horizontal, true ); + if (style()->overflowY() == OSCROLL) + m_layer->showScrollbar( Qt::Vertical, true ); + } + + setContainsPageBreak(false); + + if (childrenInline()) + layoutInlineChildren( relayoutChildren ); + else + layoutBlockChildren( relayoutChildren ); + + // Expand our intrinsic height to encompass floats. + int toAdd = borderBottom() + paddingBottom(); + if (m_layer && scrollsOverflowX() && style()->height().isVariable()) + toAdd += m_layer->horizontalScrollbarHeight(); + if ( hasOverhangingFloats() && (isFloatingOrPositioned() || flowAroundFloats()) ) + m_overflowHeight = m_height = floatBottom() + toAdd; + + int oldHeight = m_height; + calcHeight(); + if (oldHeight != m_height) { + m_overflowHeight -= toAdd; + if (m_layer && scrollsOverflowY()) { + // overflow-height only includes padding-bottom when it scrolls + m_overflowHeight += paddingBottom(); + } + // If the block got expanded in size, then increase our overflowheight to match. + if (m_overflowHeight < m_height) + m_overflowHeight = m_height; + } + if (previousHeight != m_height) + relayoutChildren = true; + + if (isTableCell()) { + // Table cells need to grow to accommodate both overhanging floats and + // blocks that have overflowed content. + // Check for an overhanging float first. + // FIXME: This needs to look at the last flow, not the last child. + if (lastChild() && lastChild()->hasOverhangingFloats() && !lastChild()->hasOverflowClip()) { + KHTMLAssert(lastChild()->isRenderBlock()); + m_height = lastChild()->yPos() + static_cast<RenderBlock*>(lastChild())->floatBottom(); + m_height += borderBottom() + paddingBottom(); + } + + if (m_overflowHeight > m_height && !hasOverflowClip()) + m_height = m_overflowHeight + borderBottom() + paddingBottom(); + } + + if( hasOverhangingFloats() && ((isFloating() && style()->height().isVariable()) || isTableCell())) { + m_height = floatBottom(); + m_height += borderBottom() + paddingBottom(); + } + + if (canvas()->pagedMode()) { +#ifdef PAGE_DEBUG + kdDebug(6040) << renderName() << " Page Bottom: " << pageTopAfter(0) << endl; + kdDebug(6040) << renderName() << " Bottom: " << m_height << endl; +#endif + bool needsPageBreak = false; + int xpage = crossesPageBreak(0, m_height); + if (xpage) { + needsPageBreak = true; +#ifdef PAGE_DEBUG + kdDebug( 6040 ) << renderName() << " crosses to page " << xpage << endl; +#endif + } + if (needsPageBreak && !containsPageBreak()) { + setNeedsPageClear(true); +#ifdef PAGE_DEBUG + kdDebug( 6040 ) << renderName() << " marked for page-clear" << endl; +#endif + } + } + + layoutPositionedObjects( relayoutChildren ); + + // Always ensure our overflow width/height are at least as large as our width/height. + m_overflowWidth = kMax(m_overflowWidth, (int)m_width); + m_overflowHeight = kMax(m_overflowHeight, m_height); + + // Update our scrollbars if we're overflow:auto/scroll now that we know if + // we overflow or not. + if (hasOverflowClip() && m_layer) + m_layer->checkScrollbarsAfterLayout(); + + setNeedsLayout(false); +} + +void RenderBlock::adjustPositionedBlock(RenderObject* child, const MarginInfo& marginInfo) +{ + if (child->isBox() && child->hasStaticX()) { + if (style()->direction() == LTR) + static_cast<RenderBox*>(child)->setStaticX(borderLeft() + paddingLeft()); + else + static_cast<RenderBox*>(child)->setStaticX(borderRight() + paddingRight()); + } + + if (child->isBox() && child->hasStaticY()) { + int y = m_height; + if (!marginInfo.canCollapseWithTop()) { + child->calcVerticalMargins(); + int marginTop = child->marginTop(); + int collapsedTopPos = marginInfo.posMargin(); + int collapsedTopNeg = marginInfo.negMargin(); + if (marginTop > 0) { + if (marginTop > collapsedTopPos) + collapsedTopPos = marginTop; + } else { + if (-marginTop > collapsedTopNeg) + collapsedTopNeg = -marginTop; + } + y += (collapsedTopPos - collapsedTopNeg) - marginTop; + } + static_cast<RenderBox*>(child)->setStaticY(y); + } +} + +void RenderBlock::adjustFloatingBlock(const MarginInfo& marginInfo) +{ + // The float should be positioned taking into account the bottom margin + // of the previous flow. We add that margin into the height, get the + // float positioned properly, and then subtract the margin out of the + // height again. In the case of self-collapsing blocks, we always just + // use the top margins, since the self-collapsing block collapsed its + // own bottom margin into its top margin. + // + // Note also that the previous flow may collapse its margin into the top of + // our block. If this is the case, then we do not add the margin in to our + // height when computing the position of the float. This condition can be tested + // for by simply calling canCollapseWithTop. See + // http://www.hixie.ch/tests/adhoc/css/box/block/margin-collapse/046.html for + // an example of this scenario. + int marginOffset = marginInfo.canCollapseWithTop() ? 0 : marginInfo.margin(); + m_height += marginOffset; + positionNewFloats(); + m_height -= marginOffset; +} + +RenderObject* RenderBlock::handleSpecialChild(RenderObject* child, const MarginInfo& marginInfo, CompactInfo& compactInfo, bool& handled) +{ + // Handle positioned children first. + RenderObject* next = handlePositionedChild(child, marginInfo, handled); + if (handled) return next; + + // Handle floating children next. + next = handleFloatingChild(child, marginInfo, handled); + if (handled) return next; + + // See if we have a compact element. If we do, then try to tuck the compact element into the margin space of the next block. + next = handleCompactChild(child, compactInfo, marginInfo, handled); + if (handled) return next; + + // Finally, see if we have a run-in element. + return handleRunInChild(child, handled); +} + +RenderObject* RenderBlock::handlePositionedChild(RenderObject* child, const MarginInfo& marginInfo, bool& handled) +{ + if (child->isPositioned()) { + handled = true; + child->containingBlock()->insertPositionedObject(child); + adjustPositionedBlock(child, marginInfo); + return child->nextSibling(); + } + return 0; +} + +RenderObject* RenderBlock::handleFloatingChild(RenderObject* child, const MarginInfo& marginInfo, bool& handled) +{ + if (child->isFloating()) { + handled = true; + insertFloatingObject(child); + adjustFloatingBlock(marginInfo); + return child->nextSibling(); + } + return 0; +} + +static inline bool isAnonymousWhitespace( RenderObject* o ) { + if (!o->isAnonymous()) + return false; + RenderObject *fc = o->firstChild(); + return fc && fc == o->lastChild() && fc->isText() && static_cast<RenderText *>(fc)->stringLength() == 1 && + static_cast<RenderText *>(fc)->text()[0].unicode() == ' '; +} + +RenderObject* RenderBlock::handleCompactChild(RenderObject* child, CompactInfo& compactInfo, const MarginInfo& marginInfo, bool& handled) +{ + // FIXME: We only deal with one compact at a time. It is unclear what should be + // done if multiple contiguous compacts are encountered. For now we assume that + // compact A followed by another compact B should simply be treated as block A. + if (child->isCompact() && !compactInfo.compact() && (child->childrenInline() || child->isReplaced())) { + // Get the next non-positioned/non-floating RenderBlock. + RenderObject* next = child->nextSibling(); + RenderObject* curr = next; + while (curr && (curr->isFloatingOrPositioned() || isAnonymousWhitespace(curr)) ) + curr = curr->nextSibling(); + if (curr && curr->isRenderBlock() && !curr->isCompact() && !curr->isRunIn()) { + curr->calcWidth(); // So that horizontal margins are correct. + // Need to compute margins for the child as though it is a block. + child->style()->setDisplay(BLOCK); + child->calcWidth(); + child->style()->setDisplay(COMPACT); + + int childMargins = child->marginLeft() + child->marginRight(); + int margin = style()->direction() == LTR ? curr->marginLeft() : curr->marginRight(); + if (margin >= (childMargins + child->maxWidth())) { + // The compact will fit in the margin. + handled = true; + compactInfo.set(child, curr); + child->layoutIfNeeded(); + int off = marginInfo.margin(); + m_height += off + curr->marginTop() < child->marginTop() ? + child->marginTop() - curr->marginTop() -off: 0; + + child->setPos(0,0); // This position will be updated to reflect the compact's + // desired position and the line box for the compact will + // pick that position up. + return next; + } + } + } + return 0; +} + +void RenderBlock::adjustSizeForCompactIfNeeded(RenderObject* child, CompactInfo& compactInfo) +{ + // if the compact is bigger than the block it was run into + // then "this" block should take the height of the compact + if (compactInfo.matches(child)) { + // We have a compact child to squeeze in. + RenderObject* compactChild = compactInfo.compact(); + if (compactChild->height() > child->height()) + m_height += compactChild->height() - child->height(); + } +} + +void RenderBlock::insertCompactIfNeeded(RenderObject* child, CompactInfo& compactInfo) +{ + if (compactInfo.matches(child)) { + // We have a compact child to squeeze in. + RenderObject* compactChild = compactInfo.compact(); + int compactXPos = borderLeft() + paddingLeft() + compactChild->marginLeft(); + if (style()->direction() == RTL) { + compactChild->calcWidth(); // have to do this because of the capped maxwidth + compactXPos = width() - borderRight() - paddingRight() - + compactChild->width() - compactChild->marginRight(); + } + + int compactYPos = child->yPos() + child->borderTop() + child->paddingTop() + - compactChild->paddingTop() - compactChild->borderTop(); + int adj = 0; + KHTMLAssert(child->isRenderBlock()); + InlineRunBox *b = static_cast<RenderBlock*>(child)->firstLineBox(); + InlineRunBox *c = static_cast<RenderBlock*>(compactChild)->firstLineBox(); + if (b && c) { + // adjust our vertical position + int vpos = compactChild->getVerticalPosition( true, child ); + if (vpos == PositionBottom) + adj = b->height() > c->height() ? (b->height() + b->yPos() - c->height() - c->yPos()) : 0; + else if (vpos == PositionTop) + adj = b->yPos() - c->yPos(); + else + adj = vpos; + compactYPos += adj; + } + Length newLineHeight( kMax(compactChild->lineHeight(true)+adj, (int)child->lineHeight(true)), tdehtml::Fixed); + child->style()->setLineHeight( newLineHeight ); + child->setNeedsLayout( true, false ); + child->layout(); + + compactChild->setPos(compactXPos, compactYPos); // Set the x position. + compactInfo.clear(); + } +} + +RenderObject* RenderBlock::handleRunInChild(RenderObject* child, bool& handled) +{ + // See if we have a run-in element with inline children. If the + // children aren't inline, then just treat the run-in as a normal + // block. + if (child->isRunIn() && (child->childrenInline() || child->isReplaced())) { + // Get the next non-positioned/non-floating RenderBlock. + RenderObject* curr = child->nextSibling(); + while (curr && (curr->isFloatingOrPositioned() || isAnonymousWhitespace(curr)) ) + curr = curr->nextSibling(); + if (curr && (curr->isRenderBlock() && curr->childrenInline() && !curr->isCompact() && !curr->isRunIn())) { + // The block acts like an inline, so just null out its + // position. + handled = true; + child->setInline(true); + child->setPos(0,0); + + // Remove the child. + RenderObject* next = child->nextSibling(); + removeChildNode(child); + + // Now insert the child under |curr|. + curr->insertChildNode(child, curr->firstChild()); + return next; + } + } + return 0; +} + +void RenderBlock::collapseMargins(RenderObject* child, MarginInfo& marginInfo, int yPosEstimate) +{ + // Get our max pos and neg top margins. + int posTop = child->maxTopMargin(true); + int negTop = child->maxTopMargin(false); + + // For self-collapsing blocks, collapse our bottom margins into our + // top to get new posTop and negTop values. + if (child->isSelfCollapsingBlock()) { + posTop = kMax(posTop, (int)child->maxBottomMargin(true)); + negTop = kMax(negTop, (int)child->maxBottomMargin(false)); + } + + // See if the top margin is quirky. We only care if this child has + // margins that will collapse with us. + bool topQuirk = child->isTopMarginQuirk() /*|| style()->marginTopCollapse() == MDISCARD*/; + + if (marginInfo.canCollapseWithTop()) { + // This child is collapsing with the top of the + // block. If it has larger margin values, then we need to update + // our own maximal values. + if (!style()->htmlHacks() || !marginInfo.quirkContainer() || !topQuirk) { + m_maxTopPosMargin = kMax(posTop, (int)m_maxTopPosMargin); + m_maxTopNegMargin = kMax(negTop, (int)m_maxTopNegMargin); + } + + // The minute any of the margins involved isn't a quirk, don't + // collapse it away, even if the margin is smaller (www.webreference.com + // has an example of this, a <dt> with 0.8em author-specified inside + // a <dl> inside a <td>. + if (!marginInfo.determinedTopQuirk() && !topQuirk && (posTop-negTop)) { + m_topMarginQuirk = false; + marginInfo.setDeterminedTopQuirk(true); + } + + if (!marginInfo.determinedTopQuirk() && topQuirk && marginTop() == 0) + // We have no top margin and our top child has a quirky margin. + // We will pick up this quirky margin and pass it through. + // This deals with the <td><div><p> case. + // Don't do this for a block that split two inlines though. You do + // still apply margins in this case. + m_topMarginQuirk = true; + } + + if (marginInfo.quirkContainer() && marginInfo.atTopOfBlock() && (posTop - negTop)) + marginInfo.setTopQuirk(topQuirk); + + int ypos = m_height; + if (child->isSelfCollapsingBlock()) { + // This child has no height. We need to compute our + // position before we collapse the child's margins together, + // so that we can get an accurate position for the zero-height block. + int collapsedTopPos = kMax(marginInfo.posMargin(), (int)child->maxTopMargin(true)); + int collapsedTopNeg = kMax(marginInfo.negMargin(), (int)child->maxTopMargin(false)); + marginInfo.setMargin(collapsedTopPos, collapsedTopNeg); + + // Now collapse the child's margins together, which means examining our + // bottom margin values as well. + marginInfo.setPosMarginIfLarger(child->maxBottomMargin(true)); + marginInfo.setNegMarginIfLarger(child->maxBottomMargin(false)); + + if (!marginInfo.canCollapseWithTop()) + // We need to make sure that the position of the self-collapsing block + // is correct, since it could have overflowing content + // that needs to be positioned correctly (e.g., a block that + // had a specified height of 0 but that actually had subcontent). + ypos = m_height + collapsedTopPos - collapsedTopNeg; + } + else { +#ifdef APPLE_CHANGES + if (child->style()->marginTopCollapse() == MSEPARATE) { + m_height += marginInfo.margin() + child->marginTop(); + ypos = m_height; + } + else +#endif + if (!marginInfo.atTopOfBlock() || + (!marginInfo.canCollapseTopWithChildren() + && (!style()->htmlHacks() || !marginInfo.quirkContainer() || !marginInfo.topQuirk()))) { + // We're collapsing with a previous sibling's margins and not + // with the top of the block. + m_height += kMax(marginInfo.posMargin(), posTop) - kMax(marginInfo.negMargin(), negTop); + ypos = m_height; + } + + marginInfo.setPosMargin(child->maxBottomMargin(true)); + marginInfo.setNegMargin(child->maxBottomMargin(false)); + + if (marginInfo.margin()) + marginInfo.setBottomQuirk(child->isBottomMarginQuirk() /*|| style()->marginBottomCollapse() == MDISCARD*/); + + marginInfo.setSelfCollapsingBlockClearedFloat(false); + } + + child->setPos(child->xPos(), ypos); + if (ypos != yPosEstimate) { + if (child->style()->width().isPercent() && child->usesLineWidth()) + // The child's width is a percentage of the line width. + // When the child shifts to clear an item, its width can + // change (because it has more available line width). + // So go ahead and mark the item as dirty. + child->setChildNeedsLayout(true); + + if (!child->flowAroundFloats() && child->hasFloats()) + child->markAllDescendantsWithFloatsForLayout(); + + // Our guess was wrong. Make the child lay itself out again. + child->layoutIfNeeded(); + } +} + +void RenderBlock::clearFloatsIfNeeded(RenderObject* child, MarginInfo& marginInfo, int oldTopPosMargin, int oldTopNegMargin) +{ + int heightIncrease = getClearDelta(child); + if (heightIncrease) { + // The child needs to be lowered. Move the child so that it just clears the float. + child->setPos(child->xPos(), child->yPos() + heightIncrease); + + // Increase our height by the amount we had to clear. + bool selfCollapsing = child->isSelfCollapsingBlock(); + if (!selfCollapsing) + m_height += heightIncrease; + else { + // For self-collapsing blocks that clear, they may end up collapsing + // into the bottom of the parent block. We simulate this behavior by + // setting our positive margin value to compensate for the clear. + marginInfo.setPosMargin(kMax(0, child->yPos() - m_height)); + marginInfo.setNegMargin(0); + marginInfo.setSelfCollapsingBlockClearedFloat(true); + } + + if (marginInfo.canCollapseWithTop()) { + // We can no longer collapse with the top of the block since a clear + // occurred. The empty blocks collapse into the cleared block. + // FIXME: This isn't quite correct. Need clarification for what to do + // if the height the cleared block is offset by is smaller than the + // margins involved. + m_maxTopPosMargin = oldTopPosMargin; + m_maxTopNegMargin = oldTopNegMargin; + marginInfo.setAtTopOfBlock(false); + } + + // If our value of clear caused us to be repositioned vertically to be + // underneath a float, we might have to do another layout to take into account + // the extra space we now have available. + if (!selfCollapsing && !child->style()->width().isFixed() && child->usesLineWidth()) + // The child's width is a percentage of the line width. + // When the child shifts to clear an item, its width can + // change (because it has more available line width). + // So go ahead and mark the item as dirty. + child->setChildNeedsLayout(true); + if (!child->flowAroundFloats() && child->hasFloats()) + child->markAllDescendantsWithFloatsForLayout(); + child->layoutIfNeeded(); + } +} + +bool RenderBlock::canClear(RenderObject *child, PageBreakLevel level) +{ + KHTMLAssert(child->parent() && child->parent() == this); + KHTMLAssert(canvas()->pagedMode()); + + // Positioned elements cannot be moved. Only normal flow and floating. + if (child->isPositioned() || child->isRelPositioned()) return false; + + switch(level) { + case PageBreakNormal: + // check page-break-inside: avoid + if (!style()->pageBreakInside()) + // we cannot, but can our parent? + if(!parent()->canClear(this, level)) return false; + case PageBreakHarder: + // check page-break-after/before: avoid + if (m_avoidPageBreak) + // we cannot, but can our parent? + if(!parent()->canClear(this, level)) return false; + case PageBreakForced: + // child is larger than page-height and is forced to break + if(child->height() > canvas()->pageHeight()) return false; + return true; + } + assert(false); + return false; +} + +void RenderBlock::clearPageBreak(RenderObject* child, int pageBottom) +{ + KHTMLAssert(child->parent() && child->parent() == this); + KHTMLAssert(canvas()->pagedMode()); + + if (child->yPos() >= pageBottom) return; + + int heightIncrease = 0; + + heightIncrease = pageBottom - child->yPos(); + + // ### should never happen, canClear should have been called to detect it. + if (child->height() > canvas()->pageHeight()) { + kdDebug(6040) << "### child is too large to clear: " << child->height() << " > " << canvas()->pageHeight() << endl; + return; + } + + // The child needs to be lowered. Move the child so that it just clears the break. + child->setPos(child->xPos(), pageBottom); + +#ifdef PAGE_DEBUG + kdDebug(6040) << "Cleared block " << heightIncrease << "px" << endl; +#endif + + // Increase our height by the amount we had to clear. + m_height += heightIncrease; + + // We might have to do another layout to take into account + // the extra space we now have available. + if (!child->style()->width().isFixed() && child->usesLineWidth()) + // The child's width is a percentage of the line width. + // When the child shifts to clear a page-break, its width can + // change (because it has more available line width). + // So go ahead and mark the item as dirty. + child->setChildNeedsLayout(true); + if (!child->flowAroundFloats() && child->hasFloats()) + child->markAllDescendantsWithFloatsForLayout(); + if (child->containsPageBreak()) + child->setNeedsLayout(true); + child->layoutIfNeeded(); + + child->setAfterPageBreak(true); +} + +int RenderBlock::estimateVerticalPosition(RenderObject* child, const MarginInfo& marginInfo) +{ + // FIXME: We need to eliminate the estimation of vertical position, because + // when it's wrong we sometimes trigger a pathological relayout if there are + // intruding floats. + int yPosEstimate = m_height; + if (!marginInfo.canCollapseWithTop()) { + int childMarginTop = child->selfNeedsLayout() ? child->marginTop() : child->collapsedMarginTop(); + yPosEstimate += kMax(marginInfo.margin(), childMarginTop); + } + return yPosEstimate; +} + +void RenderBlock::determineHorizontalPosition(RenderObject* child) +{ + if (style()->direction() == LTR) { + int xPos = borderLeft() + paddingLeft(); + + // Add in our left margin. + int chPos = xPos + child->marginLeft(); + + // Some objects (e.g., tables, horizontal rules, overflow:auto blocks) avoid floats. They need + // to shift over as necessary to dodge any floats that might get in the way. + if (child->flowAroundFloats()) { + int leftOff = leftOffset(m_height); + if (style()->textAlign() != KHTML_CENTER && !child->style()->marginLeft().isVariable()) { + if (child->marginLeft() < 0) + leftOff += child->marginLeft(); + chPos = kMax(chPos, leftOff); // Let the float sit in the child's margin if it can fit. + } + else if (leftOff != xPos) { + // The object is shifting right. The object might be centered, so we need to + // recalculate our horizontal margins. Note that the containing block content + // width computation will take into account the delta between |leftOff| and |xPos| + // so that we can just pass the content width in directly to the |calcHorizontalMargins| + // function. + static_cast<RenderBox*>(child)->calcHorizontalMargins(child->style()->marginLeft(), child->style()->marginRight(), lineWidth(child->yPos())); + chPos = leftOff + child->marginLeft(); + } + } + + child->setPos(chPos, child->yPos()); + } else { + int xPos = m_width - borderRight() - paddingRight(); + if (m_layer && scrollsOverflowY()) + xPos -= m_layer->verticalScrollbarWidth(); + int chPos = xPos - (child->width() + child->marginRight()); + if (child->flowAroundFloats()) { + int rightOff = rightOffset(m_height); + if (style()->textAlign() != KHTML_CENTER && !child->style()->marginRight().isVariable()) { + if (child->marginRight() < 0) + rightOff -= child->marginRight(); + chPos = kMin(chPos, rightOff - child->width()); // Let the float sit in the child's margin if it can fit. + } else if (rightOff != xPos) { + // The object is shifting left. The object might be centered, so we need to + // recalculate our horizontal margins. Note that the containing block content + // width computation will take into account the delta between |rightOff| and |xPos| + // so that we can just pass the content width in directly to the |calcHorizontalMargins| + // function. + static_cast<RenderBox*>(child)->calcHorizontalMargins(child->style()->marginLeft(), child->style()->marginRight(), lineWidth(child->yPos())); + chPos = rightOff - child->marginRight() - child->width(); + } + } + child->setPos(chPos, child->yPos()); + } +} + +void RenderBlock::setCollapsedBottomMargin(const MarginInfo& marginInfo) +{ + if (marginInfo.canCollapseWithBottom() && !marginInfo.canCollapseWithTop()) { + // Update our max pos/neg bottom margins, since we collapsed our bottom margins + // with our children. + m_maxBottomPosMargin = kMax((int)m_maxBottomPosMargin, marginInfo.posMargin()); + m_maxBottomNegMargin = kMax((int)m_maxBottomNegMargin, marginInfo.negMargin()); + + if (!marginInfo.bottomQuirk()) + m_bottomMarginQuirk = false; + + if (marginInfo.bottomQuirk() && marginBottom() == 0) + // We have no bottom margin and our last child has a quirky margin. + // We will pick up this quirky margin and pass it through. + // This deals with the <td><div><p> case. + m_bottomMarginQuirk = true; + } +} + +void RenderBlock::handleBottomOfBlock(int top, int bottom, MarginInfo& marginInfo) +{ + // If our last flow was a self-collapsing block that cleared a float, then we don't + // collapse it with the bottom of the block. + if (!marginInfo.selfCollapsingBlockClearedFloat()) + marginInfo.setAtBottomOfBlock(true); + + // If we can't collapse with children then go ahead and add in the bottom margin. + if (!marginInfo.canCollapseWithBottom() && !marginInfo.canCollapseWithTop() + && (!style()->htmlHacks() || !marginInfo.quirkContainer() || !marginInfo.bottomQuirk())) + m_height += marginInfo.margin(); + + // Now add in our bottom border/padding. + m_height += bottom; + + // Negative margins can cause our height to shrink below our minimal height (border/padding). + // If this happens, ensure that the computed height is increased to the minimal height. + m_height = kMax(m_height, top + bottom); + + // Always make sure our overflow height is at least our height. + m_overflowHeight = kMax(m_height, m_overflowHeight); + + // Update our bottom collapsed margin info. + setCollapsedBottomMargin(marginInfo); +} + +void RenderBlock::layoutBlockChildren( bool relayoutChildren ) +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << " layoutBlockChildren( " << this <<" ), relayoutChildren="<< relayoutChildren << endl; +#endif + + int top = borderTop() + paddingTop(); + int bottom = borderBottom() + paddingBottom(); + if (m_layer && scrollsOverflowX() && style()->height().isVariable()) + bottom += m_layer->horizontalScrollbarHeight(); + + m_height = m_overflowHeight = top; + + // The margin struct caches all our current margin collapsing state. + // The compact struct caches state when we encounter compacts. + MarginInfo marginInfo(this, top, bottom); + CompactInfo compactInfo; + + // Fieldsets need to find their legend and position it inside the border of the object. + // The legend then gets skipped during normal layout. + RenderObject* legend = layoutLegend(relayoutChildren); + + PageBreakInfo pageBreakInfo(pageTopAfter(0)); + + RenderObject* child = firstChild(); + while( child != 0 ) + { + if (legend == child) { + child = child->nextSibling(); + continue; // Skip the legend, since it has already been positioned up in the fieldset's border. + } + + int oldTopPosMargin = m_maxTopPosMargin; + int oldTopNegMargin = m_maxTopNegMargin; + + // make sure we relayout children if we need it. + if (!child->isPositioned() && (relayoutChildren || + (child->isReplaced() && (child->style()->width().isPercent() || child->style()->height().isPercent())) || + (child->isRenderBlock() && child->style()->height().isPercent()) || + (child->isBody() && child->style()->htmlHacks()))) + { + child->setChildNeedsLayout(true); + } + + // Handle the four types of special elements first. These include positioned content, floating content, compacts and + // run-ins. When we encounter these four types of objects, we don't actually lay them out as normal flow blocks. + bool handled = false; + RenderObject* next = handleSpecialChild(child, marginInfo, compactInfo, handled); + if (handled) { child = next; continue; } + + // The child is a normal flow object. Compute its vertical margins now. + child->calcVerticalMargins(); + +#ifdef APPLE_CHANGES /* margin-*-collapse not merged yet */ + // Do not allow a collapse if the margin top collapse style is set to SEPARATE. + if (child->style()->marginTopCollapse() == MSEPARATE) { + marginInfo.setAtTopOfBlock(false); + marginInfo.clearMargin(); + } +#endif + + // Try to guess our correct y position. In most cases this guess will + // be correct. Only if we're wrong (when we compute the real y position) + // will we have to potentially relayout. + int yPosEstimate = estimateVerticalPosition(child, marginInfo); + + // If an element might be affected by the presence of floats, then always mark it for + // layout. + if ( !child->flowAroundFloats() || child->usesLineWidth() ) { + int fb = floatBottom(); + if (fb > m_height || fb > yPosEstimate) + child->setChildNeedsLayout(true); + } + + // Go ahead and position the child as though it didn't collapse with the top. + child->setPos(child->xPos(), yPosEstimate); + child->layoutIfNeeded(); + + // Now determine the correct ypos based on examination of collapsing margin + // values. + collapseMargins(child, marginInfo, yPosEstimate); + + // Now check for clear. + clearFloatsIfNeeded(child, marginInfo, oldTopPosMargin, oldTopNegMargin); + + // We are no longer at the top of the block if we encounter a non-empty child. + // This has to be done after checking for clear, so that margins can be reset if a clear occurred. + if (marginInfo.atTopOfBlock() && !child->isSelfCollapsingBlock()) + marginInfo.setAtTopOfBlock(false); + + // Now place the child in the correct horizontal position + determineHorizontalPosition(child); + + adjustSizeForCompactIfNeeded(child, compactInfo); + // Update our height now that the child has been placed in the correct position. + m_height += child->height(); + +#ifdef APPLE_CHANGES + if (child->style()->marginBottomCollapse() == MSEPARATE) { + m_height += child->marginBottom(); + marginInfo.clearMargin(); + } +#endif + + // Check for page-breaks + if (canvas()->pagedMode()) + clearChildOfPageBreaks(child, pageBreakInfo, marginInfo); + + if (child->hasOverhangingFloats() && !child->flowAroundFloats()) { + // need to add the child's floats to our floating objects list, but not in the case where + // overflow is auto/scroll + addOverHangingFloats( static_cast<RenderBlock *>(child), -child->xPos(), -child->yPos(), true ); + } + + // See if this child has made our overflow need to grow. + int effX = child->effectiveXPos(); + int effY = child->effectiveYPos(); + m_overflowWidth = kMax(effX + child->effectiveWidth(), m_overflowWidth); + m_overflowLeft = kMin(effX, m_overflowLeft); + m_overflowHeight = kMax(effY + child->effectiveHeight(), m_overflowHeight); + m_overflowTop = kMin(effY, m_overflowTop); + + // Insert our compact into the block margin if we have one. + insertCompactIfNeeded(child, compactInfo); + + child = child->nextSibling(); + } + + // The last child had forced page-break-after + if (pageBreakInfo.forcePageBreak()) + m_height = pageBreakInfo.pageBottom(); + + // Now do the handling of the bottom of the block, adding in our bottom border/padding and + // determining the correct collapsed bottom margin information. + handleBottomOfBlock(top, bottom, marginInfo); + + setNeedsLayout(false); +} + +void RenderBlock::clearChildOfPageBreaks(RenderObject *child, PageBreakInfo &pageBreakInfo, MarginInfo &marginInfo) +{ + (void)marginInfo; + int childTop = child->yPos(); + int childBottom = child->yPos()+child->height(); +#ifdef PAGE_DEBUG + kdDebug(6040) << renderName() << " ChildTop: " << childTop << " ChildBottom: " << childBottom << endl; +#endif + + bool forcePageBreak = pageBreakInfo.forcePageBreak() || child->style()->pageBreakBefore() == PBALWAYS; +#ifdef PAGE_DEBUG + if (forcePageBreak) + kdDebug(6040) << renderName() << "Forced break required" << endl; +#endif + + int xpage = crossesPageBreak(childTop, childBottom); + if (xpage || forcePageBreak) + { + if (!forcePageBreak && child->containsPageBreak() && !child->needsPageClear()) { +#ifdef PAGE_DEBUG + kdDebug(6040) << renderName() << " Child contains page-break to page " << xpage << endl; +#endif + // ### Actually this assumes floating children are breaking/clearing + // nicely as well. + setContainsPageBreak(true); + } + else { + bool doBreak = true; + // don't break before the first child or when page-break-inside is avoid + if (!forcePageBreak && (!style()->pageBreakInside() || m_avoidPageBreak || child == firstChild())) { + if (parent()->canClear(this, (m_avoidPageBreak) ? PageBreakHarder : PageBreakNormal )) { +#ifdef PAGE_DEBUG + kdDebug(6040) << renderName() << "Avoid page-break inside" << endl; +#endif + child->setNeedsPageClear(false); + setNeedsPageClear(true); + doBreak = false; + } +#ifdef PAGE_DEBUG + else + kdDebug(6040) << renderName() << "Ignoring page-break avoid" << endl; +#endif + } + if (doBreak) { +#ifdef PAGE_DEBUG + kdDebug(6040) << renderName() << " Clearing child of page-break" << endl; + kdDebug(6040) << renderName() << " child top of page " << xpage << endl; +#endif + clearPageBreak(child, pageBreakInfo.pageBottom()); + child->setNeedsPageClear(false); + setContainsPageBreak(true); + } + } + pageBreakInfo.setPageBottom(pageBreakInfo.pageBottom() + canvas()->pageHeight()); + } + else + if (child->yPos() >= pageBreakInfo.pageBottom()) { + bool doBreak = true; +#ifdef PAGE_DEBUG + kdDebug(6040) << "Page-break between children" << endl; +#endif + if (!style()->pageBreakInside() || m_avoidPageBreak) { + if(parent()->canClear(this, (m_avoidPageBreak) ? PageBreakHarder : PageBreakNormal )) { +#ifdef PAGE_DEBUG + kdDebug(6040) << "Avoid page-break inside" << endl; +#endif + child->setNeedsPageClear(false); + setNeedsPageClear(true); + doBreak = false; + } +#ifdef PAGE_DEBUG + else + kdDebug(6040) << "Ignoring page-break avoid" << endl; +#endif + } + if (doBreak) { + // Break between children + setContainsPageBreak(true); + // ### Should collapse top-margin with page-margin + } + pageBreakInfo.setPageBottom(pageBreakInfo.pageBottom() + canvas()->pageHeight()); + } + + // Do we need a forced page-break before next child? + pageBreakInfo.setForcePageBreak(false); + if (child->style()->pageBreakAfter() == PBALWAYS) + pageBreakInfo.setForcePageBreak(true); +} + +void RenderBlock::layoutPositionedObjects(bool relayoutChildren) +{ + if (m_positionedObjects) { + //kdDebug( 6040 ) << renderName() << " " << this << "::layoutPositionedObjects() start" << endl; + RenderObject* r; + TQPtrListIterator<RenderObject> it(*m_positionedObjects); + for ( ; (r = it.current()); ++it ) { + //kdDebug(6040) << " have a positioned object" << endl; + if (r->markedForRepaint()) { + r->repaintDuringLayout(); + r->setMarkedForRepaint(false); + } + if ( relayoutChildren || r->style()->position() == FIXED || + ((r->hasStaticY()||r->hasStaticX()) && r->parent() != this && r->parent()->isBlockFlow()) ) { + r->setChildNeedsLayout(true); + r->dirtyFormattingContext(false); + } + r->layoutIfNeeded(); + } + } +} + +void RenderBlock::paint(PaintInfo& pI, int _tx, int _ty) +{ + _tx += m_x; + _ty += m_y; + + // check if we need to do anything at all... + if (!isRoot() && !isInlineFlow() && !overhangingContents() && !isRelPositioned() && !isPositioned() ) + { + int h = m_overflowHeight; + int yPos = _ty; + if (m_floatingObjects && floatBottom() > h) + h = floatBottom(); + + yPos += overflowTop(); + + int os = maximalOutlineSize(pI.phase); + if( (yPos > pI.r.bottom() + os) || (_ty + h <= pI.r.y() - os)) + return; + } + + paintObject(pI, _tx, _ty); +} + +void RenderBlock::paintObject(PaintInfo& pI, int _tx, int _ty, bool shouldPaintOutline) +{ +#ifdef DEBUG_LAYOUT + //kdDebug( 6040 ) << renderName() << "(RenderBlock) " << this << " ::paintObject() w/h = (" << width() << "/" << height() << ")" << endl; +#endif + + // If we're a repositioned run-in, don't paint background/borders. + bool inlineFlow = isInlineFlow(); + + // 1. paint background, borders etc + if (!inlineFlow && + (pI.phase == PaintActionElementBackground || pI.phase == PaintActionChildBackground ) && + shouldPaintBackgroundOrBorder() && style()->visibility() == VISIBLE) + paintBoxDecorations(pI, _tx, _ty); + + if ( pI.phase == PaintActionElementBackground ) + return; + if ( pI.phase == PaintActionChildBackgrounds ) + pI.phase = PaintActionChildBackground; + + // 2. paint contents + int scrolledX = _tx; + int scrolledY = _ty; + if (hasOverflowClip() && m_layer) + m_layer->subtractScrollOffset(scrolledX, scrolledY); + + if (childrenInline()) + paintLines(pI, scrolledX, scrolledY); + else { + for(RenderObject *child = firstChild(); child; child = child->nextSibling()) + if(!child->layer() && !child->isFloating()) + child->paint(pI, scrolledX, scrolledY); + } + + // 3. paint floats. + if (!inlineFlow && (pI.phase == PaintActionFloat || pI.phase == PaintActionSelection)) + paintFloats(pI, scrolledX, scrolledY, pI.phase == PaintActionSelection); + + // 4. paint outline. + if (shouldPaintOutline && !inlineFlow && pI.phase == PaintActionOutline && + style()->outlineWidth() && style()->visibility() == VISIBLE) + paintOutline(pI.p, _tx, _ty, width(), height(), style()); + +#ifdef BOX_DEBUG + if ( style() && style()->visibility() == VISIBLE ) { + if(isAnonymous()) + outlineBox(pI.p, _tx, _ty, "green"); + if(isFloating()) + outlineBox(pI.p, _tx, _ty, "yellow"); + else + outlineBox(pI.p, _tx, _ty); + } +#endif +} + +void RenderBlock::paintFloats(PaintInfo& pI, int _tx, int _ty, bool paintSelection) +{ + if (!m_floatingObjects) + return; + + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it) { + // Only paint the object if our noPaint flag isn't set. + if (r->node->isFloating() && !r->noPaint && !r->node->layer()) { + PaintAction oldphase = pI.phase; + if (paintSelection) { + pI.phase = PaintActionSelection; + r->node->paint(pI, _tx + r->left - r->node->xPos() + r->node->marginLeft(), + _ty + r->startY - r->node->yPos() + r->node->marginTop()); + } + else { + pI.phase = PaintActionElementBackground; + r->node->paint(pI, + _tx + r->left - r->node->xPos() + r->node->marginLeft(), + _ty + r->startY - r->node->yPos() + r->node->marginTop()); + pI.phase = PaintActionChildBackgrounds; + r->node->paint(pI, + _tx + r->left - r->node->xPos() + r->node->marginLeft(), + _ty + r->startY - r->node->yPos() + r->node->marginTop()); + pI.phase = PaintActionFloat; + r->node->paint(pI, + _tx + r->left - r->node->xPos() + r->node->marginLeft(), + _ty + r->startY - r->node->yPos() + r->node->marginTop()); + pI.phase = PaintActionForeground; + r->node->paint(pI, + _tx + r->left - r->node->xPos() + r->node->marginLeft(), + _ty + r->startY - r->node->yPos() + r->node->marginTop()); + pI.phase = PaintActionOutline; + r->node->paint(pI, + _tx + r->left - r->node->xPos() + r->node->marginLeft(), + _ty + r->startY - r->node->yPos() + r->node->marginTop()); + } + pI.phase = oldphase; + } + } +} + +void RenderBlock::insertPositionedObject(RenderObject *o) +{ + // Create the list of special objects if we don't aleady have one + if (!m_positionedObjects) { + m_positionedObjects = new TQPtrList<RenderObject>; + m_positionedObjects->setAutoDelete(false); + } + else { + // Don't insert the object again if it's already in the list + TQPtrListIterator<RenderObject> it(*m_positionedObjects); + RenderObject* f; + while ( (f = it.current()) ) { + if (f == o) return; + ++it; + } + } + + // Create the special object entry & append it to the list + setOverhangingContents(); + m_positionedObjects->append(o); +} + +void RenderBlock::removePositionedObject(RenderObject *o) +{ + if (m_positionedObjects) { + TQPtrListIterator<RenderObject> it(*m_positionedObjects); + while (it.current()) { + if (it.current() == o) + m_positionedObjects->removeRef(it.current()); + ++it; + } + if (m_positionedObjects->isEmpty()) { + delete m_positionedObjects; + m_positionedObjects = 0; + } + } +} + +void RenderBlock::insertFloatingObject(RenderObject *o) +{ + // Create the list of special objects if we don't aleady have one + if (!m_floatingObjects) { + m_floatingObjects = new TQPtrList<FloatingObject>; + m_floatingObjects->setAutoDelete(true); + } + else { + // Don't insert the object again if it's already in the list + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + FloatingObject* f; + while ( (f = it.current()) ) { + if (f->node == o) return; + ++it; + } + } + + // Create the special object entry & append it to the list + + FloatingObject *newObj; + if (o->isFloating()) { + // floating object + o->layoutIfNeeded(); + + if(o->style()->floating() & FLEFT) + newObj = new FloatingObject(FloatingObject::FloatLeft); + else + newObj = new FloatingObject(FloatingObject::FloatRight); + + newObj->startY = -500000; + newObj->endY = -500000; + newObj->width = o->width() + o->marginLeft() + o->marginRight(); + } + else { + // We should never get here, as insertFloatingObject() should only ever be called with floating + // objects. + KHTMLAssert(false); + newObj = 0; // keep gcc's uninitialized variable warnings happy + } + + newObj->node = o; + + m_floatingObjects->append(newObj); +} + +void RenderBlock::removeFloatingObject(RenderObject *o) +{ + if (m_floatingObjects) { + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + while (it.current()) { + if (it.current()->node == o) + m_floatingObjects->removeRef(it.current()); + ++it; + } + } +} + +void RenderBlock::positionNewFloats() +{ + if(!m_floatingObjects) return; + FloatingObject *f = m_floatingObjects->getLast(); + if(!f || f->startY != -500000) return; + FloatingObject *lastFloat; + while(1) + { + lastFloat = m_floatingObjects->prev(); + if (!lastFloat || lastFloat->startY != -500000) { + m_floatingObjects->next(); + break; + } + f = lastFloat; + } + + int y = m_height; + + + // the float can not start above the y position of the last positioned float. + if(lastFloat && lastFloat->startY > y) + y = lastFloat->startY; + + while(f) + { + //skip elements copied from elsewhere and positioned elements + if (f->node->containingBlock()!=this) + { + f = m_floatingObjects->next(); + continue; + } + + RenderObject *o = f->node; + int _height = o->height() + o->marginTop() + o->marginBottom(); + + // floats avoid page-breaks + if(canvas()->pagedMode()) + { + int top = y; + int bottom = y + o->height(); + if (crossesPageBreak(top, bottom) && o->height() < canvas()->pageHeight() ) { + int newY = pageTopAfter(top); +#ifdef PAGE_DEBUG + kdDebug(6040) << renderName() << " clearing float " << newY - y << "px" << endl; +#endif + y = newY; + } + } + + int ro = rightOffset(); // Constant part of right offset. + int lo = leftOffset(); // Constant part of left offset. + int fwidth = f->width; // The width we look for. + //kdDebug( 6040 ) << " Object width: " << fwidth << " available width: " << ro - lo << endl; + + // in quirk mode, floated auto-width tables try to fit within remaining linewidth + bool ftQuirk = o->isTable() && style()->htmlHacks() && o->style()->width().isVariable(); + if (ftQuirk) + fwidth = kMin( o->minWidth()+o->marginLeft()+o->marginRight(), fwidth ); + + if (ro - lo < fwidth) + fwidth = ro - lo; // Never look for more than what will be available. + + if ( o->style()->clear() & CLEFT ) + y = kMax( leftBottom(), y ); + if ( o->style()->clear() & CRIGHT ) + y = kMax( rightBottom(), y ); + + bool canClearLine; + if (o->style()->floating() & FLEFT) + { + int heightRemainingLeft = 1; + int heightRemainingRight = 1; + int fx = leftRelOffset(y,lo, false, &heightRemainingLeft, &canClearLine); + if (canClearLine) + { + while (rightRelOffset(y,ro, false, &heightRemainingRight)-fx < fwidth) + { + y += kMin( heightRemainingLeft, heightRemainingRight ); + fx = leftRelOffset(y,lo, false, &heightRemainingLeft); + } + } + if (ftQuirk && (rightRelOffset(y,ro, false)-fx < f->width)) { + o->setPos( o->xPos(), y + o->marginTop() ); + o->setChildNeedsLayout(true, false); + o->layoutIfNeeded(); + _height = o->height() + o->marginTop() + o->marginBottom(); + f->width = o->width() + o->marginLeft() + o->marginRight(); + } + f->left = fx; + //kdDebug( 6040 ) << "positioning left aligned float at (" << fx + o->marginLeft() << "/" << y + o->marginTop() << ") fx=" << fx << endl; + o->setPos(fx + o->marginLeft(), y + o->marginTop()); + } + else + { + int heightRemainingLeft = 1; + int heightRemainingRight = 1; + int fx = rightRelOffset(y,ro, false, &heightRemainingRight, &canClearLine); + if (canClearLine) + { + while (fx - leftRelOffset(y,lo, false, &heightRemainingLeft) < fwidth) + { + y += kMin(heightRemainingLeft, heightRemainingRight); + fx = rightRelOffset(y,ro, false, &heightRemainingRight); + } + } + if (ftQuirk && (fx - leftRelOffset(y,lo, false) < f->width)) { + o->setPos( o->xPos(), y + o->marginTop() ); + o->setChildNeedsLayout(true, false); + o->layoutIfNeeded(); + _height = o->height() + o->marginTop() + o->marginBottom(); + f->width = o->width() + o->marginLeft() + o->marginRight(); + } + f->left = fx - f->width; + //kdDebug( 6040 ) << "positioning right aligned float at (" << fx - o->marginRight() - o->width() << "/" << y + o->marginTop() << ")" << endl; + o->setPos(fx - o->marginRight() - o->width(), y + o->marginTop()); + } + + if ( m_layer && hasOverflowClip()) { + if (o->xPos()+o->width() > m_overflowWidth) + m_overflowWidth = o->xPos()+o->width(); + else + if (o->xPos() < m_overflowLeft) + m_overflowLeft = o->xPos(); + } + + f->startY = y; + f->endY = f->startY + _height; + + + //kdDebug( 6040 ) << "floatingObject x/y= (" << f->left << "/" << f->startY << "-" << f->width << "/" << f->endY - f->startY << ")" << endl; + + f = m_floatingObjects->next(); + } +} + +void RenderBlock::newLine() +{ + positionNewFloats(); + // set y position + int newY = 0; + switch(m_clearStatus) + { + case CLEFT: + newY = leftBottom(); + break; + case CRIGHT: + newY = rightBottom(); + break; + case CBOTH: + newY = floatBottom(); + default: + break; + } + if(m_height < newY) + { + // kdDebug( 6040 ) << "adjusting y position" << endl; + m_height = newY; + } + m_clearStatus = CNONE; +} + +int +RenderBlock::leftOffset() const +{ + return borderLeft()+paddingLeft(); +} + +int +RenderBlock::leftRelOffset(int y, int fixedOffset, bool applyTextIndent, int *heightRemaining, bool *canClearLine ) const +{ + int left = fixedOffset; + if (canClearLine) *canClearLine = true; + + if (m_floatingObjects) { + if ( heightRemaining ) *heightRemaining = 1; + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) + { + //kdDebug( 6040 ) <<(void *)this << " left: sy, ey, x, w " << r->startY << "," << r->endY << "," << r->left << "," << r->width << " " << endl; + if (r->startY <= y && r->endY > y && + r->type == FloatingObject::FloatLeft && + r->left + r->width > left) { + left = r->left + r->width; + if ( heightRemaining ) *heightRemaining = r->endY - y; + if ( canClearLine ) *canClearLine = (r->node->style()->floating() != FLEFT_ALIGN); + } + } + } + + if (applyTextIndent && m_firstLine && style()->direction() == LTR ) { + int cw=0; + if (style()->textIndent().isPercent()) + cw = containingBlock()->contentWidth(); + left += style()->textIndent().minWidth(cw); + } + + //kdDebug( 6040 ) << "leftOffset(" << y << ") = " << left << endl; + return left; +} + +int +RenderBlock::rightOffset() const +{ + int right = m_width - borderRight() - paddingRight(); + if (m_layer && scrollsOverflowY()) + right -= m_layer->verticalScrollbarWidth(); + return right; +} + +int +RenderBlock::rightRelOffset(int y, int fixedOffset, bool applyTextIndent, int *heightRemaining, bool *canClearLine ) const +{ + int right = fixedOffset; + if (canClearLine) *canClearLine = true; + + if (m_floatingObjects) { + if (heightRemaining) *heightRemaining = 1; + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) + { + //kdDebug( 6040 ) << "right: sy, ey, x, w " << r->startY << "," << r->endY << "," << r->left << "," << r->width << " " << endl; + if (r->startY <= y && r->endY > y && + r->type == FloatingObject::FloatRight && + r->left < right) { + right = r->left; + if ( heightRemaining ) *heightRemaining = r->endY - y; + if ( canClearLine ) *canClearLine = (r->node->style()->floating() != FRIGHT_ALIGN); + } + } + } + + if (applyTextIndent && m_firstLine && style()->direction() == RTL ) { + int cw=0; + if (style()->textIndent().isPercent()) + cw = containingBlock()->contentWidth(); + right -= style()->textIndent().minWidth(cw); + } + + //kdDebug( 6040 ) << "rightOffset(" << y << ") = " << right << endl; + return right; +} + +unsigned short +RenderBlock::lineWidth(int y, bool *canClearLine) const +{ + //kdDebug( 6040 ) << "lineWidth(" << y << ")=" << rightOffset(y) - leftOffset(y) << endl; + int result; + if (canClearLine) { + bool rightCanClearLine; + bool leftCanClearLine; + result = rightOffset(y, &rightCanClearLine) - leftOffset(y, &leftCanClearLine); + *canClearLine = rightCanClearLine && leftCanClearLine; + } else + result = rightOffset(y) - leftOffset(y); + return (result < 0) ? 0 : result; +} + +int +RenderBlock::nearestFloatBottom(int height) const +{ + if (!m_floatingObjects) return 0; + int bottom = 0; + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) + if (r->endY>height && (r->endY<bottom || bottom==0)) + bottom=r->endY; + return kMax(bottom, height); +} + +int RenderBlock::floatBottom() const +{ + if (!m_floatingObjects) return 0; + int bottom=0; + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) + if (r->endY>bottom) + bottom=r->endY; + return bottom; +} + +int RenderBlock::lowestPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int bottom = RenderFlow::lowestPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return bottom; + if (includeSelf && m_overflowHeight > bottom) + bottom = m_overflowHeight; + + if (m_floatingObjects) { + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) { + if (!r->noPaint) { + int lp = r->startY + r->node->marginTop() + r->node->lowestPosition(false); + bottom = kMax(bottom, lp); + } + } + } + bottom = kMax(bottom, lowestAbsolutePosition()); + + if (!includeSelf && lastLineBox()) { + int lp = lastLineBox()->yPos() + lastLineBox()->height(); + bottom = kMax(bottom, lp); + } + + return bottom; +} + +int RenderBlock::lowestAbsolutePosition() const +{ + if (!m_positionedObjects) + return 0; + + // Fixed positioned objects do not scroll and thus should not constitute + // part of the lowest position. + int bottom = 0; + RenderObject* r; + TQPtrListIterator<RenderObject> it(*m_positionedObjects); + for ( ; (r = it.current()); ++it ) { + if (r->style()->position() == FIXED) + continue; + int lp = r->yPos() + r->lowestPosition(false); + bottom = kMax(bottom, lp); + } + return bottom; +} + +int RenderBlock::rightmostPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int right = RenderFlow::rightmostPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return right; + if (includeSelf && m_overflowWidth > right) + right = m_overflowWidth; + + if (m_floatingObjects) { + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) { + if (!r->noPaint) { + int rp = r->left + r->node->marginLeft() + r->node->rightmostPosition(false); + right = kMax(right, rp); + } + } + } + right = kMax(right, rightmostAbsolutePosition()); + + if (!includeSelf && firstLineBox()) { + for (InlineRunBox* currBox = firstLineBox(); currBox; currBox = currBox->nextLineBox()) { + int rp = currBox->xPos() + currBox->width(); + right = kMax(right, rp); + } + } + + return right; +} + +int RenderBlock::rightmostAbsolutePosition() const +{ + if (!m_positionedObjects) + return 0; + int right = 0; + RenderObject* r; + TQPtrListIterator<RenderObject> it(*m_positionedObjects); + for ( ; (r = it.current()); ++it ) { + if (r->style()->position() == FIXED) + continue; + int rp = r->xPos() + r->rightmostPosition(false); + right = kMax(right, rp); + } + return right; +} + +int RenderBlock::leftmostPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int left = RenderFlow::leftmostPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return left; + + if (includeSelf && m_overflowLeft < left) + left = m_overflowLeft; + + if (m_floatingObjects) { + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) { + if (!r->noPaint) { + int lp = r->left + r->node->marginLeft() + r->node->leftmostPosition(false); + left = kMin(left, lp); + } + } + } + left = kMin(left, leftmostAbsolutePosition()); + + if (!includeSelf && firstLineBox()) { + for (InlineRunBox* currBox = firstLineBox(); currBox; currBox = currBox->nextLineBox()) + left = kMin(left, (int)currBox->xPos()); + } + + return left; +} + +int RenderBlock::leftmostAbsolutePosition() const +{ + if (!m_positionedObjects) + return 0; + int left = 0; + RenderObject* r; + TQPtrListIterator<RenderObject> it(*m_positionedObjects); + for ( ; (r = it.current()); ++it ) { + if (r->style()->position() == FIXED) + continue; + int lp = r->xPos() + r->leftmostPosition(false); + left = kMin(left, lp); + } + return left; +} + +int RenderBlock::highestPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int top = RenderFlow::highestPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return top; + + if (includeSelf && m_overflowTop < top) + top = m_overflowTop; + + if (m_floatingObjects) { + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) { + if (!r->noPaint) { + int hp = r->startY + r->node->marginTop() + r->node->highestPosition(false); + top = kMin(top, hp); + } + } + } + top = kMin(top, highestAbsolutePosition()); + + if (!includeSelf && firstLineBox()) { + top = kMin(top, (int)firstLineBox()->yPos()); + } + + return top; +} + +int RenderBlock::highestAbsolutePosition() const +{ + if (!m_positionedObjects) + return 0; + int top = 0; + RenderObject* r; + TQPtrListIterator<RenderObject> it(*m_positionedObjects); + for ( ; (r = it.current()); ++it ) { + if (r->style()->position() == FIXED) + continue; + int hp = r->yPos() + r->highestPosition(false); + hp = kMin(top, hp); + } + return top; +} + +int +RenderBlock::leftBottom() +{ + if (!m_floatingObjects) return 0; + int bottom=0; + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) + if (r->endY>bottom && r->type == FloatingObject::FloatLeft) + bottom=r->endY; + + return bottom; +} + +int +RenderBlock::rightBottom() +{ + if (!m_floatingObjects) return 0; + int bottom=0; + FloatingObject* r; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for ( ; (r = it.current()); ++it ) + if (r->endY>bottom && r->type == FloatingObject::FloatRight) + bottom=r->endY; + + return bottom; +} + +void +RenderBlock::clearFloats() +{ + if (m_floatingObjects) + m_floatingObjects->clear(); + + // we are done if the element defines a new block formatting context + if (flowAroundFloats() || isRoot() || isCanvas() || isFloatingOrPositioned() || isTableCell()) return; + + RenderObject *prev = previousSibling(); + + // find the element to copy the floats from + // pass non-flows + // pass fAF's + bool parentHasFloats = false; + while (prev) { + if (!prev->isRenderBlock() || prev->isFloatingOrPositioned() || prev->flowAroundFloats()) { + if ( prev->isFloating() && parent()->isRenderBlock() ) { + parentHasFloats = true; + } + prev = prev->previousSibling(); + } else + break; + } + + int offset = m_y; + if (parentHasFloats) + { + addOverHangingFloats( static_cast<RenderBlock *>( parent() ), + parent()->borderLeft() + parent()->paddingLeft(), offset, false ); + } + + int xoffset = 0; + if (prev) { + if(prev->isTableCell()) return; + offset -= prev->yPos(); + } else { + prev = parent(); + if(!prev) return; + xoffset += prev->borderLeft() + prev->paddingLeft(); + } + //kdDebug() << "RenderBlock::clearFloats found previous "<< (void *)this << " prev=" << (void *)prev<< endl; + + // add overhanging special objects from the previous RenderBlock + if(!prev->isRenderBlock()) return; + RenderBlock * flow = static_cast<RenderBlock *>(prev); + if(!flow->m_floatingObjects) return; + if(flow->floatBottom() > offset) + addOverHangingFloats( flow, xoffset, offset, false ); +} + +void RenderBlock::addOverHangingFloats( RenderBlock *flow, int xoff, int offset, bool child ) +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << (void *)this << ": adding overhanging floats xoff=" << xoff << " offset=" << offset << " child=" << child << endl; +#endif + + // Prevent floats from being added to the canvas by the root element, e.g., <html>. + if ( !flow->m_floatingObjects || (child && flow->isRoot()) ) + return; + + // if I am clear of my floats, don't add them + // the CSS spec also mentions that child floats + // are not cleared. + if (!child && style()->clear() == CBOTH) + { + return; + } + + TQPtrListIterator<FloatingObject> it(*flow->m_floatingObjects); + FloatingObject *r; + for ( ; (r = it.current()); ++it ) { + + if (!child && r->type == FloatingObject::FloatLeft && style()->clear() == CLEFT ) + continue; + if (!child && r->type == FloatingObject::FloatRight && style()->clear() == CRIGHT ) + continue; + + if ( ( !child && r->endY > offset ) || + ( child && flow->yPos() + r->endY > height() ) ) { + if (child && !r->crossedLayer) { + if (flow->enclosingLayer() == enclosingLayer()) { + // Set noPaint to true only if we didn't cross layers. + r->noPaint = true; + } else { + r->crossedLayer = true; + } + } + + FloatingObject* f = 0; + // don't insert it twice! + if (m_floatingObjects) { + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + while ( (f = it.current()) ) { + if (f->node == r->node) break; + ++it; + } + } + if ( !f ) { + FloatingObject *floatingObj = new FloatingObject(r->type); + floatingObj->startY = r->startY - offset; + floatingObj->endY = r->endY - offset; + floatingObj->left = r->left - xoff; + // Applying the child's margin makes no sense in the case where the child was passed in. + // since his own margin was added already through the subtraction of the |xoff| variable + // above. |xoff| will equal -flow->marginLeft() in this case, so it's already been taken + // into account. Only apply this code if |child| is false, since otherwise the left margin + // will get applied twice. -dwh + if (!child && flow != parent()) + floatingObj->left += flow->marginLeft(); + if ( !child ) { + floatingObj->left -= marginLeft(); + floatingObj->noPaint = true; + } + else { + floatingObj->noPaint = (r->crossedLayer || !r->noPaint); + floatingObj->crossedLayer = r->crossedLayer; + } + + floatingObj->width = r->width; + floatingObj->node = r->node; + if (!m_floatingObjects) { + m_floatingObjects = new TQPtrList<FloatingObject>; + m_floatingObjects->setAutoDelete(true); + } + m_floatingObjects->append(floatingObj); +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << "addOverHangingFloats x/y= (" << floatingObj->left << "/" << floatingObj->startY << "-" << floatingObj->width << "/" << floatingObj->endY - floatingObj->startY << ")" << endl; +#endif + } + } + } +} + +bool RenderBlock::containsFloat(RenderObject* o) const +{ + if (m_floatingObjects) { + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + while (it.current()) { + if (it.current()->node == o) + return true; + ++it; + } + } + return false; +} + +void RenderBlock::markAllDescendantsWithFloatsForLayout(RenderObject* floatToRemove) +{ + dirtyFormattingContext(false); + setChildNeedsLayout(true); + + if (floatToRemove) + removeFloatingObject(floatToRemove); + + // Iterate over our children and mark them as needed. + if (!childrenInline()) { + for (RenderObject* child = firstChild(); child; child = child->nextSibling()) { + if (isBlockFlow() && !child->isFloatingOrPositioned() && + ((floatToRemove ? child->containsFloat(floatToRemove) : child->hasFloats()) || child->usesLineWidth())) + child->markAllDescendantsWithFloatsForLayout(floatToRemove); + } + } +} + +int RenderBlock::getClearDelta(RenderObject *child) +{ + if (!hasFloats()) + return 0; + + //kdDebug( 6040 ) << "getClearDelta on child " << child << " oldheight=" << m_height << endl; + bool clearSet = child->style()->clear() != CNONE; + int bottom = 0; + switch(child->style()->clear()) + { + case CNONE: + break; + case CLEFT: + bottom = leftBottom(); + break; + case CRIGHT: + bottom = rightBottom(); + break; + case CBOTH: + bottom = floatBottom(); + break; + } + + // We also clear floats if we are too big to sit on the same line as a float, and happen to flow around floats. + // FIXME: Note that the remaining space checks aren't quite accurate, since you should be able to clear only some floats (the minimum # needed + // to fit) and not all (we should be using nearestFloatBottom and looping). + + int result = clearSet ? kMax(0, bottom - child->yPos()) : 0; + if (!result && child->flowAroundFloats() && !style()->width().isVariable()) { + bool canClearLine; + int lw = lineWidth(child->yPos(), &canClearLine); + if (((child->style()->width().isPercent() && child->width() > lw) || + (child->style()->width().isFixed() && child->minWidth() > lw)) && + child->minWidth() <= contentWidth() && canClearLine) + result = kMax(0, floatBottom() - child->yPos()); + } + return result; +} + +bool RenderBlock::isPointInScrollbar(int _x, int _y, int _tx, int _ty) +{ + if (!scrollsOverflow() || !m_layer) + return false; + + if (m_layer->verticalScrollbarWidth()) { + TQRect vertRect(_tx + width() - borderRight() - m_layer->verticalScrollbarWidth(), + _ty + borderTop() - borderTopExtra(), + m_layer->verticalScrollbarWidth(), + height() + borderTopExtra() + borderBottomExtra()-borderTop()-borderBottom()); + if (vertRect.contains(_x, _y)) { +#ifdef APPLE_CHANGES + RenderLayer::gScrollBar = m_layer->verticalScrollbar(); +#endif + return true; + } + } + + if (m_layer->horizontalScrollbarHeight()) { + TQRect horizRect(_tx + borderLeft(), + _ty + height() + borderTop() + borderBottomExtra() - borderBottom() - m_layer->horizontalScrollbarHeight(), + width()-borderLeft()-borderRight(), + m_layer->horizontalScrollbarHeight()); + if (horizRect.contains(_x, _y)) { +#ifdef APPLE_CHANGES + RenderLayer::gScrollBar = m_layer->horizontalScrollbar(); +#endif + return true; + } + } + + return false; +} + +bool RenderBlock::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inBox) +{ + bool inScrollbar = isPointInScrollbar(_x, _y, _tx+xPos(), _ty+yPos()); + if (inScrollbar && hitTestAction != HitTestChildrenOnly) + inBox = true; + + if (hitTestAction != HitTestSelfOnly && m_floatingObjects && !inScrollbar) { + int stx = _tx + xPos(); + int sty = _ty + yPos(); + if (hasOverflowClip() && m_layer) + m_layer->subtractScrollOffset(stx, sty); + FloatingObject* o; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + for (it.toLast(); (o = it.current()); --it) + if (!o->noPaint && !o->node->layer()) + inBox |= o->node->nodeAtPoint(info, _x, _y, + stx+o->left + o->node->marginLeft() - o->node->xPos(), + sty+o->startY + o->node->marginTop() - o->node->yPos(), HitTestAll ) ; + } + + inBox |= RenderFlow::nodeAtPoint(info, _x, _y, _tx, _ty, hitTestAction, inBox); + return inBox; +} + +void RenderBlock::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(RenderBlock)::calcMinMaxWidth() this=" << this << endl; +#endif + + m_minWidth = 0; + m_maxWidth = 0; + + bool noWrap = !style()->autoWrap(); + if (childrenInline()) + calcInlineMinMaxWidth(); + else + calcBlockMinMaxWidth(); + + if(m_maxWidth < m_minWidth) m_maxWidth = m_minWidth; + + if (noWrap && childrenInline()) { + m_minWidth = m_maxWidth; + + // A horizontal marquee with inline children has no minimum width. + if (style()->overflowX() == OMARQUEE && m_layer && m_layer->marquee() && + m_layer->marquee()->isHorizontal() && !m_layer->marquee()->isUnfurlMarquee()) + m_minWidth = 0; + } + + if (isTableCell()) { + Length w = static_cast<RenderTableCell*>(this)->styleOrColWidth(); + if (w.isFixed() && w.value() > 0) + m_maxWidth = kMax((int)m_minWidth, calcContentWidth(w.value())); + } else if (style()->width().isFixed() && style()->width().value() > 0) + m_minWidth = m_maxWidth = calcContentWidth(style()->width().value()); + + if (style()->minWidth().isFixed() && style()->minWidth().value() > 0) { + m_maxWidth = kMax(m_maxWidth, (int)calcContentWidth(style()->minWidth().value())); + m_minWidth = kMax(m_minWidth, (short)calcContentWidth(style()->minWidth().value())); + } + + if (style()->maxWidth().isFixed() && style()->maxWidth().value() != UNDEFINED) { + m_maxWidth = kMin(m_maxWidth, (int)calcContentWidth(style()->maxWidth().value())); + m_minWidth = kMin(m_minWidth, (short)calcContentWidth(style()->maxWidth().value())); + } + + int toAdd = 0; + toAdd = borderLeft() + borderRight() + paddingLeft() + paddingRight(); + + m_minWidth += toAdd; + m_maxWidth += toAdd; + + setMinMaxKnown(); + + //kdDebug( 6040 ) << "Text::calcMinMaxWidth(" << this << "): min = " << m_minWidth << " max = " << m_maxWidth << endl; + // ### compare with min/max width set in style sheet... +} + +// bidi.cpp defines the following functions too. +// Maybe these should not be static, after all... + +#ifndef KDE_USE_FINAL + +static int getBPMWidth(int childValue, Length cssUnit) +{ + if (!cssUnit.isVariable()) + return (cssUnit.isFixed() ? cssUnit.value() : childValue); + return 0; +} + +static int getBorderPaddingMargin(RenderObject* child, bool endOfInline) +{ + RenderStyle* cstyle = child->style(); + int result = 0; + bool leftSide = (cstyle->direction() == LTR) ? !endOfInline : endOfInline; + result += getBPMWidth((leftSide ? child->marginLeft() : child->marginRight()), + (leftSide ? cstyle->marginLeft() : + cstyle->marginRight())); + result += getBPMWidth((leftSide ? child->paddingLeft() : child->paddingRight()), + (leftSide ? cstyle->paddingLeft() : + cstyle->paddingRight())); + result += leftSide ? child->borderLeft() : child->borderRight(); + return result; +} +#endif + +static void stripTrailingSpace(bool preserveWS, + int& inlineMax, int& inlineMin, + RenderObject* trailingSpaceChild) +{ + if (!preserveWS && trailingSpaceChild && trailingSpaceChild->isText()) { + // Collapse away the trailing space at the end of a block. + RenderText* t = static_cast<RenderText *>(trailingSpaceChild); + const Font *f = t->htmlFont( false ); + TQChar space[1]; space[0] = ' '; + int spaceWidth = f->width(space, 1, 0); + inlineMax -= spaceWidth; + if (inlineMin > inlineMax) + inlineMin = inlineMax; + } +} + +void RenderBlock::calcInlineMinMaxWidth() +{ + int inlineMax=0; + int inlineMin=0; + + int cw = containingBlock()->contentWidth(); + int floatMaxWidth = 0; + + // If we are at the start of a line, we want to ignore all white-space. + // Also strip spaces if we previously had text that ended in a trailing space. + bool stripFrontSpaces = true; + + bool isTcQuirk = isTableCell() && style()->htmlHacks() && style()->width().isVariable(); + + RenderObject* trailingSpaceChild = 0; + + bool autoWrap, oldAutoWrap; + autoWrap = oldAutoWrap = style()->autoWrap(); + + InlineMinMaxIterator childIterator(this, this); + bool addedTextIndent = false; // Only gets added in once. + RenderObject* prevFloat = 0; + while (RenderObject* child = childIterator.next()) + { + autoWrap = child->style()->autoWrap(); + + if( !child->isBR() ) + { + // Step One: determine whether or not we need to go ahead and + // terminate our current line. Each discrete chunk can become + // the new min-width, if it is the widest chunk seen so far, and + // it can also become the max-width. + + // Children fall into three categories: + // (1) An inline flow object. These objects always have a min/max of 0, + // and are included in the iteration solely so that their margins can + // be added in. + // + // (2) An inline non-text non-flow object, e.g., an inline replaced element. + // These objects can always be on a line by themselves, so in this situation + // we need to go ahead and break the current line, and then add in our own + // margins and min/max width on its own line, and then terminate the line. + // + // (3) A text object. Text runs can have breakable characters at the start, + // the middle or the end. They may also lose whitespace off the front if + // we're already ignoring whitespace. In order to compute accurate min-width + // information, we need three pieces of information. + // (a) the min-width of the first non-breakable run. Should be 0 if the text string + // starts with whitespace. + // (b) the min-width of the last non-breakable run. Should be 0 if the text string + // ends with whitespace. + // (c) the min/max width of the string (trimmed for whitespace). + // + // If the text string starts with whitespace, then we need to go ahead and + // terminate our current line (unless we're already in a whitespace stripping + // mode. + // + // If the text string has a breakable character in the middle, but didn't start + // with whitespace, then we add the width of the first non-breakable run and + // then end the current line. We then need to use the intermediate min/max width + // values (if any of them are larger than our current min/max). We then look at + // the width of the last non-breakable run and use that to start a new line + // (unless we end in whitespace). + RenderStyle* cstyle = child->style(); + short childMin = 0; + short childMax = 0; + + if (!child->isText()) { + // Case (1) and (2). Inline replaced and inline flow elements. + if (child->isInlineFlow()) { + // Add in padding/border/margin from the appropriate side of + // the element. + int bpm = getBorderPaddingMargin(child, childIterator.endOfInline); + childMin += bpm; + childMax += bpm; + + inlineMin += childMin; + inlineMax += childMax; + } + else { + // Inline replaced elements add in their margins to their min/max values. + int margins = 0; + LengthType type = cstyle->marginLeft().type(); + if ( type != Variable ) + margins += (type == Fixed ? cstyle->marginLeft().value() : child->marginLeft()); + type = cstyle->marginRight().type(); + if ( type != Variable ) + margins += (type == Fixed ? cstyle->marginRight().value() : child->marginRight()); + childMin += margins; + childMax += margins; + } + } + + if (!child->isRenderInline() && !child->isText()) { + + bool qBreak = isTcQuirk && !child->isFloatingOrPositioned(); + // Case (2). Inline replaced elements and floats. + // Go ahead and terminate the current line as far as + // minwidth is concerned. + childMin += child->minWidth(); + childMax += child->maxWidth(); + + if (!qBreak && (autoWrap || oldAutoWrap)) { + if(m_minWidth < inlineMin) m_minWidth = inlineMin; + inlineMin = 0; + } + + // Check our "clear" setting. If we're supposed to clear the previous float, then + // go ahead and terminate maxwidth as well. + if (child->isFloating()) { + if (prevFloat && + ((inlineMax + childMax > floatMaxWidth) || + ((prevFloat->style()->floating() & FLEFT) && (child->style()->clear() & CLEFT)) || + ((prevFloat->style()->floating() & FRIGHT) && (child->style()->clear() & CRIGHT)))) { + m_maxWidth = kMax(inlineMax, (int)m_maxWidth); + inlineMax = 0; + } + prevFloat = child; + if (!floatMaxWidth) + floatMaxWidth = availableWidth(); + } + + // Add in text-indent. This is added in only once. + int ti = 0; + if ( !addedTextIndent ) { + addedTextIndent = true; + ti = style()->textIndent().minWidth( cw ); + childMin+=ti; + childMax+=ti; + } + + // Add our width to the max. + inlineMax += childMax; + + if (!autoWrap||qBreak) + inlineMin += childMin; + else { + // Now check our line. + inlineMin = childMin; + if(m_minWidth < inlineMin) m_minWidth = inlineMin; + + // Now start a new line. + inlineMin = 0; + } + + // We are no longer stripping whitespace at the start of + // a line. + if (!child->isFloating()) { + stripFrontSpaces = false; + trailingSpaceChild = 0; + } + } + else if (child->isText()) + { + // Case (3). Text. + RenderText* t = static_cast<RenderText *>(child); + + // Determine if we have a breakable character. Pass in + // whether or not we should ignore any spaces at the front + // of the string. If those are going to be stripped out, + // then they shouldn't be considered in the breakable char + // check. + bool hasBreakableChar, hasBreak; + short beginMin, endMin; + bool beginWS, endWS; + short beginMax, endMax; + t->trimmedMinMaxWidth(beginMin, beginWS, endMin, endWS, hasBreakableChar, + hasBreak, beginMax, endMax, + childMin, childMax, stripFrontSpaces); + + // This text object is insignificant and will not be rendered. Just + // continue. + if (!hasBreak && childMax == 0) continue; + + if (stripFrontSpaces) + trailingSpaceChild = child; + else + trailingSpaceChild = 0; + + // Add in text-indent. This is added in only once. + int ti = 0; + if (!addedTextIndent) { + addedTextIndent = true; + ti = style()->textIndent().minWidth(cw); + childMin+=ti; beginMin += ti; + childMax+=ti; beginMax += ti; + } + + // If we have no breakable characters at all, + // then this is the easy case. We add ourselves to the current + // min and max and continue. + if (!hasBreakableChar) { + inlineMin += childMin; + } + else { + // We have a breakable character. Now we need to know if + // we start and end with whitespace. + if (beginWS) { + // Go ahead and end the current line. + if(m_minWidth < inlineMin) m_minWidth = inlineMin; + } + else { + inlineMin += beginMin; + if(m_minWidth < inlineMin) m_minWidth = inlineMin; + childMin -= ti; + } + + inlineMin = childMin; + + if (endWS) { + // We end in whitespace, which means we can go ahead + // and end our current line. + if(m_minWidth < inlineMin) m_minWidth = inlineMin; + inlineMin = 0; + } + else { + if(m_minWidth < inlineMin) m_minWidth = inlineMin; + inlineMin = endMin; + } + } + + if (hasBreak) { + inlineMax += beginMax; + if (m_maxWidth < inlineMax) m_maxWidth = inlineMax; + if (m_maxWidth < childMax) m_maxWidth = childMax; + inlineMax = endMax; + } + else + inlineMax += childMax; + } + } + else + { + if(m_minWidth < inlineMin) m_minWidth = inlineMin; + if(m_maxWidth < inlineMax) m_maxWidth = inlineMax; + inlineMin = inlineMax = 0; + stripFrontSpaces = true; + trailingSpaceChild = 0; + } + + oldAutoWrap = autoWrap; + } + + stripTrailingSpace(style()->preserveWS(), inlineMax, inlineMin, trailingSpaceChild); + + if(m_minWidth < inlineMin) m_minWidth = inlineMin; + if(m_maxWidth < inlineMax) m_maxWidth = inlineMax; + // kdDebug( 6040 ) << "m_minWidth=" << m_minWidth + // << " m_maxWidth=" << m_maxWidth << endl; +} + +// Use a very large value (in effect infinite). +#define BLOCK_MAX_WIDTH 15000 + +void RenderBlock::calcBlockMinMaxWidth() +{ + bool nowrap = !style()->autoWrap(); + + RenderObject *child = firstChild(); + RenderObject* prevFloat = 0; + int floatWidths = 0; + int floatMaxWidth = 0; + + while(child != 0) + { + // positioned children don't affect the minmaxwidth + if (child->isPositioned()) { + child = child->nextSibling(); + continue; + } + + if (prevFloat && (!child->isFloating() || + ((prevFloat->style()->floating() & FLEFT) && (child->style()->clear() & CLEFT)) || + ((prevFloat->style()->floating() & FRIGHT) && (child->style()->clear() & CRIGHT)))) { + m_maxWidth = kMax(floatWidths, m_maxWidth); + floatWidths = 0; + } + + Length ml = child->style()->marginLeft(); + Length mr = child->style()->marginRight(); + + // Call calcWidth on the child to ensure that our margins are + // up to date. This method can be called before the child has actually + // calculated its margins (which are computed inside calcWidth). + if (ml.isPercent() || mr.isPercent()) + calcWidth(); + + // A margin basically has three types: fixed, percentage, and auto (variable). + // Auto margins simply become 0 when computing min/max width. + // Fixed margins can be added in as is. + // Percentage margins are computed as a percentage of the width we calculated in + // the calcWidth call above. In this case we use the actual cached margin values on + // the RenderObject itself. + int margin = 0; + if (ml.isFixed()) + margin += ml.value(); + else if (ml.isPercent()) + margin += child->marginLeft(); + + if (mr.isFixed()) + margin += mr.value(); + else if (mr.isPercent()) + margin += child->marginRight(); + + if (margin < 0) margin = 0; + + int w = child->minWidth() + margin; + if(m_minWidth < w) m_minWidth = w; + // IE ignores tables for calculation of nowrap. Makes some sense. + if ( nowrap && !child->isTable() && m_maxWidth < w ) + m_maxWidth = w; + + w = child->maxWidth() + margin; + + if(m_maxWidth < w) m_maxWidth = w; + + if (child->isFloating()) { + if (prevFloat && (floatWidths + w > floatMaxWidth)) { + m_maxWidth = kMax(floatWidths, m_maxWidth); + floatWidths = w; + } else + floatWidths += w; + } else if (m_maxWidth < w) + m_maxWidth = w; + + // A very specific WinIE quirk. + // Example: + /* + <div style="position:absolute; width:100px; top:50px;"> + <div style="position:absolute;left:0px;top:50px;height:50px;background-color:green"> + <table style="width:100%"><tr><td></table> + </div> + </div> + */ + // In the above example, the inner absolute positioned block should have a computed width + // of 100px because of the table. + // We can achieve this effect by making the maxwidth of blocks that contain tables + // with percentage widths be infinite (as long as they are not inside a table cell). + if (style()->htmlHacks() && child->style()->width().isPercent() && + !isTableCell() && child->isTable() && m_maxWidth < BLOCK_MAX_WIDTH) { + RenderBlock* cb = containingBlock(); + while (!cb->isCanvas() && !cb->isTableCell()) + cb = cb->containingBlock(); + if (!cb->isTableCell()) + m_maxWidth = BLOCK_MAX_WIDTH; + } + if (child->isFloating()) { + prevFloat = child; + if (!floatMaxWidth) + floatMaxWidth = availableWidth(); + } + child = child->nextSibling(); + } + m_maxWidth = kMax(floatWidths, m_maxWidth); +} + +void RenderBlock::close() +{ + if (lastChild() && lastChild()->isAnonymousBlock()) + lastChild()->close(); + updateFirstLetter(); + RenderFlow::close(); +} + +int RenderBlock::getBaselineOfFirstLineBox() +{ + if (m_firstLineBox) + return m_firstLineBox->yPos() + m_firstLineBox->baseline(); + + if (isInline()) + return -1; // We're inline and had no line box, so we have no baseline we can return. + + for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) { + int result = curr->getBaselineOfFirstLineBox(); + if (result != -1) + return curr->yPos() + result; // Translate to our coordinate space. + } + + return -1; +} + +InlineFlowBox* RenderBlock::getFirstLineBox() +{ + if (m_firstLineBox) + return m_firstLineBox; + + if (isInline()) + return 0; // We're inline and had no line box, so we have no baseline we can return. + + for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) { + InlineFlowBox* result = curr->getFirstLineBox(); + if (result) + return result; + } + + return 0; +} + +bool RenderBlock::inRootBlockContext() const +{ + if (isTableCell() || isFloatingOrPositioned() || hasOverflowClip()) + return false; + + if (isRoot() || isCanvas()) + return true; + + return containingBlock()->inRootBlockContext(); +} + +const char *RenderBlock::renderName() const +{ + if (isFloating()) + return "RenderBlock (floating)"; + if (isPositioned()) + return "RenderBlock (positioned)"; + if (isAnonymousBlock() && m_avoidPageBreak) + return "RenderBlock (avoidPageBreak)"; + if (isAnonymousBlock()) + return "RenderBlock (anonymous)"; + else if (isAnonymous()) + return "RenderBlock (generated)"; + if (isRelPositioned()) + return "RenderBlock (relative positioned)"; + if (style() && style()->display() == COMPACT) + return "RenderBlock (compact)"; + if (style() && style()->display() == RUN_IN) + return "RenderBlock (run-in)"; + return "RenderBlock"; +} + +#ifdef ENABLE_DUMP +void RenderBlock::printTree(int indent) const +{ + RenderFlow::printTree(indent); + + if (m_floatingObjects) + { + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + FloatingObject *r; + for ( ; (r = it.current()); ++it ) + { + TQString s; + s.fill(' ', indent); + kdDebug() << s << renderName() << ": " << + (r->type == FloatingObject::FloatLeft ? "FloatLeft" : "FloatRight" ) << + "[" << r->node->renderName() << ": " << (void*)r->node << "] (" << r->startY << " - " << r->endY << ")" << "width: " << r->width << + endl; + } + } +} + +void RenderBlock::dump(TQTextStream &stream, const TQString &ind) const +{ + RenderFlow::dump(stream,ind); + + if (m_childrenInline) { stream << " childrenInline"; } + // FIXME: currently only print pre to not mess up regression + if (style()->preserveWS()) { stream << " pre"; } + if (m_firstLine) { stream << " firstLine"; } + + if (m_floatingObjects && !m_floatingObjects->isEmpty()) + { + stream << " special("; + TQPtrListIterator<FloatingObject> it(*m_floatingObjects); + FloatingObject *r; + bool first = true; + for ( ; (r = it.current()); ++it ) + { + if (!first) + stream << ","; + stream << r->node->renderName(); + first = false; + } + stream << ")"; + } + + // ### EClear m_clearStatus +} +#endif + +#undef DEBUG +#undef DEBUG_LAYOUT +#undef BOX_DEBUG + +} // namespace tdehtml + diff --git a/tdehtml/rendering/render_block.h b/tdehtml/rendering/render_block.h new file mode 100644 index 000000000..84fd15a0b --- /dev/null +++ b/tdehtml/rendering/render_block.h @@ -0,0 +1,378 @@ +/* + * This file is part of the render object implementation for KHTML. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999-2003 Antti Koivisto (koivisto@kde.org) + * (C) 2002-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#ifndef RENDER_BLOCK_H +#define RENDER_BLOCK_H + +#include <tqptrlist.h> + +#include "render_flow.h" + +namespace tdehtml { + +class RenderBlock : public RenderFlow +{ +public: + RenderBlock(DOM::NodeImpl* node); + virtual ~RenderBlock(); + + virtual const char *renderName() const; + + virtual bool isRenderBlock() const { return true; } + virtual bool isBlockFlow() const { return !isInline() && !isTable(); } + virtual bool isInlineFlow() const { return isInline() && !isReplaced(); } + virtual bool isInlineBlockOrInlineTable() const { return isInline() && isReplaced(); } + + virtual bool childrenInline() const { return m_childrenInline; } + virtual void setChildrenInline(bool b) { m_childrenInline = b; } + void makeChildrenNonInline(RenderObject* insertionPoint = 0); + + void makePageBreakAvoidBlocks(); + + // The height (and width) of a block when you include overflow spillage out of the bottom + // of the block (e.g., a <div style="height:25px"> that has a 100px tall image inside + // it would have an overflow height of borderTop() + paddingTop() + 100px. + virtual int overflowHeight() const { return m_overflowHeight; } + virtual int overflowWidth() const { return m_overflowWidth; } + virtual int overflowLeft() const { return m_overflowLeft; } + virtual int overflowTop() const { return m_overflowTop; } + virtual void setOverflowHeight(int h) { m_overflowHeight = h; } + virtual void setOverflowWidth(int w) { m_overflowWidth = w; } + virtual void setOverflowLeft(int l) { m_overflowLeft = l; } + virtual void setOverflowTop(int t) { m_overflowTop = t; } + + virtual bool isSelfCollapsingBlock() const; + virtual bool isTopMarginQuirk() const { return m_topMarginQuirk; } + virtual bool isBottomMarginQuirk() const { return m_bottomMarginQuirk; } + + virtual short maxTopMargin(bool positive) const { + if (positive) + return m_maxTopPosMargin; + else + return m_maxTopNegMargin; + } + virtual short maxBottomMargin(bool positive) const { + if (positive) + return m_maxBottomPosMargin; + else + return m_maxBottomNegMargin; + } + + void initMaxMarginValues() { + if (m_marginTop >= 0) + m_maxTopPosMargin = m_marginTop; + else + m_maxTopNegMargin = -m_marginTop; + if (m_marginBottom >= 0) + m_maxBottomPosMargin = m_marginBottom; + else + m_maxBottomNegMargin = -m_marginBottom; + } + + virtual void addChildToFlow(RenderObject* newChild, RenderObject* beforeChild); + virtual void removeChild(RenderObject *oldChild); + + virtual void setStyle(RenderStyle* _style); + virtual void attach(); + void updateFirstLetter(); + + virtual void layout(); + void layoutBlock( bool relayoutChildren ); + void layoutBlockChildren( bool relayoutChildren ); + void layoutInlineChildren( bool relayoutChildren, int breakBeforeLine = 0); + + void layoutPositionedObjects( bool relayoutChildren ); + void insertPositionedObject(RenderObject *o); + void removePositionedObject(RenderObject *o); + + // Called to lay out the legend for a fieldset. + virtual RenderObject* layoutLegend(bool /*relayoutChildren*/) { return 0; }; + + // the implementation of the following functions is in bidi.cpp + void bidiReorderLine(const BidiIterator &start, const BidiIterator &end, BidiState &bidi ); + BidiIterator findNextLineBreak(BidiIterator &start, BidiState &info ); + InlineFlowBox* constructLine(const BidiIterator& start, const BidiIterator& end); + InlineFlowBox* createLineBoxes(RenderObject* obj); + void computeHorizontalPositionsForLine(InlineFlowBox* lineBox, BidiState &bidi); + void computeVerticalPositionsForLine(InlineFlowBox* lineBox); + bool clearLineOfPageBreaks(InlineFlowBox* lineBox); + void checkLinesForOverflow(); + void deleteEllipsisLineBoxes(); + void checkLinesForTextOverflow(); + // end bidi.cpp functions + + virtual void paint(PaintInfo& i, int tx, int ty); + void paintObject(PaintInfo& i, int tx, int ty, bool paintOutline = true); + void paintFloats(PaintInfo& i, int _tx, int _ty, bool paintSelection = false); + + void insertFloatingObject(RenderObject *o); + void removeFloatingObject(RenderObject *o); + + // called from lineWidth, to position the floats added in the last line. + void positionNewFloats(); + void clearFloats(); + int getClearDelta(RenderObject *child); + virtual void markAllDescendantsWithFloatsForLayout(RenderObject* floatToRemove = 0); + + // FIXME: containsFloats() should not return true if the floating objects list + // is empty. However, layoutInlineChildren() relies on the current behavior. + // http://bugzilla.opendarwin.org/show_bug.cgi?id=7395#c3 + virtual bool hasFloats() const { return m_floatingObjects!=0; } + virtual bool containsFloat(RenderObject* o) const; + + virtual bool hasOverhangingFloats() const { return floatBottom() > m_height; } + void addOverHangingFloats( RenderBlock *block, int xoffset, int yoffset, bool child ); + + int nearestFloatBottom(int height) const; + int floatBottom() const; + inline int leftBottom(); + inline int rightBottom(); + + virtual unsigned short lineWidth(int y, bool *canClearLine = 0) const; + virtual int lowestPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int rightmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int leftmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int highestPosition(bool includeOverflowInterior, bool includeSelf) const; + int lowestAbsolutePosition() const; + int leftmostAbsolutePosition() const; + int rightmostAbsolutePosition() const; + int highestAbsolutePosition() const; + + int rightOffset() const; + int rightRelOffset(int y, int fixedOffset, bool applyTextIndent=true, int *heightRemaining = 0, bool *canClearLine = 0) const; + int rightOffset(int y, bool *canClearLine = 0) const { return rightRelOffset(y, rightOffset(), true, 0, canClearLine); } + + int leftOffset() const; + int leftRelOffset(int y, int fixedOffset, bool applyTextIndent=true, int *heightRemaining = 0, bool *canClearLine = 0) const; + int leftOffset(int y, bool *canClearLine = 0) const { return leftRelOffset(y, leftOffset(), true, 0, canClearLine); } + + virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int _tx, int _ty, HitTestAction hitTestAction = HitTestAll, bool inside=false); + + bool isPointInScrollbar(int x, int y, int tx, int ty); + + virtual void calcMinMaxWidth(); + void calcInlineMinMaxWidth(); + void calcBlockMinMaxWidth(); + + virtual void close(); + + virtual int getBaselineOfFirstLineBox(); + virtual InlineFlowBox* getFirstLineBox(); + + RootInlineBox* firstRootBox() { return static_cast<RootInlineBox*>(m_firstLineBox); } + RootInlineBox* lastRootBox() { return static_cast<RootInlineBox*>(m_lastLineBox); } + + bool inRootBlockContext() const; + +#ifdef ENABLE_DUMP + virtual void printTree(int indent=0) const; + virtual void dump(TQTextStream &stream, const TQString &ind) const; +#endif + +protected: + void newLine(); + +protected: + struct FloatingObject { + enum Type { + FloatLeft, + FloatRight + }; + + FloatingObject(Type _type) { + node = 0; + startY = 0; + endY = 0; + type = _type; + left = 0; + width = 0; + noPaint = false; + crossedLayer = false; + + } + RenderObject* node; + int startY; + int endY; + short left; + short width; + Type type : 1; // left or right aligned + bool noPaint : 1; + bool crossedLayer : 1; // lock noPaint flag + }; + + // The following helper functions and structs are used by layoutBlockChildren. + class CompactInfo { + // A compact child that needs to be collapsed into the margin of the following block. + RenderObject* m_compact; + + // The block with the open margin that the compact child is going to place itself within. + RenderObject* m_block; + bool m_treatAsBlock : 1; + + public: + RenderObject* compact() const { return m_compact; } + RenderObject* block() const { return m_block; } + void setTreatAsBlock(bool b) { m_treatAsBlock = b; } + bool treatAsBlock() const { return m_treatAsBlock; } + bool matches(RenderObject* child) const { return m_compact && m_block == child; } + + void clear() { set(0, 0); } + void set(RenderObject* c, RenderObject* b) { m_compact = c; m_block = b; } + + CompactInfo() { clear(); } + }; + + class MarginInfo { + // Collapsing flags for whether we can collapse our margins with our children's margins. + bool m_canCollapseWithChildren : 1; + bool m_canCollapseTopWithChildren : 1; + bool m_canCollapseBottomWithChildren : 1; + + // Whether or not we are a quirky container, i.e., do we collapse away top and bottom + // margins in our container. Table cells and the body are the common examples. We + // also have a custom style property for Safari RSS to deal with TypePad blog articles. + bool m_quirkContainer : 1; + + // This flag tracks whether we are still looking at child margins that can all collapse together at the beginning of a block. + // They may or may not collapse with the top margin of the block (|m_canCollapseTopWithChildren| tells us that), but they will + // always be collapsing with one another. This variable can remain set to true through multiple iterations + // as long as we keep encountering self-collapsing blocks. + bool m_atTopOfBlock : 1; + + // This flag is set when we know we're examining bottom margins and we know we're at the bottom of the block. + bool m_atBottomOfBlock : 1; + + // If our last normal flow child was a self-collapsing block that cleared a float, + // we track it in this variable. + bool m_selfCollapsingBlockClearedFloat : 1; + + // These variables are used to detect quirky margins that we need to collapse away (in table cells + // and in the body element). + bool m_topQuirk : 1; + bool m_bottomQuirk : 1; + bool m_determinedTopQuirk : 1; + + // These flags track the previous maximal positive and negative margins. + int m_posMargin; + int m_negMargin; + + public: + MarginInfo(RenderBlock* b, int top, int bottom); + + void setAtTopOfBlock(bool b) { m_atTopOfBlock = b; } + void setAtBottomOfBlock(bool b) { m_atBottomOfBlock = b; } + void clearMargin() { m_posMargin = m_negMargin = 0; } + void setSelfCollapsingBlockClearedFloat(bool b) { m_selfCollapsingBlockClearedFloat = b; } + void setTopQuirk(bool b) { m_topQuirk = b; } + void setBottomQuirk(bool b) { m_bottomQuirk = b; } + void setDeterminedTopQuirk(bool b) { m_determinedTopQuirk = b; } + void setPosMargin(int p) { m_posMargin = p; } + void setNegMargin(int n) { m_negMargin = n; } + void setPosMarginIfLarger(int p) { if (p > m_posMargin) m_posMargin = p; } + void setNegMarginIfLarger(int n) { if (n > m_negMargin) m_negMargin = n; } + + void setMargin(int p, int n) { m_posMargin = p; m_negMargin = n; } + + bool atTopOfBlock() const { return m_atTopOfBlock; } + bool canCollapseWithTop() const { return m_atTopOfBlock && m_canCollapseTopWithChildren; } + bool canCollapseWithBottom() const { return m_atBottomOfBlock && m_canCollapseBottomWithChildren; } + bool canCollapseTopWithChildren() const { return m_canCollapseTopWithChildren; } + bool canCollapseBottomWithChildren() const { return m_canCollapseBottomWithChildren; } + bool selfCollapsingBlockClearedFloat() const { return m_selfCollapsingBlockClearedFloat; } + bool quirkContainer() const { return m_quirkContainer; } + bool determinedTopQuirk() const { return m_determinedTopQuirk; } + bool topQuirk() const { return m_topQuirk; } + bool bottomQuirk() const { return m_bottomQuirk; } + int posMargin() const { return m_posMargin; } + int negMargin() const { return m_negMargin; } + int margin() const { return m_posMargin - m_negMargin; } + }; + + class PageBreakInfo { + int m_pageBottom; // Next calculated page-break + bool m_forcePageBreak : 1; // Must break before next block + // ### to do better "page-break-after/before: avoid" this struct + // should keep a pagebreakAvoid block and gather children in it + public: + PageBreakInfo(int pageBottom) : m_pageBottom(pageBottom), m_forcePageBreak(false) {}; + bool forcePageBreak() { return m_forcePageBreak; } + void setForcePageBreak(bool b) { m_forcePageBreak = b; } + int pageBottom() { return m_pageBottom; }; + void setPageBottom(int bottom) { m_pageBottom = bottom; } + }; + + virtual bool canClear(RenderObject *child, PageBreakLevel level); + void clearPageBreak(RenderObject* child, int pageBottom); + + void adjustPositionedBlock(RenderObject* child, const MarginInfo& marginInfo); + void adjustFloatingBlock(const MarginInfo& marginInfo); + RenderObject* handleSpecialChild(RenderObject* child, const MarginInfo& marginInfo, CompactInfo& compactInfo, bool& handled); + RenderObject* handleFloatingChild(RenderObject* child, const MarginInfo& marginInfo, bool& handled); + RenderObject* handlePositionedChild(RenderObject* child, const MarginInfo& marginInfo, bool& handled); + RenderObject* handleCompactChild(RenderObject* child, CompactInfo& compactInfo, const MarginInfo& marginInfo, bool& handled); + RenderObject* handleRunInChild(RenderObject* child, bool& handled); + void collapseMargins(RenderObject* child, MarginInfo& marginInfo, int yPosEstimate); + void clearFloatsIfNeeded(RenderObject* child, MarginInfo& marginInfo, int oldTopPosMargin, int oldTopNegMargin); + void adjustSizeForCompactIfNeeded(RenderObject* child, CompactInfo& compactInfo); + void insertCompactIfNeeded(RenderObject* child, CompactInfo& compactInfo); + int estimateVerticalPosition(RenderObject* child, const MarginInfo& info); + void determineHorizontalPosition(RenderObject* child); + void handleBottomOfBlock(int top, int bottom, MarginInfo& marginInfo); + void setCollapsedBottomMargin(const MarginInfo& marginInfo); + void clearChildOfPageBreaks(RenderObject* child, PageBreakInfo &pageBreakInfo, MarginInfo &marginInfo); + // End helper functions and structs used by layoutBlockChildren. + +protected: + // How much content overflows out of our block vertically or horizontally (all we support + // for now is spillage out of the bottom and the right, which are the common cases). + int m_overflowHeight; + int m_overflowWidth; + + // Left and top overflow. + int m_overflowTop; + int m_overflowLeft; + +private: + TQPtrList<FloatingObject>* m_floatingObjects; + TQPtrList<RenderObject>* m_positionedObjects; + + bool m_childrenInline : 1; + bool m_firstLine : 1; // used in inline layouting + EClear m_clearStatus : 2; // used during layuting of paragraphs + bool m_avoidPageBreak : 1; // anonymous avoid page-break block + bool m_topMarginQuirk : 1; + bool m_bottomMarginQuirk : 1; + + short m_maxTopPosMargin; + short m_maxTopNegMargin; + short m_maxBottomPosMargin; + short m_maxBottomNegMargin; + +}; + +} // namespace + +#endif // RENDER_BLOCK_H + diff --git a/tdehtml/rendering/render_body.cpp b/tdehtml/rendering/render_body.cpp new file mode 100644 index 000000000..80a613000 --- /dev/null +++ b/tdehtml/rendering/render_body.cpp @@ -0,0 +1,121 @@ +/** + * This file is part of the html renderer for KDE. + * + * Copyright (C) 2000-2003 Lars Knoll (knoll@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#include "rendering/render_body.h" +#include "rendering/render_canvas.h" +#include "html/html_baseimpl.h" +#include "xml/dom_docimpl.h" +#include "tdehtmlview.h" + +#include <kglobal.h> +#include <kdebug.h> + +using namespace tdehtml; +using namespace DOM; + +RenderBody::RenderBody(HTMLBodyElementImpl* element) + : RenderBlock(element) +{ + scrollbarsStyled = false; +} + +RenderBody::~RenderBody() +{ +} + +void RenderBody::setStyle(RenderStyle* style) +{ +// tqDebug("RenderBody::setStyle()"); + // ignore position: fixed on body + if (style->htmlHacks() && style->position() == FIXED) + style->setPosition(STATIC); + + RenderBlock::setStyle(style); + document()->setTextColor( style->color() ); + scrollbarsStyled = false; +} + +void RenderBody::paintBoxDecorations(PaintInfo& paintInfo, int _tx, int _ty) +{ + //kdDebug( 6040 ) << renderName() << "::paintDecorations()" << endl; + TQColor bgColor; + const BackgroundLayer *bgLayer = 0; + + if( parent()->style()->hasBackground() ) { + // the root element already has a non-transparent background of its own + // so we must fork our own. (CSS2.1 - 14.2 §4) + bgColor = style()->backgroundColor(); + bgLayer = style()->backgroundLayers(); + } + + int w = width(); + int h = height() + borderTopExtra() + borderBottomExtra(); + _ty -= borderTopExtra(); + + int my = kMax(_ty, paintInfo.r.y()); + int end = kMin( paintInfo.r.y()+paintInfo.r.height(), _ty + h ); + int mh = end - my; + + paintBackgrounds(paintInfo.p, bgColor, bgLayer, my, mh, _tx, _ty, w, h); + + if(style()->hasBorder()) + paintBorder( paintInfo.p, _tx, _ty, w, h, style() ); + +} + +void RenderBody::repaint(Priority p) +{ + RenderObject *cb = containingBlock(); + if(cb) + cb->repaint(p); +} + +void RenderBody::layout() +{ + // in quirk mode, we'll need to have our margins determined + // for percentage height calculations + if (style()->htmlHacks()) + calcHeight(); + RenderBlock::layout(); + + if (!scrollbarsStyled) + { + RenderCanvas* canvas = this->canvas(); + if (canvas->view()) + { + canvas->view()->horizontalScrollBar()->setPalette(style()->palette()); + canvas->view()->verticalScrollBar()->setPalette(style()->palette()); + } + scrollbarsStyled=true; + } +} + +int RenderBody::availableHeight() const +{ + int h = RenderBlock::availableHeight(); + + if( style()->marginTop().isFixed() ) + h -= style()->marginTop().value(); + if( style()->marginBottom().isFixed() ) + h -= style()->marginBottom().value(); + + return kMax(0, h); +} diff --git a/tdehtml/rendering/render_body.h b/tdehtml/rendering/render_body.h new file mode 100644 index 000000000..b7ac7c99a --- /dev/null +++ b/tdehtml/rendering/render_body.h @@ -0,0 +1,56 @@ +/* + * This file is part of the html renderer for KDE. + * + * Copyright (C) 2000-2003 Lars Knoll (knoll@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_BODY +#define RENDER_BODY + +#include "rendering/render_block.h" + +namespace DOM +{ + class HTMLBodyElementImpl; +} + +namespace tdehtml { + +class RenderBody : public RenderBlock +{ +public: + RenderBody(DOM::HTMLBodyElementImpl* node); + virtual ~RenderBody(); + + virtual bool isBody() const { return true; } + + virtual const char *renderName() const { return "RenderBody"; } + virtual void repaint(Priority p=NormalPriority); + + virtual void layout(); + virtual void setStyle(RenderStyle* style); + + virtual int availableHeight() const; + +protected: + virtual void paintBoxDecorations(PaintInfo&, int _tx, int _ty); + bool scrollbarsStyled; +}; + +} // end namespace +#endif diff --git a/tdehtml/rendering/render_box.cpp b/tdehtml/rendering/render_box.cpp new file mode 100644 index 000000000..4cf7080c7 --- /dev/null +++ b/tdehtml/rendering/render_box.cpp @@ -0,0 +1,2325 @@ +/** + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2002-2003 Apple Computer, Inc. + * (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * (C) 2006 Samuel Weinig (sam.weinig@gmail.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +// ------------------------------------------------------------------------- +//#define DEBUG_LAYOUT +//#define CLIP_DEBUG + + +#include <tqpainter.h> + +#include "misc/loader.h" +#include "rendering/render_replaced.h" +#include "rendering/render_canvas.h" +#include "rendering/render_table.h" +#include "rendering/render_inline.h" +#include "rendering/render_block.h" +#include "rendering/render_line.h" +#include "rendering/render_layer.h" +#include "misc/htmlhashes.h" +#include "xml/dom_nodeimpl.h" +#include "xml/dom_docimpl.h" +#include "html/html_elementimpl.h" + +#include <tdehtmlview.h> +#include <kdebug.h> +#include <kglobal.h> +#include <assert.h> + + +using namespace DOM; +using namespace tdehtml; + +#define TABLECELLMARGIN -0x4000 + +RenderBox::RenderBox(DOM::NodeImpl* node) + : RenderContainer(node) +{ + m_minWidth = -1; + m_maxWidth = -1; + m_width = m_height = 0; + m_x = 0; + m_y = 0; + m_marginTop = 0; + m_marginBottom = 0; + m_marginLeft = 0; + m_marginRight = 0; + m_staticX = 0; + m_staticY = 0; + + m_placeHolderBox = 0; + m_layer = 0; +} + +RenderBlock* RenderBox::createAnonymousBlock() +{ + RenderStyle *newStyle = new RenderStyle(); + newStyle->inheritFrom(style()); + newStyle->setDisplay(BLOCK); + + RenderBlock *newBox = new (renderArena()) RenderBlock(document() /* anonymous*/); + newBox->setStyle(newStyle); + return newBox; +} + +void RenderBox::restructureParentFlow() { + if (!parent() || parent()->childrenInline() == isInline()) + return; + // We have gone from not affecting the inline status of the parent flow to suddenly + // having an impact. See if there is a mismatch between the parent flow's + // childrenInline() state and our state. + if (!isInline()) { + if (parent()->isRenderInline()) { + // We have to split the parent flow. + RenderInline* parentInline = static_cast<RenderInline*>(parent()); + RenderBlock* newBox = parentInline->createAnonymousBlock(); + + RenderFlow* oldContinuation = parent()->continuation(); + parentInline->setContinuation(newBox); + + RenderObject* beforeChild = nextSibling(); + parent()->removeChildNode(this); + parentInline->splitFlow(beforeChild, newBox, this, oldContinuation); + } + else if (parent()->isRenderBlock()) + static_cast<RenderBlock*>(parent())->makeChildrenNonInline(); + } + else { + // An anonymous block must be made to wrap this inline. + RenderBlock* box = createAnonymousBlock(); + parent()->insertChildNode(box, this); + box->appendChildNode(parent()->removeChildNode(this)); + } +} + +static inline bool overflowAppliesTo(RenderObject* o) +{ + // css 2.1-11.1.1 + // 1) overflow only applies to non-replaced block-level elements, table cells, and inline-block elements + if (o->isRenderBlock() || o->isTableRow() || o->isTableSection()) + // 2) overflow on root applies to the viewport (cf. KHTMLView::layout) + if (!o->isRoot()) + // 3) overflow on body may apply to the viewport... + if (!o->isBody() + // ...but only for HTML documents... + || !o->document()->isHTMLDocument() + // ...and only when the root has a visible overflow + || !o->document()->documentElement()->renderer() + || !o->document()->documentElement()->renderer()->style() + || o->document()->documentElement()->renderer()->style()->hidesOverflow()) + return true; + + return false; +} + +void RenderBox::setStyle(RenderStyle *_style) +{ + bool affectsParent = style() && isFloatingOrPositioned() && + (!_style->isFloating() && _style->position() != ABSOLUTE && _style->position() != FIXED) && + parent() && (parent()->isBlockFlow() || parent()->isInlineFlow()); + + RenderContainer::setStyle(_style); + + // The root always paints its background/border. + if (isRoot()) + setShouldPaintBackgroundOrBorder(true); + + switch(_style->display()) + { + case INLINE: + case INLINE_BLOCK: + case INLINE_TABLE: + setInline(true); + break; + case RUN_IN: + if (isInline() && parent() && parent()->childrenInline()) + break; + default: + setInline(false); + } + + switch(_style->position()) + { + case ABSOLUTE: + case FIXED: + setPositioned(true); + break; + default: + setPositioned(false); + if( !isTableCell() && _style->isFloating() ) + setFloating(true); + + if( _style->position() == RELATIVE ) + setRelPositioned(true); + } + + if (overflowAppliesTo(this) && _style->hidesOverflow()) + setHasOverflowClip(); + + if (requiresLayer()) { + if (!m_layer) { + m_layer = new (renderArena()) RenderLayer(this); + m_layer->insertOnlyThisLayer(); + if (parent() && containingBlock()) + m_layer->updateLayerPosition(); + } + } + else if (m_layer && !isCanvas()) { + m_layer->removeOnlyThisLayer(); + m_layer = 0; + } + + if (m_layer) + m_layer->styleChanged(); + + if (style()->outlineWidth() > 0 && style()->outlineSize() > maximalOutlineSize(PaintActionOutline)) + static_cast<RenderCanvas*>(document()->renderer())->setMaximalOutlineSize(style()->outlineSize()); + if (affectsParent) + restructureParentFlow(); +} + +RenderBox::~RenderBox() +{ + //kdDebug( 6040 ) << "Element destructor: this=" << nodeName().string() << endl; +} + +void RenderBox::detach() +{ + RenderLayer* layer = m_layer; + RenderArena* arena = renderArena(); + + RenderContainer::detach(); + + if (layer) + layer->detach(arena); +} + +InlineBox* RenderBox::createInlineBox(bool /*makePlaceHolderBox*/, bool /*isRootLineBox*/) +{ + if (m_placeHolderBox) + m_placeHolderBox->detach(renderArena()); + return (m_placeHolderBox = new (renderArena()) InlineBox(this)); +} + +void RenderBox::deleteInlineBoxes(RenderArena* arena) +{ + if (m_placeHolderBox) { + m_placeHolderBox->detach( arena ? arena : renderArena() ); + m_placeHolderBox = 0; + } +} + +short RenderBox::contentWidth() const +{ + short w = m_width - style()->borderLeftWidth() - style()->borderRightWidth(); + w -= paddingLeft() + paddingRight(); + + if (m_layer && scrollsOverflowY()) + w -= m_layer->verticalScrollbarWidth(); + + //kdDebug( 6040 ) << "RenderBox::contentWidth(2) = " << w << endl; + return w; +} + +int RenderBox::contentHeight() const +{ + int h = m_height - style()->borderTopWidth() - style()->borderBottomWidth(); + h -= paddingTop() + paddingBottom(); + + if (m_layer && scrollsOverflowX()) + h -= m_layer->horizontalScrollbarHeight(); + + return h; +} + +void RenderBox::setPos( int xPos, int yPos ) +{ + m_x = xPos; m_y = yPos; +} + +short RenderBox::width() const +{ + return m_width; +} + +int RenderBox::height() const +{ + return m_height; +} + +void RenderBox::setWidth( int width ) +{ + m_width = width; +} + +void RenderBox::setHeight( int height ) +{ + m_height = height; +} + +int RenderBox::calcBoxHeight(int h) const +{ + if (style()->boxSizing() == CONTENT_BOX) + h += borderTop() + borderBottom() + paddingTop() + paddingBottom(); + + return h; +} + +int RenderBox::calcBoxWidth(int w) const +{ + if (style()->boxSizing() == CONTENT_BOX) + w += borderLeft() + borderRight() + paddingLeft() + paddingRight(); + + return w; +} + +int RenderBox::calcContentHeight(int h) const +{ + if (style()->boxSizing() == BORDER_BOX) + h -= borderTop() + borderBottom() + paddingTop() + paddingBottom(); + + return kMax(0, h); +} + +int RenderBox::calcContentWidth(int w) const +{ + if (style()->boxSizing() == BORDER_BOX) + w -= borderLeft() + borderRight() + paddingLeft() + paddingRight(); + + return kMax(0, w); +} + +// --------------------- painting stuff ------------------------------- + +void RenderBox::paint(PaintInfo& i, int _tx, int _ty) +{ + _tx += m_x; + _ty += m_y; + + if (hasOverflowClip() && m_layer) + m_layer->subtractScrollOffset(_tx, _ty); + + // default implementation. Just pass things through to the children + for(RenderObject* child = firstChild(); child; child = child->nextSibling()) + child->paint(i, _tx, _ty); +} + +void RenderBox::paintRootBoxDecorations(PaintInfo& paintInfo, int _tx, int _ty) +{ + //kdDebug( 6040 ) << renderName() << "::paintRootBoxDecorations()" << _tx << "/" << _ty << endl; + const BackgroundLayer* bgLayer = style()->backgroundLayers(); + TQColor bgColor = style()->backgroundColor(); + if (document()->isHTMLDocument() && !style()->hasBackground()) { + // Locate the <body> element using the DOM. This is easier than trying + // to crawl around a render tree with potential :before/:after content and + // anonymous blocks created by inline <body> tags etc. We can locate the <body> + // render object very easily via the DOM. + HTMLElementImpl* body = document()->body(); + RenderObject* bodyObject = (body && body->id() == ID_BODY) ? body->renderer() : 0; + + if (bodyObject) { + bgLayer = bodyObject->style()->backgroundLayers(); + bgColor = bodyObject->style()->backgroundColor(); + } + } + + if( !bgColor.isValid() && canvas()->view()) + bgColor = canvas()->view()->palette().active().color(TQColorGroup::Base); + + int w = width(); + int h = height(); + + // kdDebug(0) << "width = " << w <<endl; + + int rw, rh; + if (canvas()->view()) { + rw = canvas()->view()->contentsWidth(); + rh = canvas()->view()->contentsHeight(); + } else { + rw = canvas()->docWidth(); + rh = canvas()->docHeight(); + } + + // kdDebug(0) << "rw = " << rw <<endl; + + int bx = _tx - marginLeft(); + int by = _ty - marginTop(); + int bw = QMAX(w + marginLeft() + marginRight() + borderLeft() + borderRight(), rw); + int bh = QMAX(h + marginTop() + marginBottom() + borderTop() + borderBottom(), rh); + + // CSS2 14.2: + // " The background of the box generated by the root element covers the entire canvas." + // hence, paint the background even in the margin areas (unlike for every other element!) + // I just love these little inconsistencies .. :-( (Dirk) + int my = kMax(by, paintInfo.r.y()); + + paintBackgrounds(paintInfo.p, bgColor, bgLayer, my, paintInfo.r.height(), bx, by, bw, bh); + + if(style()->hasBorder()) + paintBorder( paintInfo.p, _tx, _ty, w, h, style() ); +} + +void RenderBox::paintBoxDecorations(PaintInfo& paintInfo, int _tx, int _ty) +{ + //kdDebug( 6040 ) << renderName() << "::paintDecorations()" << endl; + + if(isRoot()) + return paintRootBoxDecorations(paintInfo, _tx, _ty); + + int w = width(); + int h = height() + borderTopExtra() + borderBottomExtra(); + _ty -= borderTopExtra(); + + int my = kMax(_ty,paintInfo.r.y()); + int end = kMin( paintInfo.r.y() + paintInfo.r.height(), _ty + h ); + int mh = end - my; + + // The <body> only paints its background if the root element has defined a background + // independent of the body. Go through the DOM to get to the root element's render object, + // since the root could be inline and wrapped in an anonymous block. + + if (!isBody() || !document()->isHTMLDocument() || document()->documentElement()->renderer()->style()->hasBackground()) + paintBackgrounds(paintInfo.p, style()->backgroundColor(), style()->backgroundLayers(), my, mh, _tx, _ty, w, h); + + if(style()->hasBorder()) { + paintBorder(paintInfo.p, _tx, _ty, w, h, style()); + } +} + +void RenderBox::paintBackgrounds(TQPainter *p, const TQColor& c, const BackgroundLayer* bgLayer, int clipy, int cliph, int _tx, int _ty, int w, int height) + { + if (!bgLayer) return; + paintBackgrounds(p, c, bgLayer->next(), clipy, cliph, _tx, _ty, w, height); + paintBackground(p, c, bgLayer, clipy, cliph, _tx, _ty, w, height); +} + +void RenderBox::paintBackground(TQPainter *p, const TQColor& c, const BackgroundLayer* bgLayer, int clipy, int cliph, int _tx, int _ty, int w, int height) +{ + paintBackgroundExtended(p, c, bgLayer, clipy, cliph, _tx, _ty, w, height, + borderLeft(), borderRight(), paddingLeft(), paddingRight()); +} + +static void calculateBackgroundSize(const BackgroundLayer* bgLayer, int& scaledWidth, int& scaledHeight) +{ + CachedImage* bg = bgLayer->backgroundImage(); + + if (bgLayer->isBackgroundSizeSet()) { + Length bgWidth = bgLayer->backgroundSize().width; + Length bgHeight = bgLayer->backgroundSize().height; + + if (bgWidth.isPercent()) + scaledWidth = scaledWidth * bgWidth.value() / 100; + else if (bgWidth.isFixed()) + scaledWidth = bgWidth.value(); + else if (bgWidth.isVariable()) { + // If the width is auto and the height is not, we have to use the appropriate + // scale to maintain our aspect ratio. + if (bgHeight.isPercent()) { + int scaledH = scaledHeight * bgHeight.value() / 100; + scaledWidth = bg->pixmap_size().width() * scaledH / bg->pixmap_size().height(); + } else if (bgHeight.isFixed()) + scaledWidth = bg->pixmap_size().width() * bgHeight.value() / bg->pixmap_size().height(); + } + + if (bgHeight.isPercent()) + scaledHeight = scaledHeight * bgHeight.value() / 100; + else if (bgHeight.isFixed()) + scaledHeight = bgHeight.value(); + else if (bgHeight.isVariable()) { + // If the height is auto and the width is not, we have to use the appropriate + // scale to maintain our aspect ratio. + if (bgWidth.isPercent()) + scaledHeight = bg->pixmap_size().height() * scaledWidth / bg->pixmap_size().width(); + else if (bgWidth.isFixed()) + scaledHeight = bg->pixmap_size().height() * bgWidth.value() / bg->pixmap_size().width(); + else if (bgWidth.isVariable()) { + // If both width and height are auto, we just want to use the image's + // intrinsic size. + scaledWidth = bg->pixmap_size().width(); + scaledHeight = bg->pixmap_size().height(); + } + } + } else { + scaledWidth = bg->pixmap_size().width(); + scaledHeight = bg->pixmap_size().height(); + } +} + +void RenderBox::paintBackgroundExtended(TQPainter *p, const TQColor &c, const BackgroundLayer* bgLayer, int clipy, int cliph, + int _tx, int _ty, int w, int h, + int bleft, int bright, int pleft, int pright) +{ + if ( cliph < 0 ) + return; + + if (bgLayer->backgroundClip() != BGBORDER) { + // Clip to the padding or content boxes as necessary. + bool includePadding = bgLayer->backgroundClip() == BGCONTENT; + int x = _tx + bleft + (includePadding ? pleft : 0); + int y = _ty + borderTop() + (includePadding ? paddingTop() : 0); + int width = w - bleft - bright - (includePadding ? pleft + pright : 0); + int height = h - borderTop() - borderBottom() - (includePadding ? paddingTop() + paddingBottom() : 0); + p->save(); + p->setClipRect(TQRect(x, y, width, height), TQPainter::CoordPainter); + } + + CachedImage* bg = bgLayer->backgroundImage(); + bool shouldPaintBackgroundImage = bg && bg->pixmap_size() == bg->valid_rect().size() && !bg->isTransparent() && !bg->isErrorImage(); + TQColor bgColor = c; + + // Paint the color first underneath all images. + if (!bgLayer->next() && bgColor.isValid() && tqAlpha(bgColor.rgb()) > 0) + p->fillRect(_tx, clipy, w, cliph, bgColor); + + // no progressive loading of the background image + if (shouldPaintBackgroundImage) { + int sx = 0; + int sy = 0; + int cw,ch; + int cx,cy; + int scaledImageWidth, scaledImageHeight; + + // CSS2 chapter 14.2.1 + + if (bgLayer->backgroundAttachment()) { + //scroll + int hpab = 0, vpab = 0, left = 0, top = 0; // Init to 0 for background-origin of 'border' + if (bgLayer->backgroundOrigin() != BGBORDER) { + hpab += bleft + bright; + vpab += borderTop() + borderBottom(); + left += bleft; + top += borderTop(); + if (bgLayer->backgroundOrigin() == BGCONTENT) { + hpab += pleft + pright; + vpab += paddingTop() + paddingBottom(); + left += pleft; + top += paddingTop(); + } + } + + int pw = w - hpab; + int ph = h - vpab; + scaledImageWidth = pw; + scaledImageHeight = ph; + calculateBackgroundSize(bgLayer, scaledImageWidth, scaledImageHeight); + + EBackgroundRepeat bgr = bgLayer->backgroundRepeat(); + if (bgr == NO_REPEAT || bgr == REPEAT_Y) { + cw = scaledImageWidth; + int xPosition = bgLayer->backgroundXPosition().minWidth(pw-scaledImageWidth); + if ( xPosition >= 0 ) { + cx = _tx + xPosition; + cw = kMin(scaledImageWidth, pw - xPosition); + } + else { + cx = _tx; + if (scaledImageWidth > 0) { + sx = -xPosition; + cw = kMin(scaledImageWidth+xPosition, pw); + } + } + cx += left; + } else { + // repeat over x + cw = w; + cx = _tx; + if (scaledImageWidth > 0) { + int xPosition = bgLayer->backgroundXPosition().minWidth(pw-scaledImageWidth); + sx = scaledImageWidth - (xPosition % scaledImageWidth); + sx -= left % scaledImageWidth; + } + } + if (bgr == NO_REPEAT || bgr == REPEAT_X) { + ch = scaledImageHeight; + int yPosition = bgLayer->backgroundYPosition().minWidth(ph - scaledImageHeight); + if ( yPosition >= 0 ) { + cy = _ty + yPosition; + ch = kMin(ch, ph - yPosition); + } + else { + cy = _ty; + if (scaledImageHeight > 0) { + sy = -yPosition; + ch = kMin(scaledImageHeight+yPosition, ph); + } + } + + cy += top; + } else { + // repeat over y + ch = h; + cy = _ty; + if (scaledImageHeight > 0) { + int yPosition = bgLayer->backgroundYPosition().minWidth(ph - scaledImageHeight); + sy = scaledImageHeight - (yPosition % scaledImageHeight); + sy -= top % scaledImageHeight; + } + } + if (layer()) + layer()->scrollOffset(sx, sy); + } + else + { + //fixed + TQRect vr = viewRect(); + int pw = vr.width(); + int ph = vr.height(); + scaledImageWidth = pw; + scaledImageHeight = ph; + calculateBackgroundSize(bgLayer, scaledImageWidth, scaledImageHeight); + EBackgroundRepeat bgr = bgLayer->backgroundRepeat(); + + int xPosition = bgLayer->backgroundXPosition().minWidth(pw-scaledImageWidth); + if (bgr == NO_REPEAT || bgr == REPEAT_Y) { + cw = kMin(scaledImageWidth, pw - xPosition); + cx = vr.x() + xPosition; + } else { + cw = pw; + cx = vr.x(); + if (scaledImageWidth > 0) + sx = scaledImageWidth - xPosition % scaledImageWidth; + } + + int yPosition = bgLayer->backgroundYPosition().minWidth(ph-scaledImageHeight); + if (bgr == NO_REPEAT || bgr == REPEAT_X) { + ch = kMin(scaledImageHeight, ph - yPosition); + cy = vr.y() + yPosition; + } else { + ch = ph; + cy = vr.y(); + if (scaledImageHeight > 0) + sy = scaledImageHeight - yPosition % scaledImageHeight; + } + + TQRect fix(cx, cy, cw, ch); + TQRect ele(_tx, _ty, w, h); + TQRect b = fix.intersect(ele); + + //kdDebug() <<" ele is " << ele << " b is " << b << " fix is " << fix << endl; + sx+=b.x()-cx; + sy+=b.y()-cy; + cx=b.x();cy=b.y();cw=b.width();ch=b.height(); + } + // restrict painting to repaint-clip + if (cy < clipy) { + ch -= (clipy - cy); + sy += (clipy - cy); + cy = clipy; + } + ch = kMin(ch, cliph); + +// kdDebug() << " clipy, cliph: " << clipy << ", " << cliph << endl; +// kdDebug() << " drawTiledPixmap(" << cx << ", " << cy << ", " << cw << ", " << ch << ", " << sx << ", " << sy << ")" << endl; + if (cw>0 && ch>0) + p->drawTiledPixmap(cx, cy, cw, ch, bg->tiled_pixmap(c, scaledImageWidth, scaledImageHeight), sx, sy); + + } + + if (bgLayer->backgroundClip() != BGBORDER) + p->restore(); // Undo the background clip + +} + +void RenderBox::outlineBox(TQPainter *p, int _tx, int _ty, const char *color) +{ + p->setPen(TQPen(TQColor(color), 1, Qt::DotLine)); + p->setBrush( Qt::NoBrush ); + p->drawRect(_tx, _ty, m_width, m_height); +} + +TQRect RenderBox::getOverflowClipRect(int tx, int ty) +{ + // XXX When overflow-clip (CSS3) is implemented, we'll obtain the property + // here. + int bl=borderLeft(),bt=borderTop(),bb=borderBottom(),br=borderRight(); + int clipx = tx+bl; + int clipy = ty+bt; + int clipw = m_width-bl-br; + int cliph = m_height-bt-bb+borderTopExtra()+borderBottomExtra(); + + // Substract out scrollbars if we have them. + if (m_layer) { + clipw -= m_layer->verticalScrollbarWidth(); + cliph -= m_layer->horizontalScrollbarHeight(); + } + + return TQRect(clipx,clipy,clipw,cliph); +} + +TQRect RenderBox::getClipRect(int tx, int ty) +{ + int bl=borderLeft(),bt=borderTop(),bb=borderBottom(),br=borderRight(); + // ### what about paddings? + int clipw = m_width-bl-br; + int cliph = m_height-bt-bb; + + bool rtl = (style()->direction() == RTL); + + int clipleft = 0; + int clipright = clipw; + int cliptop = 0; + int clipbottom = cliph; + + if ( style()->hasClip() && style()->position() == ABSOLUTE ) { + // the only case we use the clip property according to CSS 2.1 + if (!style()->clipLeft().isVariable()) { + int c = style()->clipLeft().width(clipw); + if ( rtl ) + clipleft = clipw - c; + else + clipleft = c; + } + if (!style()->clipRight().isVariable()) { + int w = style()->clipRight().width(clipw); + if ( rtl ) { + clipright = clipw - w; + } else { + clipright = w; + } + } + if (!style()->clipTop().isVariable()) + cliptop = style()->clipTop().width(cliph); + if (!style()->clipBottom().isVariable()) + clipbottom = style()->clipBottom().width(cliph); + } + int clipx = tx + clipleft; + int clipy = ty + cliptop; + clipw = clipright-clipleft; + cliph = clipbottom-cliptop; + + //kdDebug( 6040 ) << "setting clip("<<clipx<<","<<clipy<<","<<clipw<<","<<cliph<<")"<<endl; + + return TQRect(clipx,clipy,clipw,cliph); +} + +void RenderBox::close() +{ + setNeedsLayoutAndMinMaxRecalc(); +} + +short RenderBox::containingBlockWidth() const +{ + if (isCanvas() && canvas()->view()) + { + if (canvas()->pagedMode()) + return canvas()->width(); + else + return canvas()->view()->visibleWidth(); + } + + RenderBlock* cb = containingBlock(); + if (isRenderBlock() && cb->isTable() && static_cast<RenderTable*>(cb)->caption() == this) { + //captions are not affected by table border or padding + return cb->width(); + } + if (usesLineWidth()) + return cb->lineWidth(m_y); + else + return cb->contentWidth(); +} + +bool RenderBox::absolutePosition(int &_xPos, int &_yPos, bool f) const +{ + if ( style()->position() == FIXED ) + f = true; + RenderObject *o = container(); + if( o && o->absolutePosition(_xPos, _yPos, f)) + { + if ( o->layer() ) { + if (o->hasOverflowClip()) + o->layer()->subtractScrollOffset( _xPos, _yPos ); + if (isPositioned()) + o->layer()->checkInlineRelOffset(this, _xPos, _yPos); + } + + if(!isInline() || isReplaced()) { + _xPos += xPos(), + _yPos += yPos(); + } + + if(isRelPositioned()) + relativePositionOffset(_xPos, _yPos); + return true; + } + else + { + _xPos = 0; + _yPos = 0; + return false; + } +} + +void RenderBox::position(InlineBox* box, int /*from*/, int /*len*/, bool /*reverse*/) +{ + if (isPositioned()) { + // Cache the x position only if we were an INLINE type originally. + bool wasInline = style()->isOriginalDisplayInlineType(); + + if (wasInline && hasStaticX()) { + // The value is cached in the xPos of the box. We only need this value if + // our object was inline originally, since otherwise it would have ended up underneath + // the inlines. + m_staticX = box->xPos(); + } + else if (!wasInline && hasStaticY()) { + // Our object was a block originally, so we make our normal flow position be + // just below the line box (as though all the inlines that came before us got + // wrapped in an anonymous block, which is what would have happened had we been + // in flow). This value was cached in the yPos() of the box. + m_staticY = box->yPos(); + } + } + else if (isReplaced()) + setPos( box->xPos(), box->yPos() ); +} + +void RenderBox::repaint(Priority prior) +{ + int ow = style() ? style()->outlineSize() : 0; + if( isInline() && !isReplaced() ) + { + RenderObject* p = parent(); + Q_ASSERT(p); + while( p->isInline() && !p->isReplaced() ) + p = p->parent(); + int xoff = p->hasOverflowClip() ? 0 : p->overflowLeft(); + int yoff = p->hasOverflowClip() ? 0 : p->overflowTop(); + p->repaintRectangle( -ow + xoff, -ow + yoff, p->effectiveWidth()+ow*2, p->effectiveHeight()+ow*2, prior); + } + else + { + int xoff = hasOverflowClip() ? 0 : overflowLeft(); + int yoff = hasOverflowClip() ? 0 : overflowTop(); + repaintRectangle( -ow + xoff, -ow + yoff, effectiveWidth()+ow*2, effectiveHeight()+ow*2, prior); + } +} + +void RenderBox::repaintRectangle(int x, int y, int w, int h, Priority p, bool f) +{ + x += m_x; + y += m_y; + + // Apply the relative position offset when invalidating a rectangle. The layer + // is translated, but the render box isn't, so we need to do this to get the + // right dirty rect. Since this is called from RenderObject::setStyle, the relative position + // flag on the RenderObject has been cleared, so use the one on the style(). + if (style()->position() == RELATIVE && m_layer) + relativePositionOffset(x,y); + + if (style()->position() == FIXED) f=true; + + // kdDebug( 6040 ) << "RenderBox(" <<this << ", " << renderName() << ")::repaintRectangle (" << x << "/" << y << ") (" << w << "/" << h << ")" << endl; + RenderObject *o = container(); + if( o ) { + if (o->layer()) { + if (o->style()->hidesOverflow() && o->layer() && !o->isInlineFlow()) + o->layer()->subtractScrollOffset(x,y); // For overflow:auto/scroll/hidden. + if (style()->position() == ABSOLUTE) + o->layer()->checkInlineRelOffset(this,x,y); + } + o->repaintRectangle(x, y, w, h, p, f); + } +} + +void RenderBox::relativePositionOffset(int &tx, int &ty) const +{ + if(!style()->left().isVariable()) + tx += style()->left().width(containingBlockWidth()); + else if(!style()->right().isVariable()) + tx -= style()->right().width(containingBlockWidth()); + if(!style()->top().isVariable()) + { + if (!style()->top().isPercent() + || containingBlock()->style()->height().isFixed()) + ty += style()->top().width(containingBlockHeight()); + } + else if(!style()->bottom().isVariable()) + { + if (!style()->bottom().isPercent() + || containingBlock()->style()->height().isFixed()) + ty -= style()->bottom().width(containingBlockHeight()); + } +} + +void RenderBox::calcWidth() +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << "RenderBox("<<renderName()<<")::calcWidth()" << endl; +#endif + if (isPositioned()) + { + calcAbsoluteHorizontal(); + } + else + { + bool treatAsReplaced = isReplaced() && !isInlineBlockOrInlineTable(); + Length w; + if (treatAsReplaced) + w = Length( calcReplacedWidth(), Fixed ); + else + w = style()->width(); + + Length ml = style()->marginLeft(); + Length mr = style()->marginRight(); + + int cw = containingBlockWidth(); + if (cw<0) cw = 0; + + m_marginLeft = 0; + m_marginRight = 0; + + if (isInline() && !isInlineBlockOrInlineTable()) + { + // just calculate margins + m_marginLeft = ml.minWidth(cw); + m_marginRight = mr.minWidth(cw); + if (treatAsReplaced) + { + m_width = calcBoxWidth(w.width(cw)); + m_width = KMAX(m_width, m_minWidth); + } + + return; + } + else + { + LengthType widthType, minWidthType, maxWidthType; + if (treatAsReplaced) { + m_width = calcBoxWidth(w.width(cw)); + widthType = w.type(); + } else { + m_width = calcWidthUsing(Width, cw, widthType); + int minW = calcWidthUsing(MinWidth, cw, minWidthType); + int maxW = style()->maxWidth().value() == UNDEFINED ? + m_width : calcWidthUsing(MaxWidth, cw, maxWidthType); + + if (m_width > maxW) { + m_width = maxW; + widthType = maxWidthType; + } + if (m_width < minW) { + m_width = minW; + widthType = minWidthType; + } + } + + if (widthType == Variable) { + // kdDebug( 6040 ) << "variable" << endl; + m_marginLeft = ml.minWidth(cw); + m_marginRight = mr.minWidth(cw); + } + else + { +// kdDebug( 6040 ) << "non-variable " << w.type << ","<< w.value << endl; + calcHorizontalMargins(ml,mr,cw); + } + } + + if (cw && cw != m_width + m_marginLeft + m_marginRight && !isFloating() && !isInline()) + { + if (containingBlock()->style()->direction()==LTR) + m_marginRight = cw - m_width - m_marginLeft; + else + m_marginLeft = cw - m_width - m_marginRight; + } + } + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << "RenderBox::calcWidth(): m_width=" << m_width << " containingBlockWidth()=" << containingBlockWidth() << endl; + kdDebug( 6040 ) << "m_marginLeft=" << m_marginLeft << " m_marginRight=" << m_marginRight << endl; +#endif +} + +int RenderBox::calcWidthUsing(WidthType widthType, int cw, LengthType& lengthType) +{ + int width = m_width; + Length w; + if (widthType == Width) + w = style()->width(); + else if (widthType == MinWidth) + w = style()->minWidth(); + else + w = style()->maxWidth(); + + lengthType = w.type(); + + if (lengthType == Variable) { + int marginLeft = style()->marginLeft().minWidth(cw); + int marginRight = style()->marginRight().minWidth(cw); + if (cw) width = cw - marginLeft - marginRight; + + // size to max width? + if (sizesToMaxWidth()) { + width = KMAX(width, (int)m_minWidth); + width = KMIN(width, (int)m_maxWidth); + } + } + else + { + width = calcBoxWidth(w.width(cw)); + } + + return width; +} + +void RenderBox::calcHorizontalMargins(const Length& ml, const Length& mr, int cw) +{ + if (isFloating() || isInline()) // Inline blocks/tables and floats don't have their margins increased. + { + m_marginLeft = ml.minWidth(cw); + m_marginRight = mr.minWidth(cw); + } + else + { + if ( (ml.isVariable() && mr.isVariable() && m_width<cw) || + (!ml.isVariable() && !mr.isVariable() && + containingBlock()->style()->textAlign() == KHTML_CENTER) ) + { + m_marginLeft = (cw - m_width)/2; + if (m_marginLeft<0) m_marginLeft=0; + m_marginRight = cw - m_width - m_marginLeft; + } + else if ( (mr.isVariable() && m_width<cw) || + (!ml.isVariable() && containingBlock()->style()->direction() == RTL && + containingBlock()->style()->textAlign() == KHTML_LEFT)) + { + m_marginLeft = ml.width(cw); + m_marginRight = cw - m_width - m_marginLeft; + } + else if ( (ml.isVariable() && m_width<cw) || + (!mr.isVariable() && containingBlock()->style()->direction() == LTR && + containingBlock()->style()->textAlign() == KHTML_RIGHT)) + { + m_marginRight = mr.width(cw); + m_marginLeft = cw - m_width - m_marginRight; + } + else + { + // this makes auto margins 0 if we failed a m_width<cw test above (css2.1, 10.3.3) + m_marginLeft = ml.minWidth(cw); + m_marginRight = mr.minWidth(cw); + } + } +} + +void RenderBox::calcHeight() +{ + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << "RenderBox::calcHeight()" << endl; +#endif + + //cell height is managed by table, inline elements do not have a height property. + if ( isTableCell() || (isInline() && !isReplaced()) ) + return; + + if (isPositioned()) + calcAbsoluteVertical(); + else + { + calcVerticalMargins(); + + // For tables, calculate margins only + if (isTable()) + return; + + Length h; + bool treatAsReplaced = isReplaced() && !isInlineBlockOrInlineTable(); + bool checkMinMaxHeight = false; + + if ( treatAsReplaced ) + h = Length( calcReplacedHeight(), Fixed ); + else { + h = style()->height(); + checkMinMaxHeight = true; + } + + int height; + if (checkMinMaxHeight) { + height = calcHeightUsing(style()->height()); + if (height == -1) + height = m_height; + int minH = calcHeightUsing(style()->minHeight()); // Leave as -1 if unset. + int maxH = style()->maxHeight().value() == UNDEFINED ? height : calcHeightUsing(style()->maxHeight()); + if (maxH == -1) + maxH = height; + height = kMin(maxH, height); + height = kMax(minH, height); + } + else { + // The only times we don't check min/max height are when a fixed length has + // been given as an override. Just use that. + height = calcBoxHeight(h.value()); + } + + if (height<m_height && !overhangingContents() && !hasOverflowClip()) + setOverhangingContents(); + + m_height = height; + } + + // Unfurling marquees override with the furled height. + if (style()->overflowX() == OMARQUEE && m_layer && m_layer->marquee() && + m_layer->marquee()->isUnfurlMarquee() && !m_layer->marquee()->isHorizontal()) { + m_layer->marquee()->setEnd(m_height); + m_height = kMin(m_height, m_layer->marquee()->unfurlPos()); + } + +} + +int RenderBox::calcHeightUsing(const Length& h) +{ + int height = -1; + if (!h.isVariable()) { + if (h.isFixed()) + height = h.value(); + else if (h.isPercent()) + height = calcPercentageHeight(h); + if (height != -1) { + height = calcBoxHeight(height); + return height; + } + } + return height; +} + +int RenderBox::calcImplicitHeight() const { + assert(hasImplicitHeight()); + + RenderBlock* cb = containingBlock(); + // padding-box height + int ch = cb->height() - cb->borderTop() + cb->borderBottom(); + int top = style()->top().width(ch); + int bottom = style()->bottom().width(ch); + + return ch - top - bottom; +} + +int RenderBox::calcPercentageHeight(const Length& height, bool treatAsReplaced) const +{ + int result = -1; + RenderBlock* cb = containingBlock(); + // In quirk mode, table cells violate what the CSS spec says to do with heights. + if (cb->isTableCell() && style()->htmlHacks()) { + result = static_cast<RenderTableCell*>(cb)->cellPercentageHeight(); + } + + // Otherwise we only use our percentage height if our containing block had a specified + // height. + else if (cb->style()->height().isFixed()) + result = cb->calcContentHeight(cb->style()->height().value()); + else if (cb->style()->height().isPercent()) { + // We need to recur and compute the percentage height for our containing block. + result = cb->calcPercentageHeight(cb->style()->height(), treatAsReplaced); + if (result != -1) + result = cb->calcContentHeight(result); + } + else if (cb->isCanvas()) { + if (!canvas()->pagedMode()) + result = static_cast<RenderCanvas*>(cb)->viewportHeight(); + else + result = static_cast<RenderCanvas*>(cb)->height(); + result -= cb->style()->borderTopWidth() - cb->style()->borderBottomWidth(); + result -= cb->paddingTop() + cb->paddingBottom(); + } + else if (cb->isBody() && style()->htmlHacks() && + cb->style()->height().isVariable() && !cb->isFloatingOrPositioned()) { + int margins = cb->collapsedMarginTop() + cb->collapsedMarginBottom(); + int visHeight = canvas()->viewportHeight(); + RenderObject* p = cb->parent(); + result = visHeight - (margins + p->marginTop() + p->marginBottom() + + p->borderTop() + p->borderBottom() + + p->paddingTop() + p->paddingBottom()); + } + else if (cb->isRoot() && style()->htmlHacks() && cb->style()->height().isVariable()) { + int visHeight = canvas()->viewportHeight(); + result = visHeight - (marginTop() + marginBottom() + + borderTop() + borderBottom() + + paddingTop() + paddingBottom()); + } + else if (cb->isAnonymousBlock() || treatAsReplaced && style()->htmlHacks()) { + // IE quirk. + result = cb->calcPercentageHeight(cb->style()->height(), treatAsReplaced); + } + else if (cb->hasImplicitHeight()) { + result = cb->calcImplicitHeight(); + } + + if (result != -1) { + result = height.width(result); + if (cb->isTableCell() && style()->boxSizing() != BORDER_BOX) { + result -= (borderTop() + paddingTop() + borderBottom() + paddingBottom()); + result = kMax(0, result); + } + } + return result; +} + +short RenderBox::calcReplacedWidth() const +{ + int width = calcReplacedWidthUsing(Width); + int minW = calcReplacedWidthUsing(MinWidth); + int maxW = style()->maxWidth().value() == UNDEFINED ? width : calcReplacedWidthUsing(MaxWidth); + + if (width > maxW) + width = maxW; + + if (width < minW) + width = minW; + + return width; +} + +int RenderBox::calcReplacedWidthUsing(WidthType widthType) const +{ + Length w; + if (widthType == Width) + w = style()->width(); + else if (widthType == MinWidth) + w = style()->minWidth(); + else + w = style()->maxWidth(); + + switch (w.type()) { + case Fixed: + return w.value(); + case Percent: + { + const int cw = containingBlockWidth(); + if (cw > 0) { + int result = w.minWidth(cw); + return result; + } + } + // fall through + default: + return intrinsicWidth(); + } +} + +int RenderBox::calcReplacedHeight() const +{ + int height = calcReplacedHeightUsing(Height); + int minH = calcReplacedHeightUsing(MinHeight); + int maxH = style()->maxHeight().value() == UNDEFINED ? height : calcReplacedHeightUsing(MaxHeight); + + if (height > maxH) + height = maxH; + + if (height < minH) + height = minH; + + return height; +} + +int RenderBox::calcReplacedHeightUsing(HeightType heightType) const +{ + Length h; + if (heightType == Height) + h = style()->height(); + else if (heightType == MinHeight) + h = style()->minHeight(); + else + h = style()->maxHeight(); + switch( h.type() ) { + case Fixed: + return h.value(); + case Percent: + { + int th = calcPercentageHeight(h, true); + if (th != -1) + return th; + // fall through + } + default: + return intrinsicHeight(); + }; +} + +int RenderBox::availableHeight() const +{ + return availableHeightUsing(style()->height()); +} + +int RenderBox::availableHeightUsing(const Length& h) const +{ + if (h.isFixed()) + return calcContentHeight(h.value()); + + if (isCanvas()) + if (static_cast<const RenderCanvas*>(this)->pagedMode()) + return static_cast<const RenderCanvas*>(this)->pageHeight(); + else + return static_cast<const RenderCanvas*>(this)->viewportHeight(); + + // We need to stop here, since we don't want to increase the height of the table + // artificially. We're going to rely on this cell getting expanded to some new + // height, and then when we lay out again we'll use the calculation below. + if (isTableCell() && (h.isVariable() || h.isPercent())) { + const RenderTableCell* tableCell = static_cast<const RenderTableCell*>(this); + return tableCell->cellPercentageHeight() - + (borderTop()+borderBottom()+paddingTop()+paddingBottom()); + } + + if (h.isPercent()) + return calcContentHeight(h.width(containingBlock()->availableHeight())); + + // Check for implicit height + if (hasImplicitHeight()) + return calcImplicitHeight(); + + return containingBlock()->availableHeight(); +} + +int RenderBox::availableWidth() const +{ + return availableWidthUsing(style()->width()); +} + +int RenderBox::availableWidthUsing(const Length& w) const +{ + if (w.isFixed()) + return calcContentWidth(w.value()); + + if (isCanvas()) + return static_cast<const RenderCanvas*>(this)->viewportWidth(); + + if (w.isPercent()) + return calcContentWidth(w.width(containingBlock()->availableWidth())); + + return containingBlock()->availableWidth(); +} + +void RenderBox::calcVerticalMargins() +{ + if( isTableCell() ) { + // table margins are basically infinite + m_marginTop = TABLECELLMARGIN; + m_marginBottom = TABLECELLMARGIN; + return; + } + + Length tm = style()->marginTop(); + Length bm = style()->marginBottom(); + + // margins are calculated with respect to the _width_ of + // the containing block (8.3) + int cw = containingBlock()->contentWidth(); + + m_marginTop = tm.minWidth(cw); + m_marginBottom = bm.minWidth(cw); +} + +void RenderBox::setStaticX(short staticX) +{ + m_staticX = staticX; +} + +void RenderBox::setStaticY(int staticY) +{ + m_staticY = staticY; +} + +void RenderBox::calcAbsoluteHorizontal() +{ + if (isReplaced()) { + calcAbsoluteHorizontalReplaced(); + return; + } + + // QUESTIONS + // FIXME 1: Which RenderObject's 'direction' property should used: the + // containing block (cb) as the spec seems to imply, the parent (parent()) as + // was previously done in calculating the static distances, or ourself, which + // was also previously done for deciding what to override when you had + // over-constrained margins? Also note that the container block is used + // in similar situations in other parts of the RenderBox class (see calcWidth() + // and calcHorizontalMargins()). For now we are using the parent for quirks + // mode and the containing block for strict mode. + + // FIXME 2: Can perhaps optimize out cases when max-width/min-width are greater + // than or less than the computed m_width. Be careful of box-sizing and + // percentage issues. + + // The following is based off of the W3C Working Draft from April 11, 2006 of + // CSS 2.1: Section 10.3.7 "Absolutely positioned, non-replaced elements" + // <http://www.w3.org/TR/CSS21/visudet.html#abs-non-replaced-width> + // (block-style-comments in this function and in calcAbsoluteHorizontalValues() + // correspond to text from the spec) + + + // We don't use containingBlock(), since we may be positioned by an enclosing + // relative positioned inline. + const RenderObject* containerBlock = container(); + + // FIXME: This is incorrect for cases where the container block is a relatively + // positioned inline. + const int containerWidth = containingBlockWidth() + containerBlock->paddingLeft() + containerBlock->paddingRight(); + + // To match WinIE, in quirks mode use the parent's 'direction' property + // instead of the the container block's. + EDirection containerDirection = (style()->htmlHacks()) ? parent()->style()->direction() : containerBlock->style()->direction(); + + const int bordersPlusPadding = borderLeft() + borderRight() + paddingLeft() + paddingRight(); + const Length marginLeft = style()->marginLeft(); + const Length marginRight = style()->marginRight(); + Length left = style()->left(); + Length right = style()->right(); + + /*---------------------------------------------------------------------------*\ + * For the purposes of this section and the next, the term "static position" + * (of an element) refers, roughly, to the position an element would have had + * in the normal flow. More precisely: + * + * * The static position for 'left' is the distance from the left edge of the + * containing block to the left margin edge of a hypothetical box that would + * have been the first box of the element if its 'position' property had + * been 'static' and 'float' had been 'none'. The value is negative if the + * hypothetical box is to the left of the containing block. + * * The static position for 'right' is the distance from the right edge of the + * containing block to the right margin edge of the same hypothetical box as + * above. The value is positive if the hypothetical box is to the left of the + * containing block's edge. + * + * But rather than actually calculating the dimensions of that hypothetical box, + * user agents are free to make a guess at its probable position. + * + * For the purposes of calculating the static position, the containing block of + * fixed positioned elements is the initial containing block instead of the + * viewport, and all scrollable boxes should be assumed to be scrolled to their + * origin. + \*---------------------------------------------------------------------------*/ + + // Calculate the static distance if needed. + if (left.isVariable() && right.isVariable()) { + if (containerDirection == LTR) { + // 'm_staticX' should already have been set through layout of the parent. + int staticPosition = m_staticX - containerBlock->borderLeft(); + for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent()) + staticPosition += po->xPos(); + left = Length(staticPosition, Fixed); + } else { + RenderObject* po = parent(); + // 'm_staticX' should already have been set through layout of the parent. + int staticPosition = m_staticX + containerWidth + containerBlock->borderRight() - po->width(); + for (; po && po != containerBlock; po = po->parent()) + staticPosition -= po->xPos(); + right = Length(staticPosition, Fixed); + } + } + + // Calculate constraint equation values for 'width' case. + calcAbsoluteHorizontalValues(style()->width(), containerBlock, containerDirection, + containerWidth, bordersPlusPadding, + left, right, marginLeft, marginRight, + m_width, m_marginLeft, m_marginRight, m_x); + // Calculate constraint equation values for 'max-width' case.calcContentWidth(width.width(containerWidth)); + if (style()->maxWidth().value() != UNDEFINED) { + short maxWidth; + short maxMarginLeft; + short maxMarginRight; + short maxXPos; + + calcAbsoluteHorizontalValues(style()->maxWidth(), containerBlock, containerDirection, + containerWidth, bordersPlusPadding, + left, right, marginLeft, marginRight, + maxWidth, maxMarginLeft, maxMarginRight, maxXPos); + + if (m_width > maxWidth) { + m_width = maxWidth; + m_marginLeft = maxMarginLeft; + m_marginRight = maxMarginRight; + m_x = maxXPos; + } + } + + // Calculate constraint equation values for 'min-width' case. + if (style()->minWidth().value()) { + short minWidth; + short minMarginLeft; + short minMarginRight; + short minXPos; + + calcAbsoluteHorizontalValues(style()->minWidth(), containerBlock, containerDirection, + containerWidth, bordersPlusPadding, + left, right, marginLeft, marginRight, + minWidth, minMarginLeft, minMarginRight, minXPos); + + if (m_width < minWidth) { + m_width = minWidth; + m_marginLeft = minMarginLeft; + m_marginRight = minMarginRight; + m_x = minXPos; + } + } + + // Put m_width into correct form. + m_width += bordersPlusPadding; +} + +void RenderBox::calcAbsoluteHorizontalValues(Length width, const RenderObject* containerBlock, EDirection containerDirection, + const int containerWidth, const int bordersPlusPadding, + const Length left, const Length right, const Length marginLeft, const Length marginRight, + short& widthValue, short& marginLeftValue, short& marginRightValue, short& xPos) +{ + // 'left' and 'right' cannot both be 'auto' because one would of been + // converted to the static postion already + assert(!(left.isVariable() && right.isVariable())); + + int leftValue = 0; + + bool widthIsAuto = width.isVariable(); + bool leftIsAuto = left.isVariable(); + bool rightIsAuto = right.isVariable(); + + if (!leftIsAuto && !widthIsAuto && !rightIsAuto) { + /*-----------------------------------------------------------------------*\ + * If none of the three is 'auto': If both 'margin-left' and 'margin- + * right' are 'auto', solve the equation under the extra constraint that + * the two margins get equal values, unless this would make them negative, + * in which case when direction of the containing block is 'ltr' ('rtl'), + * set 'margin-left' ('margin-right') to zero and solve for 'margin-right' + * ('margin-left'). If one of 'margin-left' or 'margin-right' is 'auto', + * solve the equation for that value. If the values are over-constrained, + * ignore the value for 'left' (in case the 'direction' property of the + * containing block is 'rtl') or 'right' (in case 'direction' is 'ltr') + * and solve for that value. + \*-----------------------------------------------------------------------*/ + // NOTE: It is not necessary to solve for 'right' in the over constrained + // case because the value is not used for any further calculations. + + leftValue = left.width(containerWidth); + widthValue = calcContentWidth(width.width(containerWidth)); + + const int availableSpace = containerWidth - (leftValue + widthValue + right.width(containerWidth) + bordersPlusPadding); + + // Margins are now the only unknown + if (marginLeft.isVariable() && marginRight.isVariable()) { + // Both margins auto, solve for equality + if (availableSpace >= 0) { + marginLeftValue = availableSpace / 2; // split the diference + marginRightValue = availableSpace - marginLeftValue; // account for odd valued differences + } else { + // see FIXME 1 + if (containerDirection == LTR) { + marginLeftValue = 0; + marginRightValue = availableSpace; // will be negative + } else { + marginLeftValue = availableSpace; // will be negative + marginRightValue = 0; + } + } + } else if (marginLeft.isVariable()) { + // Solve for left margin + marginRightValue = marginRight.width(containerWidth); + marginLeftValue = availableSpace - marginRightValue; + } else if (marginRight.isVariable()) { + // Solve for right margin + marginLeftValue = marginLeft.width(containerWidth); + marginRightValue = availableSpace - marginLeftValue; + } else { + // Over-constrained, solve for left if direction is RTL + marginLeftValue = marginLeft.width(containerWidth); + marginRightValue = marginRight.width(containerWidth); + + // see FIXME 1 -- used to be "this->style()->direction()" + if (containerDirection == RTL) + leftValue = (availableSpace + leftValue) - marginLeftValue - marginRightValue; + } + } else { + /*--------------------------------------------------------------------*\ + * Otherwise, set 'auto' values for 'margin-left' and 'margin-right' + * to 0, and pick the one of the following six rules that applies. + * + * 1. 'left' and 'width' are 'auto' and 'right' is not 'auto', then the + * width is shrink-to-fit. Then solve for 'left' + * + * OMIT RULE 2 AS IT SHOULD NEVER BE HIT + * ------------------------------------------------------------------ + * 2. 'left' and 'right' are 'auto' and 'width' is not 'auto', then if + * the 'direction' property of the containing block is 'ltr' set + * 'left' to the static position, otherwise set 'right' to the + * static position. Then solve for 'left' (if 'direction is 'rtl') + * or 'right' (if 'direction' is 'ltr'). + * ------------------------------------------------------------------ + * + * 3. 'width' and 'right' are 'auto' and 'left' is not 'auto', then the + * width is shrink-to-fit . Then solve for 'right' + * 4. 'left' is 'auto', 'width' and 'right' are not 'auto', then solve + * for 'left' + * 5. 'width' is 'auto', 'left' and 'right' are not 'auto', then solve + * for 'width' + * 6. 'right' is 'auto', 'left' and 'width' are not 'auto', then solve + * for 'right' + * + * Calculation of the shrink-to-fit width is similar to calculating the + * width of a table cell using the automatic table layout algorithm. + * Roughly: calculate the preferred width by formatting the content + * without breaking lines other than where explicit line breaks occur, + * and also calculate the preferred minimum width, e.g., by trying all + * possible line breaks. CSS 2.1 does not define the exact algorithm. + * Thirdly, calculate the available width: this is found by solving + * for 'width' after setting 'left' (in case 1) or 'right' (in case 3) + * to 0. + * + * Then the shrink-to-fit width is: + * kMin(kMax(preferred minimum width, available width), preferred width). + \*--------------------------------------------------------------------*/ + // NOTE: For rules 3 and 6 it is not necessary to solve for 'right' + // because the value is not used for any further calculations. + + // Calculate margins, 'auto' margins are ignored. + marginLeftValue = marginLeft.minWidth(containerWidth); + marginRightValue = marginRight.minWidth(containerWidth); + + const int availableSpace = containerWidth - (marginLeftValue + marginRightValue + bordersPlusPadding); + + // FIXME: Is there a faster way to find the correct case? + // Use rule/case that applies. + if (leftIsAuto && widthIsAuto && !rightIsAuto) { + // RULE 1: (use shrink-to-fit for width, and solve of left) + int rightValue = right.width(containerWidth); + + // FIXME: would it be better to have shrink-to-fit in one step? + int preferredWidth = m_maxWidth - bordersPlusPadding; + int preferredMinWidth = m_minWidth - bordersPlusPadding; + int availableWidth = availableSpace - rightValue; + widthValue = kMin(kMax(preferredMinWidth, availableWidth), preferredWidth); + leftValue = availableSpace - (widthValue + rightValue); + } else if (!leftIsAuto && widthIsAuto && rightIsAuto) { + // RULE 3: (use shrink-to-fit for width, and no need solve of right) + leftValue = left.width(containerWidth); + + // FIXME: would it be better to have shrink-to-fit in one step? + int preferredWidth = m_maxWidth - bordersPlusPadding; + int preferredMinWidth = m_minWidth - bordersPlusPadding; + int availableWidth = availableSpace - leftValue; + widthValue = kMin(kMax(preferredMinWidth, availableWidth), preferredWidth); + } else if (leftIsAuto && !width.isVariable() && !rightIsAuto) { + // RULE 4: (solve for left) + widthValue = calcContentWidth(width.width(containerWidth)); + leftValue = availableSpace - (widthValue + right.width(containerWidth)); + } else if (!leftIsAuto && widthIsAuto && !rightIsAuto) { + // RULE 5: (solve for width) + leftValue = left.width(containerWidth); + widthValue = availableSpace - (leftValue + right.width(containerWidth)); + } else if (!leftIsAuto&& !widthIsAuto && rightIsAuto) { + // RULE 6: (no need solve for right) + leftValue = left.width(containerWidth); + widthValue = calcContentWidth(width.width(containerWidth)); + } + } + + // Use computed values to calculate the horizontal position. + xPos = leftValue + marginLeftValue + containerBlock->borderLeft(); +} + + +void RenderBox::calcAbsoluteVertical() +{ + if (isReplaced()) { + calcAbsoluteVerticalReplaced(); + return; + } + + // The following is based off of the W3C Working Draft from April 11, 2006 of + // CSS 2.1: Section 10.6.4 "Absolutely positioned, non-replaced elements" + // <http://www.w3.org/TR/2005/WD-CSS21-20050613/visudet.html#abs-non-replaced-height> + // (block-style-comments in this function and in calcAbsoluteVerticalValues() + // correspond to text from the spec) + + + // We don't use containingBlock(), since we may be positioned by an enclosing relpositioned inline. + const RenderObject* containerBlock = container(); + const int containerHeight = containerBlock->height() - containerBlock->borderTop() - containerBlock->borderBottom(); + + const int bordersPlusPadding = borderTop() + borderBottom() + paddingTop() + paddingBottom(); + const Length marginTop = style()->marginTop(); + const Length marginBottom = style()->marginBottom(); + Length top = style()->top(); + Length bottom = style()->bottom(); + + /*---------------------------------------------------------------------------*\ + * For the purposes of this section and the next, the term "static position" + * (of an element) refers, roughly, to the position an element would have had + * in the normal flow. More precisely, the static position for 'top' is the + * distance from the top edge of the containing block to the top margin edge + * of a hypothetical box that would have been the first box of the element if + * its 'position' property had been 'static' and 'float' had been 'none'. The + * value is negative if the hypothetical box is above the containing block. + * + * But rather than actually calculating the dimensions of that hypothetical + * box, user agents are free to make a guess at its probable position. + * + * For the purposes of calculating the static position, the containing block + * of fixed positioned elements is the initial containing block instead of + * the viewport. + \*---------------------------------------------------------------------------*/ + + // Calculate the static distance if needed. + if (top.isVariable() && bottom.isVariable()) { + // m_staticY should already have been set through layout of the parent() + int staticTop = m_staticY - containerBlock->borderTop(); + for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent()) { + staticTop += po->yPos(); + } + top.setValue(Fixed, staticTop); + } + + + int height; // Needed to compute overflow. + + // Calculate constraint equation values for 'height' case. + calcAbsoluteVerticalValues(style()->height(), containerBlock, containerHeight, bordersPlusPadding, + top, bottom, marginTop, marginBottom, + height, m_marginTop, m_marginBottom, m_y); + + // Avoid doing any work in the common case (where the values of min-height and max-height are their defaults). + // see FIXME 2 + + // Calculate constraint equation values for 'max-height' case. + if (style()->maxHeight().value() != UNDEFINED) { + int maxHeight; + short maxMarginTop; + short maxMarginBottom; + int maxYPos; + + calcAbsoluteVerticalValues(style()->maxHeight(), containerBlock, containerHeight, bordersPlusPadding, + top, bottom, marginTop, marginBottom, + maxHeight, maxMarginTop, maxMarginBottom, maxYPos); + + if (height > maxHeight) { + height = maxHeight; + m_marginTop = maxMarginTop; + m_marginBottom = maxMarginBottom; + m_y = maxYPos; + } + } + + // Calculate constraint equation values for 'min-height' case. + if (style()->minHeight().value()) { + int minHeight; + short minMarginTop; + short minMarginBottom; + int minYPos; + + calcAbsoluteVerticalValues(style()->minHeight(), containerBlock, containerHeight, bordersPlusPadding, + top, bottom, marginTop, marginBottom, + minHeight, minMarginTop, minMarginBottom, minYPos); + + if (height < minHeight) { + height = minHeight; + m_marginTop = minMarginTop; + m_marginBottom = minMarginBottom; + m_y = minYPos; + } + } + + height += bordersPlusPadding; + + // Set final height value. + m_height = height; +} + +void RenderBox::calcAbsoluteVerticalValues(Length height, const RenderObject* containerBlock, + const int containerHeight, const int bordersPlusPadding, + const Length top, const Length bottom, const Length marginTop, const Length marginBottom, + int& heightValue, short& marginTopValue, short& marginBottomValue, int& yPos) +{ + // 'top' and 'bottom' cannot both be 'auto' because 'top would of been + // converted to the static position in calcAbsoluteVertical() + assert(!(top.isVariable() && bottom.isVariable())); + + int contentHeight = m_height - bordersPlusPadding; + + int topValue = 0; + + bool heightIsAuto = height.isVariable(); + bool topIsAuto = top.isVariable(); + bool bottomIsAuto = bottom.isVariable(); + + if (isTable() && heightIsAuto) { + // Height is never unsolved for tables. "auto" means shrink to fit. + // Use our height instead. + heightValue = contentHeight; + heightIsAuto = false; + } else if (!heightIsAuto) { + heightValue = calcContentHeight(height.width(containerHeight)); + if (contentHeight > heightValue) { + if (!isTable()) + contentHeight = heightValue; + else + heightValue = contentHeight; + } + } + + + if (!topIsAuto && !heightIsAuto && !bottomIsAuto) { + /*-----------------------------------------------------------------------*\ + * If none of the three are 'auto': If both 'margin-top' and 'margin- + * bottom' are 'auto', solve the equation under the extra constraint that + * the two margins get equal values. If one of 'margin-top' or 'margin- + * bottom' is 'auto', solve the equation for that value. If the values + * are over-constrained, ignore the value for 'bottom' and solve for that + * value. + \*-----------------------------------------------------------------------*/ + // NOTE: It is not necessary to solve for 'bottom' in the over constrained + // case because the value is not used for any further calculations. + + topValue = top.width(containerHeight); + + const int availableSpace = containerHeight - (topValue + heightValue + bottom.width(containerHeight) + bordersPlusPadding); + + // Margins are now the only unknown + if (marginTop.isVariable() && marginBottom.isVariable()) { + // Both margins auto, solve for equality + // NOTE: This may result in negative values. + marginTopValue = availableSpace / 2; // split the diference + marginBottomValue = availableSpace - marginTopValue; // account for odd valued differences + } else if (marginTop.isVariable()) { + // Solve for top margin + marginBottomValue = marginBottom.width(containerHeight); + marginTopValue = availableSpace - marginBottomValue; + } else if (marginBottom.isVariable()) { + // Solve for bottom margin + marginTopValue = marginTop.width(containerHeight); + marginBottomValue = availableSpace - marginTopValue; + } else { + // Over-constrained, (no need solve for bottom) + marginTopValue = marginTop.width(containerHeight); + marginBottomValue = marginBottom.width(containerHeight); + } + } else { + /*--------------------------------------------------------------------*\ + * Otherwise, set 'auto' values for 'margin-top' and 'margin-bottom' + * to 0, and pick the one of the following six rules that applies. + * + * 1. 'top' and 'height' are 'auto' and 'bottom' is not 'auto', then + * the height is based on the content, and solve for 'top'. + * + * OMIT RULE 2 AS IT SHOULD NEVER BE HIT + * ------------------------------------------------------------------ + * 2. 'top' and 'bottom' are 'auto' and 'height' is not 'auto', then + * set 'top' to the static position, and solve for 'bottom'. + * ------------------------------------------------------------------ + * + * 3. 'height' and 'bottom' are 'auto' and 'top' is not 'auto', then + * the height is based on the content, and solve for 'bottom'. + * 4. 'top' is 'auto', 'height' and 'bottom' are not 'auto', and + * solve for 'top'. + * 5. 'height' is 'auto', 'top' and 'bottom' are not 'auto', and + * solve for 'height'. + * 6. 'bottom' is 'auto', 'top' and 'height' are not 'auto', and + * solve for 'bottom'. + \*--------------------------------------------------------------------*/ + // NOTE: For rules 3 and 6 it is not necessary to solve for 'bottom' + // because the value is not used for any further calculations. + + // Calculate margins, 'auto' margins are ignored. + marginTopValue = marginTop.minWidth(containerHeight); + marginBottomValue = marginBottom.minWidth(containerHeight); + + const int availableSpace = containerHeight - (marginTopValue + marginBottomValue + bordersPlusPadding); + + // Use rule/case that applies. + if (topIsAuto && heightIsAuto && !bottomIsAuto) { + // RULE 1: (height is content based, solve of top) + heightValue = contentHeight; + topValue = availableSpace - (heightValue + bottom.width(containerHeight)); + } + else if (topIsAuto && !heightIsAuto && bottomIsAuto) { + // RULE 2: (shouldn't happen) + } + else if (!topIsAuto && heightIsAuto && bottomIsAuto) { + // RULE 3: (height is content based, no need solve of bottom) + heightValue = contentHeight; + topValue = top.width(containerHeight); + } else if (topIsAuto && !heightIsAuto && !bottomIsAuto) { + // RULE 4: (solve of top) + topValue = availableSpace - (heightValue + bottom.width(containerHeight)); + } else if (!topIsAuto && heightIsAuto && !bottomIsAuto) { + // RULE 5: (solve of height) + topValue = top.width(containerHeight); + heightValue = kMax(0, availableSpace - (topValue + bottom.width(containerHeight))); + } else if (!topIsAuto && !heightIsAuto && bottomIsAuto) { + // RULE 6: (no need solve of bottom) + topValue = top.width(containerHeight); + } + } + + // Use computed values to calculate the vertical position. + yPos = topValue + marginTopValue + containerBlock->borderTop(); +} + +void RenderBox::calcAbsoluteHorizontalReplaced() +{ + // The following is based off of the W3C Working Draft from April 11, 2006 of + // CSS 2.1: Section 10.3.8 "Absolutly positioned, replaced elements" + // <http://www.w3.org/TR/2005/WD-CSS21-20050613/visudet.html#abs-replaced-width> + // (block-style-comments in this function correspond to text from the spec and + // the numbers correspond to numbers in spec) + + // We don't use containingBlock(), since we may be positioned by an enclosing relpositioned inline. + const RenderObject* containerBlock = container(); + + // FIXME: This is incorrect for cases where the container block is a relatively + // positioned inline. + const int containerWidth = containingBlockWidth() + containerBlock->paddingLeft() + containerBlock->paddingRight(); + + // To match WinIE, in quirks mode use the parent's 'direction' property + // instead of the the container block's. + EDirection containerDirection = (style()->htmlHacks()) ? parent()->style()->direction() : containerBlock->style()->direction(); + + // Variables to solve. + Length left = style()->left(); + Length right = style()->right(); + Length marginLeft = style()->marginLeft(); + Length marginRight = style()->marginRight(); + + + /*-----------------------------------------------------------------------*\ + * 1. The used value of 'width' is determined as for inline replaced + * elements. + \*-----------------------------------------------------------------------*/ + // NOTE: This value of width is FINAL in that the min/max width calculations + // are dealt with in calcReplacedWidth(). This means that the steps to produce + // correct max/min in the non-replaced version, are not necessary. + m_width = calcReplacedWidth() + borderLeft() + borderRight() + paddingLeft() + paddingRight(); + const int availableSpace = containerWidth - m_width; + + /*-----------------------------------------------------------------------*\ + * 2. If both 'left' and 'right' have the value 'auto', then if 'direction' + * of the containing block is 'ltr', set 'left' to the static position; + * else if 'direction' is 'rtl', set 'right' to the static position. + \*-----------------------------------------------------------------------*/ + if (left.isVariable() && right.isVariable()) { + // see FIXME 1 + if (containerDirection == LTR) { + // 'm_staticX' should already have been set through layout of the parent. + int staticPosition = m_staticX - containerBlock->borderLeft(); + for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent()) + staticPosition += po->xPos(); + left.setValue(Fixed, staticPosition); + } else { + RenderObject* po = parent(); + // 'm_staticX' should already have been set through layout of the parent. + int staticPosition = m_staticX + containerWidth + containerBlock->borderRight() - po->width(); + for (; po && po != containerBlock; po = po->parent()) + staticPosition -= po->xPos(); + right.setValue(Fixed, staticPosition); + } + } + + /*-----------------------------------------------------------------------*\ + * 3. If 'left' or 'right' are 'auto', replace any 'auto' on 'margin-left' + * or 'margin-right' with '0'. + \*-----------------------------------------------------------------------*/ + if (left.isVariable() || right.isVariable()) { + if (marginLeft.isVariable()) + marginLeft.setValue(Fixed, 0); + if (marginRight.isVariable()) + marginRight.setValue(Fixed, 0); + } + + /*-----------------------------------------------------------------------*\ + * 4. If at this point both 'margin-left' and 'margin-right' are still + * 'auto', solve the equation under the extra constraint that the two + * margins must get equal values, unless this would make them negative, + * in which case when the direction of the containing block is 'ltr' + * ('rtl'), set 'margin-left' ('margin-right') to zero and solve for + * 'margin-right' ('margin-left'). + \*-----------------------------------------------------------------------*/ + int leftValue = 0; + int rightValue = 0; + + if (marginLeft.isVariable() && marginRight.isVariable()) { + // 'left' and 'right' cannot be 'auto' due to step 3 + assert(!(left.isVariable() && right.isVariable())); + + leftValue = left.width(containerWidth); + rightValue = right.width(containerWidth); + + int difference = availableSpace - (leftValue + rightValue); + if (difference > 0) { + m_marginLeft = difference / 2; // split the diference + m_marginRight = difference - m_marginLeft; // account for odd valued differences + } else { + // see FIXME 1 + if (containerDirection == LTR) { + m_marginLeft = 0; + m_marginRight = difference; // will be negative + } else { + m_marginLeft = difference; // will be negative + m_marginRight = 0; + } + } + + /*-----------------------------------------------------------------------*\ + * 5. If at this point there is an 'auto' left, solve the equation for + * that value. + \*-----------------------------------------------------------------------*/ + } else if (left.isVariable()) { + m_marginLeft = marginLeft.width(containerWidth); + m_marginRight = marginRight.width(containerWidth); + rightValue = right.width(containerWidth); + + // Solve for 'left' + leftValue = availableSpace - (rightValue + m_marginLeft + m_marginRight); + } else if (right.isVariable()) { + m_marginLeft = marginLeft.width(containerWidth); + m_marginRight = marginRight.width(containerWidth); + leftValue = left.width(containerWidth); + + // Solve for 'right' + rightValue = availableSpace - (leftValue + m_marginLeft + m_marginRight); + } else if (marginLeft.isVariable()) { + m_marginRight = marginRight.width(containerWidth); + leftValue = left.width(containerWidth); + rightValue = right.width(containerWidth); + + // Solve for 'margin-left' + m_marginLeft = availableSpace - (leftValue + rightValue + m_marginRight); + } else if (marginRight.isVariable()) { + m_marginLeft = marginLeft.width(containerWidth); + leftValue = left.width(containerWidth); + rightValue = right.width(containerWidth); + + // Solve for 'margin-right' + m_marginRight = availableSpace - (leftValue + rightValue + m_marginLeft); + } + + /*-----------------------------------------------------------------------*\ + * 6. If at this point the values are over-constrained, ignore the value + * for either 'left' (in case the 'direction' property of the + * containing block is 'rtl') or 'right' (in case 'direction' is + * 'ltr') and solve for that value. + \*-----------------------------------------------------------------------*/ + else { + m_marginLeft = marginLeft.width(containerWidth); + m_marginRight = marginRight.width(containerWidth); + if (containerDirection == LTR) { + leftValue = left.width(containerWidth); + rightValue = availableSpace - (leftValue + m_marginLeft + m_marginRight); + } + else { + rightValue = right.width(containerWidth); + leftValue = availableSpace - (rightValue + m_marginLeft + m_marginRight); + } + } + + int totalWidth = m_width + leftValue + rightValue + m_marginLeft + m_marginRight; + if (totalWidth > containerWidth && (containerDirection == RTL)) + leftValue = containerWidth - (totalWidth - leftValue); + + // Use computed values to calculate the horizontal position. + m_x = leftValue + m_marginLeft + containerBlock->borderLeft(); +} + +void RenderBox::calcAbsoluteVerticalReplaced() +{ + // The following is based off of the W3C Working Draft from April 11, 2006 of + // CSS 2.1: Section 10.6.5 "Absolutly positioned, replaced elements" + // <http://www.w3.org/TR/2005/WD-CSS21-20050613/visudet.html#abs-replaced-height> + // (block-style-comments in this function correspond to text from the spec and + // the numbers correspond to numbers in spec) + + // We don't use containingBlock(), since we may be positioned by an enclosing relpositioned inline. + const RenderObject* containerBlock = container(); + const int containerHeight = containerBlock->height() - containerBlock->borderTop() - containerBlock->borderBottom(); + + // Variables to solve. + Length top = style()->top(); + Length bottom = style()->bottom(); + Length marginTop = style()->marginTop(); + Length marginBottom = style()->marginBottom(); + + + /*-----------------------------------------------------------------------*\ + * 1. The used value of 'height' is determined as for inline replaced + * elements. + \*-----------------------------------------------------------------------*/ + // NOTE: This value of height is FINAL in that the min/max height calculations + // are dealt with in calcReplacedHeight(). This means that the steps to produce + // correct max/min in the non-replaced version, are not necessary. + m_height = calcReplacedHeight() + borderTop() + borderBottom() + paddingTop() + paddingBottom(); + const int availableSpace = containerHeight - m_height; + + /*-----------------------------------------------------------------------*\ + * 2. If both 'top' and 'bottom' have the value 'auto', replace 'top' + * with the element's static position. + \*-----------------------------------------------------------------------*/ + if (top.isVariable() && bottom.isVariable()) { + // m_staticY should already have been set through layout of the parent(). + int staticTop = m_staticY - containerBlock->borderTop(); + for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent()) { + staticTop += po->yPos(); + } + top.setValue(Fixed, staticTop); + } + + /*-----------------------------------------------------------------------*\ + * 3. If 'bottom' is 'auto', replace any 'auto' on 'margin-top' or + * 'margin-bottom' with '0'. + \*-----------------------------------------------------------------------*/ + // FIXME: The spec. says that this step should only be taken when bottom is + // auto, but if only top is auto, this makes step 4 impossible. + if (top.isVariable() || bottom.isVariable()) { + if (marginTop.isVariable()) + marginTop.setValue(Fixed, 0); + if (marginBottom.isVariable()) + marginBottom.setValue(Fixed, 0); + } + + /*-----------------------------------------------------------------------*\ + * 4. If at this point both 'margin-top' and 'margin-bottom' are still + * 'auto', solve the equation under the extra constraint that the two + * margins must get equal values. + \*-----------------------------------------------------------------------*/ + int topValue = 0; + int bottomValue = 0; + + if (marginTop.isVariable() && marginBottom.isVariable()) { + // 'top' and 'bottom' cannot be 'auto' due to step 2 and 3 combinded. + assert(!(top.isVariable() || bottom.isVariable())); + + topValue = top.width(containerHeight); + bottomValue = bottom.width(containerHeight); + + int difference = availableSpace - (topValue + bottomValue); + // NOTE: This may result in negative values. + m_marginTop = difference / 2; // split the difference + m_marginBottom = difference - m_marginTop; // account for odd valued differences + + /*-----------------------------------------------------------------------*\ + * 5. If at this point there is only one 'auto' left, solve the equation + * for that value. + \*-----------------------------------------------------------------------*/ + } else if (top.isVariable()) { + m_marginTop = marginTop.width(containerHeight); + m_marginBottom = marginBottom.width(containerHeight); + bottomValue = bottom.width(containerHeight); + + // Solve for 'top' + topValue = availableSpace - (bottomValue + m_marginTop + m_marginBottom); + } else if (bottom.isVariable()) { + m_marginTop = marginTop.width(containerHeight); + m_marginBottom = marginBottom.width(containerHeight); + topValue = top.width(containerHeight); + + // Solve for 'bottom' + // NOTE: It is not necessary to solve for 'bottom' because we don't ever + // use the value. + } else if (marginTop.isVariable()) { + m_marginBottom = marginBottom.width(containerHeight); + topValue = top.width(containerHeight); + bottomValue = bottom.width(containerHeight); + + // Solve for 'margin-top' + m_marginTop = availableSpace - (topValue + bottomValue + m_marginBottom); + } else if (marginBottom.isVariable()) { + m_marginTop = marginTop.width(containerHeight); + topValue = top.width(containerHeight); + bottomValue = bottom.width(containerHeight); + + // Solve for 'margin-bottom' + m_marginBottom = availableSpace - (topValue + bottomValue + m_marginTop); + } + + /*-----------------------------------------------------------------------*\ + * 6. If at this point the values are over-constrained, ignore the value + * for 'bottom' and solve for that value. + \*-----------------------------------------------------------------------*/ + else { + m_marginTop = marginTop.width(containerHeight); + m_marginBottom = marginBottom.width(containerHeight); + topValue = top.width(containerHeight); + + // Solve for 'bottom' + // NOTE: It is not necessary to solve for 'bottom' because we don't ever + // use the value. + } + + // Use computed values to calculate the vertical position. + m_y = topValue + m_marginTop + containerBlock->borderTop(); +} + +int RenderBox::highestPosition(bool /*includeOverflowInterior*/, bool includeSelf) const +{ + return includeSelf ? 0 : m_height; +} + +int RenderBox::lowestPosition(bool /*includeOverflowInterior*/, bool includeSelf) const +{ + return includeSelf ? m_height : 0; +} + +int RenderBox::rightmostPosition(bool /*includeOverflowInterior*/, bool includeSelf) const +{ + return includeSelf ? m_width : 0; +} + +int RenderBox::leftmostPosition(bool /*includeOverflowInterior*/, bool includeSelf) const +{ + return includeSelf ? 0 : m_width; +} + +int RenderBox::pageTopAfter(int y) const +{ + RenderObject* cb = container(); + if (cb) + return cb->pageTopAfter(y+yPos()) - yPos(); + else + return 0; +} + +int RenderBox::crossesPageBreak(int t, int b) const +{ + RenderObject* cb = container(); + if (cb) + return cb->crossesPageBreak(yPos()+t, yPos()+b); + else + return false; +} + +void RenderBox::caretPos(int /*offset*/, int flags, int &_x, int &_y, int &width, int &height) +{ +#if 0 + _x = -1; + + // propagate it downwards to its children, someone will feel responsible + RenderObject *child = firstChild(); +// if (child) kdDebug(6040) << "delegating caretPos to " << child->renderName() << endl; + if (child) child->caretPos(offset, override, _x, _y, width, height); + + // if not, use the extents of this box. offset 0 means left, offset 1 means + // right + if (_x == -1) { + //kdDebug(6040) << "no delegation" << endl; + _x = xPos() + (offset == 0 ? 0 : m_width); + _y = yPos(); + height = m_height; + width = override && offset == 0 ? m_width : 1; + + // If height of box is smaller than font height, use the latter one, + // otherwise the caret might become invisible. + // FIXME: ignoring :first-line, missing good reason to take care of + int fontHeight = style()->fontMetrics().height(); + if (fontHeight > height) + height = fontHeight; + + int absx, absy; + + RenderObject *cb = containingBlock(); + + if (cb && cb != this && cb->absolutePosition(absx,absy)) { + //kdDebug(6040) << "absx=" << absx << " absy=" << absy << endl; + _x += absx; + _y += absy; + } else { + // we don't know our absolute position, and there is no point returning + // just a relative one + _x = _y = -1; + } + } +#endif + + _x = xPos(); + _y = yPos(); +// kdDebug(6040) << "_x " << _x << " _y " << _y << endl; + width = 1; // no override is indicated in boxes + + RenderBlock *cb = containingBlock(); + + // Place caret outside the border + if (flags & CFOutside) { + + RenderStyle *s = element() && element()->parent() + && element()->parent()->renderer() + ? element()->parent()->renderer()->style() + : cb->style(); + + const TQFontMetrics &fm = s->fontMetrics(); + height = fm.height(); + + bool rtl = s->direction() == RTL; + bool outsideEnd = flags & CFOutsideEnd; + + if (outsideEnd) { + _x += this->width(); + } else { + _x--; + } + + int hl = fm.leading() / 2; + if (!isReplaced() || style()->display() == BLOCK) { + if (!outsideEnd ^ rtl) + _y -= hl; + else + _y += kMax(this->height() - fm.ascent() - hl, 0); + } else { + _y += baselinePosition(false) - fm.ascent() - hl; + } + + // Place caret inside the element + } else { + const TQFontMetrics &fm = style()->fontMetrics(); + height = fm.height(); + + RenderStyle *s = style(); + + _x += borderLeft() + paddingLeft(); + _y += borderTop() + paddingTop(); + + // ### regard direction + switch (s->textAlign()) { + case LEFT: + case KHTML_LEFT: + case TAAUTO: // ### find out what this does + case JUSTIFY: + break; + case CENTER: + case KHTML_CENTER: + _x += contentWidth() / 2; + break; + case KHTML_RIGHT: + case RIGHT: + _x += contentWidth(); + break; + } + } + + int absx, absy; + if (cb && cb != this && cb->absolutePosition(absx,absy)) { +// kdDebug(6040) << "absx=" << absx << " absy=" << absy << endl; + _x += absx; + _y += absy; + } else { + // we don't know our absolute position, and there is no point returning + // just a relative one + _x = _y = -1; + } +} + +#undef DEBUG_LAYOUT diff --git a/tdehtml/rendering/render_box.h b/tdehtml/rendering/render_box.h new file mode 100644 index 000000000..0a65df72e --- /dev/null +++ b/tdehtml/rendering/render_box.h @@ -0,0 +1,213 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2002-2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_BOX_H +#define RENDER_BOX_H + +#include "render_container.h" + +namespace tdehtml { + +enum WidthType { Width, MinWidth, MaxWidth }; +enum HeightType { Height, MinHeight, MaxHeight }; + +class RenderBlock; + +class RenderBox : public RenderContainer +{ + + +// combines ElemImpl & PosElImpl (all rendering objects are positioned) +// should contain all border and padding handling + +public: + RenderBox(DOM::NodeImpl* node); + virtual ~RenderBox(); + + virtual const char *renderName() const { return "RenderBox"; } + virtual bool isBox() const { return true; } + + virtual void setStyle(RenderStyle *style); + virtual void paint(PaintInfo& i, int _tx, int _ty); + + virtual void close(); + + virtual InlineBox* createInlineBox(bool makePlaceHolderBox, bool isRootLineBox); + virtual void deleteInlineBoxes(RenderArena* arena=0); + + virtual void detach(); + + virtual short minWidth() const { return m_minWidth; } + virtual int maxWidth() const { return m_maxWidth; } + + virtual short contentWidth() const; + virtual int contentHeight() const; + + virtual bool absolutePosition(int &xPos, int &yPos, bool f = false) const; + + virtual void setPos( int xPos, int yPos ); + + virtual int xPos() const { return m_x; } + virtual int yPos() const { return m_y; } + virtual short width() const; + virtual int height() const; + + virtual short marginTop() const { return m_marginTop; } + virtual short marginBottom() const { return m_marginBottom; } + virtual short marginLeft() const { return m_marginLeft; } + virtual short marginRight() const { return m_marginRight; } + + virtual void setWidth( int width ); + virtual void setHeight( int height ); + + virtual void position(InlineBox* box, int from, int len, bool reverse); + + virtual int highestPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int lowestPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int rightmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int leftmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + + virtual void repaint(Priority p=NormalPriority); + + virtual void repaintRectangle(int x, int y, int w, int h, Priority p=NormalPriority, bool f=false); + + virtual short containingBlockWidth() const; + void relativePositionOffset(int &tx, int &ty) const; + + virtual void calcWidth(); + virtual void calcHeight(); + + virtual short calcReplacedWidth() const; + virtual int calcReplacedHeight() const; + + virtual int availableHeight() const; + virtual int availableWidth() const; + + void calcVerticalMargins(); + + virtual RenderLayer* layer() const { return m_layer; } + + void setStaticX(short staticX); + void setStaticY(int staticY); + int staticX() const { return m_staticX; } + int staticY() const { return m_staticY; } + + virtual void caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height); + + void calcHorizontalMargins(const Length& ml, const Length& mr, int cw); + RenderBlock* createAnonymousBlock(); + + virtual int pageTopAfter(int y) const; + virtual int crossesPageBreak(int t, int b) const; + + int calcBoxWidth(int w) const; + int calcBoxHeight(int h) const; + int calcContentWidth(int w) const; + int calcContentHeight(int h) const; + +protected: + int calcWidthUsing(WidthType widthType, int cw, LengthType& lengthType); + int calcHeightUsing(const Length& height); + int calcReplacedWidthUsing(WidthType widthType) const; + int calcReplacedHeightUsing(HeightType heightType) const; + int calcPercentageHeight(const Length& height, bool treatAsReplaced = false) const; + int availableHeightUsing(const Length& h) const; + int availableWidthUsing(const Length& w) const; + int calcImplicitHeight() const; + bool hasImplicitHeight() const { + return isPositioned() && !style()->top().isVariable() && !style()->bottom().isVariable(); + } + +protected: + virtual void paintBoxDecorations(PaintInfo& paintInfo, int _tx, int _ty); + void paintRootBoxDecorations( PaintInfo& paintInfo, int _tx, int _ty); + + void paintBackgrounds(TQPainter *p, const TQColor& c, const BackgroundLayer* bgLayer, int clipy, int cliph, int _tx, int _ty, int w, int h); + void paintBackground(TQPainter *p, const TQColor& c, const BackgroundLayer* bgLayer, int clipy, int cliph, int _tx, int _ty, int w, int h); + + virtual void paintBackgroundExtended(TQPainter* /*p*/, const TQColor& /*c*/, const BackgroundLayer* /*bgLayer*/, + int /*clipy*/, int /*cliph*/, int /*_tx*/, int /*_ty*/, + int /*w*/, int /*height*/, int /*bleft*/, int /*bright*/, int /*pleft*/, int /*pright*/ ); + + void outlineBox(TQPainter *p, int _tx, int _ty, const char *color = "red"); + + void calcAbsoluteHorizontal(); + void calcAbsoluteVertical(); + void calcAbsoluteHorizontalValues(Length width, const RenderObject* cb, EDirection containerDirection, + const int containerWidth, const int bordersPlusPadding, + const Length left, const Length right, const Length marginLeft, const Length marginRight, + short& widthValue, short& marginLeftValue, short& marginRightValue, short& xPos); + void calcAbsoluteVerticalValues(Length height, const RenderObject* cb, + const int containerHeight, const int bordersPlusPadding, + const Length top, const Length bottom, const Length marginTop, const Length marginBottom, + int& heightValue, short& marginTopValue, short& marginBottomValue, int& yPos); + + void calcAbsoluteVerticalReplaced(); + void calcAbsoluteHorizontalReplaced(); + + TQRect getOverflowClipRect(int tx, int ty); + TQRect getClipRect(int tx, int ty); + + void restructureParentFlow(); + + + // the actual height of the contents + borders + padding (border-box) + int m_height; + int m_y; + + short m_width; + short m_x; + + short m_marginTop; + short m_marginBottom; + + short m_marginLeft; + short m_marginRight; + + /* + * the minimum width the element needs, to be able to render + * its content without clipping + */ + short m_minWidth; + /* The maximum width the element can fill horizontally + * ( = the width of the element with line breaking disabled) + */ + int m_maxWidth; + + // Cached normal flow values for absolute positioned elements with static left/top values. + short m_staticX; + int m_staticY; + + RenderLayer *m_layer; + + /* A box used to represent this object on a line + * when its inner content isn't contextually relevant + * (e.g replaced or positioned elements) + */ + InlineBox *m_placeHolderBox; +}; + + +} //namespace + +#endif diff --git a/tdehtml/rendering/render_br.cpp b/tdehtml/rendering/render_br.cpp new file mode 100644 index 000000000..f330e5f17 --- /dev/null +++ b/tdehtml/rendering/render_br.cpp @@ -0,0 +1,79 @@ +/** + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 2000 Lars Knoll (knoll@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#include "render_br.h" + +using namespace tdehtml; + + +RenderBR::RenderBR(DOM::NodeImpl* node) + : RenderText(node, new DOM::DOMStringImpl(TQChar('\n'))) +{ + m_hasReturn = true; +} + +RenderBR::~RenderBR() +{ +} + +#if 0 +void RenderBR::caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height) +{ + RenderText::caretPos(offset,flags,_x,_y,width,height); + return; +#if 0 + if (previousSibling() && !previousSibling()->isBR() && !previousSibling()->isFloating()) { + int offset = 0; + if (previousSibling()->isText()) + offset = static_cast<RenderText*>(previousSibling())->maxOffset(); + + // FIXME: this won't return a big width in override mode (LS) + previousSibling()->caretPos(offset,override,_x,_y,width,height); + return; + } + + int absx, absy; + absolutePosition(absx,absy); + if (absx == -1) { + // we don't know out absolute position, and there is no point returning + // just a relative one + _x = _y = -1; + } + else { + _x += absx; + _y += absy; + } + height = RenderText::verticalPositionHint( false ); + width = override ? height / 2 : 1; +#endif +} +#endif + +FindSelectionResult RenderBR::checkSelectionPoint(int _x, int _y, int _tx, int _ty, DOM::NodeImpl*& node, int &offset, SelPointState &state) +{ + // Simply take result of previous one + RenderText *prev = static_cast<RenderText *>(previousSibling()); + if (!prev || !prev->isText() || !prev->inlineTextBoxCount() || prev->isBR()) + prev = this; + + //kdDebug(6040) << "delegated to " << prev->renderName() << "@" << prev << endl; + return prev->RenderText::checkSelectionPoint(_x, _y, _tx, _ty, node, offset, state); +} diff --git a/tdehtml/rendering/render_br.h b/tdehtml/rendering/render_br.h new file mode 100644 index 000000000..8e511c94f --- /dev/null +++ b/tdehtml/rendering/render_br.h @@ -0,0 +1,77 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 2000 Lars Knoll (knoll@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_BR_H +#define RENDER_BR_H + +#include "render_text.h" + +/* + * The whole class here is a hack to get <br> working, as long as we don't have support for + * CSS2 :before and :after pseudo elements + */ +namespace tdehtml { + +class RenderBR : public RenderText +{ +public: + RenderBR(DOM::NodeImpl* node); + virtual ~RenderBR(); + + virtual const char *renderName() const { return "RenderBR"; } + + virtual void paint( PaintInfo&, int, int) {} + + virtual unsigned int width(unsigned int, unsigned int, const Font *) const { return 0; } + virtual unsigned int width( unsigned int, unsigned int, bool) const { return 0; } + virtual short width() const { return RenderText::width(); } + + virtual int height() const { return 0; } + + // overrides + virtual void calcMinMaxWidth() {} + virtual short minWidth() const { return 0; } + virtual int maxWidth() const { return 0; } + + virtual FindSelectionResult checkSelectionPoint( int _x, int _y, int _tx, int _ty, + DOM::NodeImpl*& node, int & offset, + SelPointState & ); + + virtual bool isBR() const { return true; } +#if 0 + virtual void caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height); +#endif + /** returns the lowest possible value the caret offset may have to + * still point to a valid position. + * + * Returns 0. + */ + virtual long minOffset() const { return 0; } + /** returns the highest possible value the caret offset may have to + * still point to a valid position. + * + * Returns also 0, as BRs have no width. + */ + virtual long maxOffset() const { return 0; } +}; + +} +#endif diff --git a/tdehtml/rendering/render_canvas.cpp b/tdehtml/rendering/render_canvas.cpp new file mode 100644 index 000000000..53dc32162 --- /dev/null +++ b/tdehtml/rendering/render_canvas.cpp @@ -0,0 +1,780 @@ +/** + * This file is part of the HTML widget for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 2003 Apple Computer, Inc. + * (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + + +#include "rendering/render_canvas.h" +#include "rendering/render_layer.h" +#include "xml/dom_docimpl.h" + +#include "tdehtmlview.h" +#include "tdehtml_part.h" +#include <kdebug.h> +#include <kglobal.h> + +using namespace tdehtml; + +//#define BOX_DEBUG +//#define SPEED_DEBUG + +RenderCanvas::RenderCanvas(DOM::NodeImpl* node, KHTMLView *view) + : RenderBlock(node) +{ + // init RenderObject attributes + setInline(false); + setIsAnonymous(false); + + m_view = view; + // try to contrain the width to the views width + + m_minWidth = 0; + m_height = 0; + + m_width = m_minWidth; + m_maxWidth = m_minWidth; + + m_rootWidth = m_rootHeight = 0; + m_viewportWidth = m_viewportHeight = 0; + m_cachedDocWidth = m_cachedDocHeight = -1; + + setPositioned(true); // to 0,0 :) + + m_staticMode = false; + m_pagedMode = false; + m_printImages = true; + + m_pageTop = 0; + m_pageBottom = 0; + + m_page = 0; + + m_maximalOutlineSize = 0; + + m_selectionStart = 0; + m_selectionEnd = 0; + m_selectionStartPos = -1; + m_selectionEndPos = -1; + + m_needsWidgetMasks = false; + + // Create a new root layer for our layer hierarchy. + m_layer = new (node->getDocument()->renderArena()) RenderLayer(this); +} + +RenderCanvas::~RenderCanvas() +{ + delete m_page; +} + +void RenderCanvas::setStyle(RenderStyle* style) +{ + /* + if (m_pagedMode) + style->setOverflow(OHIDDEN); */ + RenderBlock::setStyle(style); +} + +void RenderCanvas::calcHeight() +{ + if (m_pagedMode || !m_view) + m_height = m_rootHeight; + else + m_height = m_view->visibleHeight(); +} + +void RenderCanvas::calcWidth() +{ + // the width gets set by KHTMLView::print when printing to a printer. + if(m_pagedMode || !m_view) + { + m_width = m_rootWidth; + return; + } + + m_width = m_view ? m_view->frameWidth() : m_minWidth; + + if (style()->marginLeft().isFixed()) + m_marginLeft = style()->marginLeft().value(); + else + m_marginLeft = 0; + + if (style()->marginRight().isFixed()) + m_marginRight = style()->marginRight().value(); + else + m_marginRight = 0; +} + +void RenderCanvas::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + RenderBlock::calcMinMaxWidth(); + + m_maxWidth = m_minWidth; + + setMinMaxKnown(); +} + +//#define SPEED_DEBUG + +void RenderCanvas::layout() +{ + if (m_pagedMode) { + m_minWidth = m_width; +// m_maxWidth = m_width; + } + + m_needsFullRepaint = markedForRepaint() || !view() || view()->needsFullRepaint() || m_pagedMode; + + setChildNeedsLayout(true); + setMinMaxKnown(false); + for(RenderObject* c = firstChild(); c; c = c->nextSibling()) + c->setChildNeedsLayout(true); + + int oldWidth = m_width; + int oldHeight = m_height; + + m_cachedDocWidth = m_cachedDocHeight = -1; + + if (m_pagedMode || !m_view) { + m_width = m_rootWidth; + m_height = m_rootHeight; + } + else + { + m_viewportWidth = m_width = m_view->visibleWidth(); + m_viewportHeight = m_height = m_view->visibleHeight(); + } + +#ifdef SPEED_DEBUG + TQTime qt; + qt.start(); +#endif + + if ( recalcMinMax() ) + recalcMinMaxWidths(); + +#ifdef SPEED_DEBUG + kdDebug() << "RenderCanvas::calcMinMax time used=" << qt.elapsed() << endl; + qt.start(); +#endif + + bool relayoutChildren = (oldWidth != m_width) || (oldHeight != m_height); + + RenderBlock::layoutBlock( relayoutChildren ); + +#ifdef SPEED_DEBUG + kdDebug() << "RenderCanvas::layout time used=" << qt.elapsed() << endl; + qt.start(); +#endif + + updateDocumentSize(); + + layer()->updateLayerPositions( layer(), needsFullRepaint(), true ); + + if (!m_pagedMode && m_needsWidgetMasks) + layer()->updateWidgetMasks(layer()); + + scheduleDeferredRepaints(); + setNeedsLayout(false); + +#ifdef SPEED_DEBUG + kdDebug() << "RenderCanvas::end time used=" << qt.elapsed() << endl; +#endif +} + +void RenderCanvas::updateDocumentSize() +{ + // update our cached document size + int hDocH = m_cachedDocHeight = docHeight(); + int hDocW = m_cachedDocWidth = docWidth(); + + if (!m_pagedMode && m_view) { + + bool vss = m_view->verticalScrollBar()->isShown(); + bool hss = m_view->horizontalScrollBar()->isShown(); + TQSize s = m_view->viewportSize(m_cachedDocWidth, m_cachedDocHeight); + + // if we are about to show a scrollbar, and the document is sized to the viewport w or h, + // then reserve the scrollbar space so that it doesn't trigger the _other_ scrollbar + + if (!vss && m_width - m_view->verticalScrollBar()->sizeHint().width() == s.width() && + m_cachedDocWidth <= m_width) + hDocW = kMin( m_cachedDocWidth, s.width() ); + + if (!hss && m_height - m_view->horizontalScrollBar()->sizeHint().height() == s.height() && + m_cachedDocHeight <= m_height) + hDocH = kMin( m_cachedDocHeight, s.height() ); + + // likewise, if a scrollbar is shown, and we have a cunning plan to turn it off, + // think again if we are falling downright in the hysteresis zone + + if (vss && s.width() > m_cachedDocWidth && m_cachedDocWidth > m_view->visibleWidth()) + hDocW = s.width()+1; + + if (hss && s.height() > m_cachedDocHeight && m_cachedDocHeight > m_view->visibleHeight()) + hDocH = s.height()+1; + + m_view->resizeContents(hDocW, hDocH); + + setWidth( m_viewportWidth = s.width() ); + setHeight( m_viewportHeight = s.height() ); + } + layer()->resize( kMax( m_cachedDocWidth,int( m_width ) ), kMax( m_cachedDocHeight,m_height ) ); +} + +void RenderCanvas::updateDocSizeAfterLayerTranslation( RenderObject* o, bool posXOffset, bool posYOffset ) +{ + if (needsLayout()) + return; + int rightmost, lowest; + o->absolutePosition( rightmost, lowest ); + if (posXOffset) { + rightmost += o->rightmostPosition(false, true); + setCachedDocWidth( kMax(docWidth(), rightmost) ); + } else { + setCachedDocWidth( -1 ); + } + if (posYOffset) { + lowest += o->lowestPosition(false, true); + setCachedDocHeight( kMax(docHeight(), lowest) ); + } else { + setCachedDocHeight( -1 ); + } +// kdDebug() << " posXOffset: " << posXOffset << " posYOffset " << posYOffset << " m_cachedDocWidth " << m_cachedDocWidth << " m_cachedDocHeight " << m_cachedDocHeight << endl; + updateDocumentSize(); +} + +bool RenderCanvas::needsFullRepaint() const +{ + return m_needsFullRepaint || m_pagedMode; +} + +void RenderCanvas::repaintViewRectangle(int x, int y, int w, int h, bool asap) +{ + KHTMLAssert( view() ); + view()->scheduleRepaint( x, y, w, h, asap ); +} + +bool RenderCanvas::absolutePosition(int &xPos, int &yPos, bool f) const +{ + if ( f && m_pagedMode) { + xPos = 0; + yPos = m_pageTop; + } + else if ( f && m_view) { + xPos = m_view->contentsX(); + yPos = m_view->contentsY(); + } + else { + xPos = yPos = 0; + } + return true; +} + +void RenderCanvas::paint(PaintInfo& paintInfo, int _tx, int _ty) +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << this << " ::paintObject() w/h = (" << width() << "/" << height() << ")" << endl; +#endif + + // 1. paint background, borders etc + if(paintInfo.phase == PaintActionElementBackground) { + paintBoxDecorations(paintInfo, _tx, _ty); + return; + } + + // 2. paint contents + for( RenderObject *child = firstChild(); child; child=child->nextSibling()) + if(!child->layer() && !child->isFloating()) + child->paint(paintInfo, _tx, _ty); + + // 3. paint floats. + if (paintInfo.phase == PaintActionFloat) + paintFloats(paintInfo, _tx, _ty); + +#ifdef BOX_DEBUG + if (m_view) + { + _tx += m_view->contentsX(); + _ty += m_view->contentsY(); + } + + outlineBox(p, _tx, _ty); +#endif + +} + +void RenderCanvas::paintBoxDecorations(PaintInfo& paintInfo, int /*_tx*/, int /*_ty*/) +{ + if ((firstChild() && firstChild()->style()->visibility() == VISIBLE) || !view()) + return; + + paintInfo.p->fillRect(paintInfo.r, view()->palette().active().color(TQColorGroup::Base)); +} + +void RenderCanvas::repaintRectangle(int x, int y, int w, int h, Priority p, bool f) +{ + if (m_staticMode) return; +// kdDebug( 6040 ) << "updating views contents (" << x << "/" << y << ") (" << w << "/" << h << ")" << endl; + + if (f && m_pagedMode) { + y += m_pageTop; + } else + if ( f && m_view ) { + x += m_view->contentsX(); + y += m_view->contentsY(); + } + + TQRect vr = viewRect(); + TQRect ur(x, y, w, h); + + if (m_view && ur.intersects(vr)) { + + if (p == RealtimePriority) + // ### KWQ's updateContents has an additional parameter "now". + // It's not clear what the difference between updateContents(...,true) + // and repaintContents(...) is. As Qt doesn't have this, I'm leaving it out. (LS) + m_view->updateContents(ur/*, true*/); + else if (p == HighPriority) + m_view->scheduleRepaint(x, y, w, h, true /*asap*/); + else + m_view->scheduleRepaint(x, y, w, h); + } +} + +void RenderCanvas::deferredRepaint( RenderObject* o ) +{ + m_dirtyChildren.append( o ); +} + +void RenderCanvas::scheduleDeferredRepaints() +{ + if (!needsFullRepaint()) { + TQValueList<RenderObject*>::const_iterator it; + for ( it = m_dirtyChildren.begin(); it != m_dirtyChildren.end(); ++it ) + (*it)->repaint(); + } + //kdDebug(6040) << "scheduled deferred repaints: " << m_dirtyChildren.count() << " needed full repaint: " << needsFullRepaint() << endl; + m_dirtyChildren.clear(); +} + +void RenderCanvas::repaint(Priority p) +{ + if (m_view && !m_staticMode) { + if (p == RealtimePriority) { + //m_view->resizeContents(docWidth(), docHeight()); + m_view->unscheduleRepaint(); + if (needsLayout()) { + m_view->scheduleRelayout(); + return; + } + // ### same as in repaintRectangle + m_view->updateContents(m_view->contentsX(), m_view->contentsY(), + m_view->visibleWidth(), m_view->visibleHeight()/*, true*/); + } + else if (p == HighPriority) + m_view->scheduleRepaint(m_view->contentsX(), m_view->contentsY(), + m_view->visibleWidth(), m_view->visibleHeight(), true /*asap*/); + else + m_view->scheduleRepaint(m_view->contentsX(), m_view->contentsY(), + m_view->visibleWidth(), m_view->visibleHeight()); + } +} + +static TQRect enclosingPositionedRect (RenderObject *n) +{ + RenderObject *enclosingParent = n->containingBlock(); + TQRect rect(0,0,0,0); + if (enclosingParent) { + int ox, oy; + enclosingParent->absolutePosition(ox, oy); + int off = 0; + if (!enclosingParent->hasOverflowClip()) { + ox += enclosingParent->overflowLeft(); + oy += enclosingParent->overflowTop(); + } + rect.setX(ox); + rect.setY(oy); + rect.setWidth(enclosingParent->effectiveWidth()); + rect.setHeight(enclosingParent->effectiveHeight()); + } + return rect; +} + +TQRect RenderCanvas::selectionRect() const +{ + RenderObject *r = m_selectionStart; + if (!r) + return TQRect(); + + TQRect selectionRect = enclosingPositionedRect(r); + + while (r && r != m_selectionEnd) + { + RenderObject* n; + if ( !(n = r->firstChild()) ){ + if ( !(n = r->nextSibling()) ) + { + n = r->parent(); + while (n && !n->nextSibling()) + n = n->parent(); + if (n) + n = n->nextSibling(); + } + } + r = n; + if (r) { + selectionRect = selectionRect.unite(enclosingPositionedRect(r)); + } + } + + return selectionRect; +} + +void RenderCanvas::setSelection(RenderObject *s, int sp, RenderObject *e, int ep) +{ + // Check we got valid renderobjects. www.msnbc.com and clicking + // around, to find the case where this happened. + if ( !s || !e ) + { + kdWarning(6040) << "RenderCanvas::setSelection() called with start=" << s << " end=" << e << endl; + return; + } +// kdDebug( 6040 ) << "RenderCanvas::setSelection(" << s << "," << sp << "," << e << "," << ep << ")" << endl; + + bool changedSelectionBorder = ( s != m_selectionStart || e != m_selectionEnd ); + + // Cut out early if the selection hasn't changed. + if ( !changedSelectionBorder && m_selectionStartPos == sp && m_selectionEndPos == ep ) + return; + + // Record the old selected objects. Will be used later + // to delta against the selected objects. + + RenderObject *oldStart = m_selectionStart; + int oldStartPos = m_selectionStartPos; + RenderObject *oldEnd = m_selectionEnd; + int oldEndPos = m_selectionEndPos; + TQPtrList<RenderObject> oldSelectedInside; + TQPtrList<RenderObject> newSelectedInside; + RenderObject *os = oldStart; + + while (os && os != oldEnd) + { + RenderObject* no; + if ( !(no = os->firstChild()) ){ + if ( !(no = os->nextSibling()) ) + { + no = os->parent(); + while (no && !no->nextSibling()) + no = no->parent(); + if (no) + no = no->nextSibling(); + } + } + if (os->selectionState() == SelectionInside && !oldSelectedInside.containsRef(os)) + oldSelectedInside.append(os); + + os = no; + } + if (changedSelectionBorder) + clearSelection(false); + + while (s->firstChild()) + s = s->firstChild(); + while (e->lastChild()) + e = e->lastChild(); + +#if 0 + bool changedSelectionBorder = ( s != m_selectionStart || e != m_selectionEnd ); + + if ( !changedSelectionBorder && m_selectionStartPos == sp && m_selectionEndPos = ep ) + return; +#endif + + // set selection start + if (m_selectionStart) + m_selectionStart->setIsSelectionBorder(false); + m_selectionStart = s; + if (m_selectionStart) + m_selectionStart->setIsSelectionBorder(true); + m_selectionStartPos = sp; + + // set selection end + if (m_selectionEnd) + m_selectionEnd->setIsSelectionBorder(false); + m_selectionEnd = e; + if (m_selectionEnd) + m_selectionEnd->setIsSelectionBorder(true); + m_selectionEndPos = ep; + +#if 0 + kdDebug( 6040 ) << "old selection (" << oldStart << "," << oldStartPos << "," << oldEnd << "," << oldEndPos << ")" << endl; + kdDebug( 6040 ) << "new selection (" << s << "," << sp << "," << e << "," << ep << ")" << endl; +#endif + + // update selection status of all objects between m_selectionStart and m_selectionEnd + RenderObject* o = s; + + while (o && o!=e) + { + o->setSelectionState(SelectionInside); +// kdDebug( 6040 ) << "setting selected " << o << ", " << o->isText() << endl; + RenderObject* no; + if ( !(no = o->firstChild()) ) + if ( !(no = o->nextSibling()) ) + { + no = o->parent(); + while (no && !no->nextSibling()) + no = no->parent(); + if (no) + no = no->nextSibling(); + } + if (o->selectionState() == SelectionInside && !newSelectedInside.containsRef(o)) + newSelectedInside.append(o); + + o=no; + } + s->setSelectionState(SelectionStart); + e->setSelectionState(SelectionEnd); + if(s == e) s->setSelectionState(SelectionBoth); + + if (!m_view) + return; + + newSelectedInside.removeRef(s); + newSelectedInside.removeRef(e); + + TQRect updateRect; + + // Don't use repaint() because it will cause all rects to + // be united (see tdehtmlview::scheduleRepaint()). Instead + // just draw damage rects for objects that have a change + // in selection state. + // ### for Qt, updateContents will unite them, too. This has to be + // circumvented somehow (LS) + + // Are any of the old fully selected objects not in the new selection? + // If so we have to draw them. + // Could be faster by building list of non-intersecting rectangles rather + // than unioning rectangles. + TQPtrListIterator<RenderObject> oldIterator(oldSelectedInside); + bool firstRect = true; + for (; oldIterator.current(); ++oldIterator){ + if (!newSelectedInside.containsRef(oldIterator.current())){ + if (firstRect){ + updateRect = enclosingPositionedRect(oldIterator.current()); + firstRect = false; + } + else + updateRect = updateRect.unite(enclosingPositionedRect(oldIterator.current())); + } + } + if (!firstRect){ + m_view->updateContents( updateRect ); + } + + // Are any of the new fully selected objects not in the previous selection? + // If so we have to draw them. + // Could be faster by building list of non-intersecting rectangles rather + // than unioning rectangles. + TQPtrListIterator<RenderObject> newIterator(newSelectedInside); + firstRect = true; + for (; newIterator.current(); ++newIterator){ + if (!oldSelectedInside.containsRef(newIterator.current())){ + if (firstRect){ + updateRect = enclosingPositionedRect(newIterator.current()); + firstRect = false; + } + else + updateRect = updateRect.unite(enclosingPositionedRect(newIterator.current())); + } + } + if (!firstRect) { + m_view->updateContents( updateRect ); + } + + // Is the new starting object different, or did the position in the starting + // element change? If so we have to draw it. + if (oldStart != m_selectionStart || + (oldStart == oldEnd && (oldStartPos != m_selectionStartPos || oldEndPos != m_selectionEndPos)) || + (oldStart == m_selectionStart && oldStartPos != m_selectionStartPos)){ + m_view->updateContents( enclosingPositionedRect(m_selectionStart) ); + } + + // Draw the old selection start object if it's different than the new selection + // start object. + if (oldStart && oldStart != m_selectionStart){ + m_view->updateContents( enclosingPositionedRect(oldStart) ); + } + + // Does the selection span objects and is the new end object different, or did the position + // in the end element change? If so we have to draw it. + if (/*(oldStart != oldEnd || !oldEnd) &&*/ + (oldEnd != m_selectionEnd || + (oldEnd == m_selectionEnd && oldEndPos != m_selectionEndPos))){ + m_view->updateContents( enclosingPositionedRect(m_selectionEnd) ); + } + + // Draw the old selection end object if it's different than the new selection + // end object. + if (oldEnd && oldEnd != m_selectionEnd){ + m_view->updateContents( enclosingPositionedRect(oldEnd) ); + } +} + +void RenderCanvas::clearSelection(bool doRepaint) +{ + // update selection status of all objects between m_selectionStart and m_selectionEnd + RenderObject* o = m_selectionStart; + while (o && o!=m_selectionEnd) + { + if (o->selectionState()!=SelectionNone) + if (doRepaint) + o->repaint(); + o->setSelectionState(SelectionNone); + o->repaint(); + RenderObject* no; + if ( !(no = o->firstChild()) ) + if ( !(no = o->nextSibling()) ) + { + no = o->parent(); + while (no && !no->nextSibling()) + no = no->parent(); + if (no) + no = no->nextSibling(); + } + o=no; + } + if (m_selectionEnd) { + m_selectionEnd->setSelectionState(SelectionNone); + if (doRepaint) + m_selectionEnd->repaint(); + } + + // set selection start & end to 0 + if (m_selectionStart) + m_selectionStart->setIsSelectionBorder(false); + m_selectionStart = 0; + m_selectionStartPos = -1; + + if (m_selectionEnd) + m_selectionEnd->setIsSelectionBorder(false); + m_selectionEnd = 0; + m_selectionEndPos = -1; +} + +void RenderCanvas::selectionStartEnd(int& spos, int& epos) +{ + spos = m_selectionStartPos; + epos = m_selectionEndPos; +} + +TQRect RenderCanvas::viewRect() const +{ + if (m_pagedMode) + if (m_pageTop == m_pageBottom) { + kdDebug(6040) << "viewRect: " << TQRect(0, m_pageTop, m_width, m_height) << endl; + return TQRect(0, m_pageTop, m_width, m_height); + } + else { + kdDebug(6040) << "viewRect: " << TQRect(0, m_pageTop, m_width, m_pageBottom - m_pageTop) << endl; + return TQRect(0, m_pageTop, m_width, m_pageBottom - m_pageTop); + } + else if (m_view) + return TQRect(m_view->contentsX(), + m_view->contentsY(), + m_view->visibleWidth(), + m_view->visibleHeight()); + else + return TQRect(0,0,m_rootWidth,m_rootHeight); +} + +int RenderCanvas::docHeight() const +{ + if (m_cachedDocHeight != -1) + return m_cachedDocHeight; + + int h; + if (m_pagedMode || !m_view) + h = m_height; + else + h = 0; + + RenderObject *fc = firstChild(); + if(fc) { + int dh = fc->overflowHeight() + fc->marginTop() + fc->marginBottom(); + int lowestPos = fc->lowestPosition(false); +// kdDebug(6040) << "h " << h << " lowestPos " << lowestPos << " dh " << dh << " fc->rh " << fc->effectiveHeight() << " fc->height() " << fc->height() << endl; + if( lowestPos > dh ) + dh = lowestPos; + lowestPos = lowestAbsolutePosition(); + if( lowestPos > dh ) + dh = lowestPos; + if( dh > h ) + h = dh; + } + + RenderLayer *layer = m_layer; + h = kMax( h, layer->yPos() + layer->height() ); +// kdDebug(6040) << "h " << h << " layer(" << layer->renderer()->renderName() << "@" << layer->renderer() << ")->height " << layer->height() << " lp " << (layer->yPos() + layer->height()) << " height() " << layer->renderer()->height() << " rh " << layer->renderer()->effectiveHeight() << endl; + return h; +} + +int RenderCanvas::docWidth() const +{ + if (m_cachedDocWidth != -1) + return m_cachedDocWidth; + + int w; + if (m_pagedMode || !m_view) + w = m_width; + else + w = 0; + + RenderObject *fc = firstChild(); + if(fc) { + // ow: like effectiveWidth() but without the negative + const int ow = fc->hasOverflowClip() ? fc->width() : fc->overflowWidth(); + int dw = ow + fc->marginLeft() + fc->marginRight(); + int rightmostPos = fc->rightmostPosition(false); +// kdDebug(6040) << "w " << w << " rightmostPos " << rightmostPos << " dw " << dw << " fc->rw " << fc->effectiveWidth() << " fc->width() " << fc->width() << endl; + if( rightmostPos > dw ) + dw = rightmostPos; + rightmostPos = rightmostAbsolutePosition(); + if ( rightmostPos > dw ) + dw = rightmostPos; + if( dw > w ) + w = dw; + } + + RenderLayer *layer = m_layer; + w = kMax( w, layer->xPos() + layer->width() ); +// kdDebug(6040) << "w " << w << " layer(" << layer->renderer()->renderName() << ")->width " << layer->width() << " rm " << (layer->xPos() + layer->width()) << " width() " << layer->renderer()->width() << " rw " << layer->renderer()->effectiveWidth() << endl; + return w; +} + +RenderPage* RenderCanvas::page() { + if (!m_page) m_page = new RenderPage(this); + return m_page; +} diff --git a/tdehtml/rendering/render_canvas.h b/tdehtml/rendering/render_canvas.h new file mode 100644 index 000000000..8495b87bc --- /dev/null +++ b/tdehtml/rendering/render_canvas.h @@ -0,0 +1,250 @@ +/* + * This file is part of the HTML widget for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef render_canvas_h +#define render_canvas_h + +#include "render_block.h" + +class KHTMLView; +class TQScrollView; + +namespace tdehtml { + +class RenderPage; +class RenderStyle; + +enum CanvasMode { + CanvasViewPort, // Paints inside a viewport + CanvasPage, // Paints one page + CanvasDocument // Paints the whole document +}; + +class RenderCanvas : public RenderBlock +{ +public: + RenderCanvas(DOM::NodeImpl* node, KHTMLView *view); + ~RenderCanvas(); + + virtual const char *renderName() const { return "RenderCanvas"; } + + virtual bool isCanvas() const { return true; } + + virtual void setStyle(RenderStyle *style); + virtual void layout(); + virtual void calcWidth(); + virtual void calcHeight(); + virtual void calcMinMaxWidth(); + virtual bool absolutePosition(int &xPos, int&yPos, bool f = false) const; + + int docHeight() const; + int docWidth() const; + + KHTMLView *view() const { return m_view; } + + virtual void repaint(Priority p=NormalPriority); + virtual void repaintRectangle(int x, int y, int w, int h, Priority p=NormalPriority, bool f=false); + void repaintViewRectangle(int x, int y, int w, int h, bool asap=false); + bool needsFullRepaint() const; + void deferredRepaint( RenderObject* o ); + void scheduleDeferredRepaints(); + + virtual void paint(PaintInfo&, int tx, int ty); + virtual void paintBoxDecorations(PaintInfo& paintInfo, int _tx, int _ty); + virtual void setSelection(RenderObject *s, int sp, RenderObject *e, int ep); + virtual void clearSelection(bool doRepaint=true); + virtual RenderObject *selectionStart() const { return m_selectionStart; } + virtual RenderObject *selectionEnd() const { return m_selectionEnd; } + + void setPrintImages(bool enable) { m_printImages = enable; } + bool printImages() const { return m_printImages; } + + void setCanvasMode(CanvasMode mode) { m_canvasMode = mode; } + CanvasMode canvasMode() const { return m_canvasMode; } + + void setPagedMode(bool b) { m_pagedMode = b; } + void setStaticMode(bool b) { m_staticMode = b; } + + bool pagedMode() const { return m_pagedMode; } + bool staticMode() const { return m_staticMode; } + + void setPageTop(int top) { + m_pageTop = top; +// m_y = top; + } + void setPageBottom(int bottom) { m_pageBottom = bottom; } + int pageTop() const { return m_pageTop; } + int pageBottom() const { return m_pageBottom; } + + int pageTopAfter(int y) const { + if (pageHeight() == 0) return 0; + return (y / pageHeight() + 1) * pageHeight() ; + } + + int crossesPageBreak(int top, int bottom) const { + if (pageHeight() == 0) return false; + int pT = top / pageHeight(); + // bottom is actually the first line not in the box + int pB = (bottom-1) / pageHeight(); + return (pT == pB) ? 0 : (pB + 1); + } + + void setPageNumber(int number) { m_pageNr = number; } + int pageNumber() const { return m_pageNr; } + +public: + virtual void setWidth( int width ) { m_rootWidth = m_width = width; } + virtual void setHeight( int height ) { m_rootHeight = m_height = height; } + +// void setPageHeight( int height ) { m_viewportHeight = m_pageHeight = height; } + int pageHeight() const { return m_pageBottom - m_pageTop; } + + int viewportWidth() const { return m_viewportWidth; } + int viewportHeight() const { return m_viewportHeight; } + + RenderPage* page(); + + TQRect selectionRect() const; + + void setMaximalOutlineSize(int o) { m_maximalOutlineSize = o; } + int maximalOutlineSize() const { return m_maximalOutlineSize; } + + void setNeedsWidgetMasks( bool b=true) { m_needsWidgetMasks = b; } + bool needsWidgetMasks() const { return m_needsWidgetMasks; } + + void updateDocSizeAfterLayerTranslation( RenderObject* o, bool posXOffset, bool posYOffset ); +protected: + // makes sure document, scrollbars and viewport size are accurate + void updateDocumentSize(); + + // internal setters for cached values of document width/height + // Setting to -1/-1 invalidates the cache. + void setCachedDocWidth(int w ) { m_cachedDocWidth = w; } + void setCachedDocHeight(int h) { m_cachedDocHeight = h; } + + virtual void selectionStartEnd(int& spos, int& epos); + + virtual TQRect viewRect() const; + + KHTMLView *m_view; + + RenderObject* m_selectionStart; + RenderObject* m_selectionEnd; + int m_selectionStartPos; + int m_selectionEndPos; + + CanvasMode m_canvasMode; + + int m_rootWidth; + int m_rootHeight; + + int m_viewportWidth; + int m_viewportHeight; + + int m_cachedDocWidth; + int m_cachedDocHeight; + + bool m_printImages; + bool m_needsFullRepaint; + + // Canvas is not interactive + bool m_staticMode; + // Canvas is paged + bool m_pagedMode; + // Canvas contains overlaid widgets + bool m_needsWidgetMasks; + + short m_pageNr; + + int m_pageTop; + int m_pageBottom; + + RenderPage* m_page; + + int m_maximalOutlineSize; // Used to apply a fudge factor to dirty-rect checks on blocks/tables. + TQValueList<RenderObject*> m_dirtyChildren; +}; + +inline RenderCanvas* RenderObject::canvas() const +{ + return static_cast<RenderCanvas*>(document()->renderer()); +} + +// Represents the page-context of CSS +class RenderPage +{ +public: + RenderPage(RenderCanvas* canvas) : m_canvas(canvas), + m_marginTop(0), m_marginBottom(0), + m_marginLeft(0), m_marginRight(0), + m_pageWidth(0), m_pageHeight(0), + m_fixedSize(false) + { + m_style = new RenderPageStyle(); + } + virtual ~RenderPage() + { + delete m_style; + } + + int marginTop() const { return m_marginTop; } + int marginBottom() const { return m_marginBottom; } + int marginLeft() const { return m_marginLeft; } + int marginRight() const { return m_marginRight; } + + void setMarginTop(int margin) { m_marginTop = margin; } + void setMarginBottom(int margin) { m_marginBottom = margin; } + void setMarginLeft(int margin) { m_marginLeft = margin; } + void setMarginRight(int margin) { m_marginRight = margin; } + + int pageWidth() const { return m_pageWidth; } + int pageHeight() const { return m_pageHeight; } + + void setPageSize(int width, int height) { + m_pageWidth = width; + m_pageHeight = height; + } + + // Returns true if size was set by document, false if set by user-agent + bool fixedSize() const { return m_fixedSize; } + void setFixedSize(bool b) { m_fixedSize = b; } + + RenderPageStyle* style() { return m_style; } + const RenderPageStyle* style() const { return m_style; } + +protected: + RenderCanvas* m_canvas; + RenderPageStyle* m_style; + + int m_marginTop; + int m_marginBottom; + int m_marginLeft; + int m_marginRight; + + int m_pageWidth; + int m_pageHeight; + + bool m_fixedSize; +}; + +} +#endif diff --git a/tdehtml/rendering/render_container.cpp b/tdehtml/rendering/render_container.cpp new file mode 100644 index 000000000..b91bc91df --- /dev/null +++ b/tdehtml/rendering/render_container.cpp @@ -0,0 +1,597 @@ +/** + * This file is part of the html renderer for KDE. + * + * Copyright (C) 2001-2003 Lars Knoll (knoll@kde.org) + * (C) 2001 Antti Koivisto (koivisto@kde.org) + * (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * (C) 2002-2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +//#define DEBUG_LAYOUT + +#include "rendering/render_container.h" +#include "rendering/render_table.h" +#include "rendering/render_text.h" +#include "rendering/render_image.h" +#include "rendering/render_canvas.h" +#include "rendering/render_generated.h" +#include "rendering/render_inline.h" +#include "xml/dom_docimpl.h" +#include "css/css_valueimpl.h" + +#include <kdebug.h> +#include <assert.h> + +using namespace tdehtml; + +RenderContainer::RenderContainer(DOM::NodeImpl* node) + : RenderObject(node) +{ + m_first = 0; + m_last = 0; +} + +void RenderContainer::detach() +{ + if (continuation()) + continuation()->detach(); + + // We simulate removeNode calls for all our children + // and set parent to 0 to avoid removeNode from being called. + // First call removeLayers and removeFromObjectLists since they assume + // a valid render-tree + for(RenderObject* n = m_first; n; n = n->nextSibling() ) { + n->removeLayers(enclosingLayer()); + n->removeFromObjectLists(); + } + + RenderObject* next; + for(RenderObject* n = m_first; n; n = next ) { + n->setParent(0); + next = n->nextSibling(); + n->detach(); + } + m_first = 0; + m_last = 0; + + RenderObject::detach(); +} + +void RenderContainer::addChild(RenderObject *newChild, RenderObject *beforeChild) +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << this << ": " << renderName() << "(RenderObject)::addChild( " << newChild << ": " << + newChild->renderName() << ", " << (beforeChild ? beforeChild->renderName() : "0") << " )" << endl; +#endif + // protect ourselves from deletion + setDoNotDelete(true); + + bool needsTable = false; + + if(!newChild->isText() && !newChild->isReplaced()) { + switch(newChild->style()->display()) { + case INLINE: + case BLOCK: + case LIST_ITEM: + case RUN_IN: + case COMPACT: + case INLINE_BLOCK: + case TABLE: + case INLINE_TABLE: + break; + case TABLE_COLUMN: + if ( isTableCol() ) + break; + // nobreak + case TABLE_COLUMN_GROUP: + case TABLE_CAPTION: + case TABLE_ROW_GROUP: + case TABLE_HEADER_GROUP: + case TABLE_FOOTER_GROUP: + + //kdDebug( 6040 ) << "adding section" << endl; + if ( !isTable() ) + needsTable = true; + break; + case TABLE_ROW: + //kdDebug( 6040 ) << "adding row" << endl; + if ( !isTableSection() ) + needsTable = true; + break; + case TABLE_CELL: + //kdDebug( 6040 ) << "adding cell" << endl; + if ( !isTableRow() ) + needsTable = true; + // I'm not 100% sure this is the best way to fix this, but without this + // change we recurse infinitely when trying to render the CSS2 test page: + // http://www.bath.ac.uk/%7Epy8ieh/internet/eviltests/htmlbodyheadrendering2.html. + if ( isTableCell() && !firstChild() && !newChild->isTableCell() ) + needsTable = false; + + break; + case NONE: + // RenderHtml and some others can have display:none + // KHTMLAssert(false); + break; + } + } + + if ( needsTable ) { + RenderTable *table; + RenderObject *last = beforeChild ? beforeChild->previousSibling() : lastChild(); + if ( last && last->isTable() && last->isAnonymous() ) { + table = static_cast<RenderTable *>(last); + } else { + //kdDebug( 6040 ) << "creating anonymous table, before=" << beforeChild << endl; + table = new (renderArena()) RenderTable(document() /* is anonymous */); + RenderStyle *newStyle = new RenderStyle(); + newStyle->inheritFrom(style()); + newStyle->setDisplay( TABLE ); + newStyle->setFlowAroundFloats( true ); + table->setParent( this ); // so it finds the arena + table->setStyle(newStyle); + table->setParent( 0 ); + addChild(table, beforeChild); + } + table->addChild(newChild); + } else { + // just add it... + insertChildNode(newChild, beforeChild); + } + + if (newChild->isText() && newChild->style()->textTransform() == CAPITALIZE) { + DOM::DOMStringImpl* textToTransform = static_cast<RenderText*>(newChild)->originalString(); + if (textToTransform) + static_cast<RenderText*>(newChild)->setText(textToTransform, true); + } + newChild->attach(); + + setDoNotDelete(false); +} + +RenderObject* RenderContainer::removeChildNode(RenderObject* oldChild) +{ + KHTMLAssert(oldChild->parent() == this); + + // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or + // that a positioned child got yanked). We also repaint, so that the area exposed when the child + // disappears gets repainted properly. + if ( document()->renderer() ) { + oldChild->setNeedsLayoutAndMinMaxRecalc(); + oldChild->repaint(); + + // Keep our layer hierarchy updated. + oldChild->removeLayers(enclosingLayer()); + // remove the child from any special layout lists + oldChild->removeFromObjectLists(); + + // if oldChild is the start or end of the selection, then clear + // the selection to avoid problems of invalid pointers + + // ### This is not the "proper" solution... ideally the selection + // ### should be maintained based on DOM Nodes and a Range, which + // ### gets adjusted appropriately when nodes are deleted/inserted + // ### near etc. But this at least prevents crashes caused when + // ### the start or end of the selection is deleted and then + // ### accessed when the user next selects something. + + if (oldChild->isSelectionBorder()) { + RenderObject *root = oldChild; + while (root->parent()) + root = root->parent(); + if (root->isCanvas()) { + static_cast<RenderCanvas*>(root)->clearSelection(); + } + } + } + + // remove the child from the render-tree + if (oldChild->previousSibling()) + oldChild->previousSibling()->setNextSibling(oldChild->nextSibling()); + if (oldChild->nextSibling()) + oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling()); + + if (m_first == oldChild) + m_first = oldChild->nextSibling(); + if (m_last == oldChild) + m_last = oldChild->previousSibling(); + + oldChild->setPreviousSibling(0); + oldChild->setNextSibling(0); + oldChild->setParent(0); + + return oldChild; +} + +void RenderContainer::setStyle(RenderStyle* _style) +{ + RenderObject::setStyle(_style); + + // If we are a pseudo-container we need to restyle the children + if (style()->isGenerated()) + { + // ### we could save this call when the change only affected + // non inherited properties + RenderStyle *pseudoStyle = new RenderStyle(); + pseudoStyle->inheritFrom(style()); + pseudoStyle->ref(); + RenderObject *child = firstChild(); + while (child != 0) + { + child->setStyle(pseudoStyle); + child = child->nextSibling(); + } + pseudoStyle->deref(); + } +} + +void RenderContainer::updatePseudoChildren() +{ + // In CSS2, before/after pseudo-content cannot nest. Check this first. + // Remove when CSS 3 Generated Content becomes Candidate Recommendation + if (style()->styleType() == RenderStyle::BEFORE + || style()->styleType() == RenderStyle::AFTER) + return; + + updatePseudoChild(RenderStyle::BEFORE); + updatePseudoChild(RenderStyle::AFTER); + // updatePseudoChild(RenderStyle::MARKER, marker()); +} + +void RenderContainer::updatePseudoChild(RenderStyle::PseudoId type) +{ + // The head manages generated content for its continuations + if (isInlineContinuation()) return; + + RenderStyle* pseudo = style()->getPseudoStyle(type); + + RenderObject* child = pseudoContainer(type); + + // Whether or not we currently have generated content attached. + bool oldContentPresent = child && (child->style()->styleType() == type); + + // Whether or not we now want generated content. + bool newContentWanted = pseudo && pseudo->display() != NONE; + + // No generated content + if (!oldContentPresent && !newContentWanted) + return; + + bool movedContent = (type == RenderStyle::AFTER && isRenderInline() && continuation()); + + // Whether or not we want the same old content. + bool sameOldContent = oldContentPresent && newContentWanted && !movedContent + && (child->style()->contentDataEquivalent(pseudo)); + + // No change in content, update style + if( sameOldContent ) { + child->setStyle(pseudo); + return; + } + + // If we don't want generated content any longer, or if we have generated content, + // but it's no longer identical to the new content data we want to build + // render objects for, then we nuke all of the old generated content. + if (oldContentPresent && (!newContentWanted || !sameOldContent)) + { + // The child needs to be removed. + oldContentPresent = false; + child->detach(); + child = 0; + } + + // If we have no pseudo-style or if the pseudo's display type is NONE, then we + // have no generated content and can now return. + if (!newContentWanted) + return; + + // Generated content consists of a single container that houses multiple children (specified + // by the content property). This pseudo container gets the pseudo style set on it. + RenderContainer* pseudoContainer = 0; + pseudoContainer = RenderFlow::createFlow(element(), pseudo, renderArena()); + pseudoContainer->setIsAnonymous( true ); + pseudoContainer->createGeneratedContent(); + + // Only add the container if it had content + if (pseudoContainer->firstChild()) { + addPseudoContainer(pseudoContainer); + pseudoContainer->close(); + } +} + +void RenderContainer::createGeneratedContent() +{ + RenderStyle* pseudo = style(); + RenderStyle* style = new RenderStyle(); + style->ref(); + style->inheritFrom(pseudo); + + // Now walk our list of generated content and create render objects for every type + // we encounter. + for (ContentData* contentData = pseudo->contentData(); + contentData; contentData = contentData->_nextContent) + { + if (contentData->_contentType == CONTENT_TEXT) + { + RenderText* t = new (renderArena()) RenderText( node(), 0); + t->setIsAnonymous( true ); + t->setStyle(style); + t->setText(contentData->contentText()); + addChild(t); + } + else if (contentData->_contentType == CONTENT_OBJECT) + { + RenderImage* img = new (renderArena()) RenderImage(node()); + img->setIsAnonymous( true ); + img->setStyle(style); + img->setContentObject(contentData->contentObject()); + addChild(img); + } + else if (contentData->_contentType == CONTENT_COUNTER) + { + // really a counter or just a glyph? + EListStyleType type = (EListStyleType)contentData->contentCounter()->listStyle(); + RenderObject *t = 0; + if (isListStyleCounted(type)) { + t = new (renderArena()) RenderCounter( node(), contentData->contentCounter() ); + } + else { + t = new (renderArena()) RenderGlyph( node(), type ); + } + t->setIsAnonymous( true ); + t->setStyle(style); + addChild(t); + } + else if (contentData->_contentType == CONTENT_QUOTE) + { + RenderQuote* t = new (renderArena()) RenderQuote( node(), contentData->contentQuote() ); + t->setIsAnonymous( true ); + t->setStyle(style); + addChild(t); + } + } + style->deref(); +} + +RenderContainer* RenderContainer::pseudoContainer(RenderStyle::PseudoId type) const +{ + RenderObject *child = 0; + switch (type) { + case RenderStyle::AFTER: + child = lastChild(); + break; + case RenderStyle::BEFORE: + child = firstChild(); + break; + case RenderStyle::REPLACED: + child = lastChild(); + if (child && child->style()->styleType() == RenderStyle::AFTER) + child = child->previousSibling(); + break; + default: + child = 0; + } + + if (child && child->style()->styleType() == type) { + assert(child->isRenderBlock() || child->isRenderInline()); + return static_cast<RenderContainer*>(child); + } + if (type == RenderStyle::AFTER) { + // check continuations + if (continuation()) + return continuation()->pseudoContainer(type); + } + if (child && child->isAnonymousBlock()) + return static_cast<RenderBlock*>(child)->pseudoContainer(type); + return 0; +} + +void RenderContainer::addPseudoContainer(RenderObject* child) +{ + RenderStyle::PseudoId type = child->style()->styleType(); + switch (type) { + case RenderStyle::AFTER: { + RenderObject *o = this; + while (o->continuation()) o = o->continuation(); + + // Coalesce inlines + if (child->style()->display() == INLINE && o->lastChild() && o->lastChild()->isAnonymousBlock()) { + o->lastChild()->addChild(child, 0); + } else + o->addChild(child, 0); + break; + } + case RenderStyle::BEFORE: + // Coalesce inlines + if (child->style()->display() == INLINE && firstChild() && firstChild()->isAnonymousBlock()) { + firstChild()->addChild(child, firstChild()->firstChild()); + } else + addChild(child, firstChild()); + break; + case RenderStyle::REPLACED: + addChild(child, pseudoContainer(RenderStyle::AFTER)); + break; + default: + break; + } +} + +void RenderContainer::updateReplacedContent() +{ + // Only for normal elements + if (!style() || style()->styleType() != RenderStyle::NOPSEUDO) + return; + + // delete old generated content + RenderContainer *container = pseudoContainer(RenderStyle::REPLACED); + if (container) { + container->detach(); + } + + if (style()->useNormalContent()) return; + + // create generated content + RenderStyle* pseudo = style()->getPseudoStyle(RenderStyle::REPLACED); + if (!pseudo) { + pseudo = new RenderStyle(); + pseudo->inheritFrom(style()); + pseudo->setStyleType(RenderStyle::REPLACED); + } + if (pseudo->useNormalContent()) + pseudo->setContentData(style()->contentData()); + + container = RenderFlow::createFlow(node(), pseudo, renderArena()); + container->setIsAnonymous( true ); + container->createGeneratedContent(); + + addChild(container, pseudoContainer(RenderStyle::AFTER)); +} + +void RenderContainer::appendChildNode(RenderObject* newChild) +{ + KHTMLAssert(newChild->parent() == 0); + + newChild->setParent(this); + RenderObject* lChild = lastChild(); + + if(lChild) + { + newChild->setPreviousSibling(lChild); + lChild->setNextSibling(newChild); + } + else + setFirstChild(newChild); + + setLastChild(newChild); + + // Keep our layer hierarchy updated. Optimize for the common case where we don't have any children + // and don't have a layer attached to ourselves. + if (newChild->firstChild() || newChild->layer()) { + RenderLayer* layer = enclosingLayer(); + newChild->addLayers(layer, newChild); + } + + newChild->setNeedsLayoutAndMinMaxRecalc(); // Goes up the containing block hierarchy. + if (!normalChildNeedsLayout()) + setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child. +} + +void RenderContainer::insertChildNode(RenderObject* child, RenderObject* beforeChild) +{ + if(!beforeChild) { + appendChildNode(child); + return; + } + + KHTMLAssert(!child->parent()); + while ( beforeChild->parent() != this && beforeChild->parent()->isAnonymousBlock() ) + beforeChild = beforeChild->parent(); + KHTMLAssert(beforeChild->parent() == this); + + if(beforeChild == firstChild()) + setFirstChild(child); + + RenderObject* prev = beforeChild->previousSibling(); + child->setNextSibling(beforeChild); + beforeChild->setPreviousSibling(child); + if(prev) prev->setNextSibling(child); + child->setPreviousSibling(prev); + child->setParent(this); + + // Keep our layer hierarchy updated. + RenderLayer* layer = enclosingLayer(); + child->addLayers(layer, child); + + child->setNeedsLayoutAndMinMaxRecalc(); + if (!normalChildNeedsLayout()) + setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child. +} + + +void RenderContainer::layout() +{ + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + const bool pagedMode = canvas()->pagedMode(); + RenderObject *child = firstChild(); + while( child ) { + if (pagedMode) child->setNeedsLayout(true); + child->layoutIfNeeded(); + if (child->containsPageBreak()) setContainsPageBreak(true); + if (child->needsPageClear()) setNeedsPageClear(true); + child = child->nextSibling(); + } + setNeedsLayout(false); +} + +void RenderContainer::removeLeftoverAnonymousBoxes() +{ + // we have to go over all child nodes and remove anonymous boxes, that do _not_ + // have inline children to keep the tree flat + RenderObject *child = firstChild(); + while( child ) { + RenderObject *next = child->nextSibling(); + + if ( child->isRenderBlock() && child->isAnonymousBlock() && !child->continuation() && + !child->childrenInline() && !child->isTableCell() && !child->doNotDelete()) { + RenderObject *firstAnChild = child->firstChild(); + RenderObject *lastAnChild = child->lastChild(); + if ( firstAnChild ) { + RenderObject *o = firstAnChild; + while( o ) { + o->setParent( this ); + o = o->nextSibling(); + } + firstAnChild->setPreviousSibling( child->previousSibling() ); + lastAnChild->setNextSibling( child->nextSibling() ); + if ( child->previousSibling() ) + child->previousSibling()->setNextSibling( firstAnChild ); + if ( child->nextSibling() ) + child->nextSibling()->setPreviousSibling( lastAnChild ); + if ( child == firstChild() ) + m_first = firstAnChild; + if ( child == lastChild() ) + m_last = lastAnChild; + } else { + if ( child->previousSibling() ) + child->previousSibling()->setNextSibling( child->nextSibling() ); + if ( child->nextSibling() ) + child->nextSibling()->setPreviousSibling( child->previousSibling() ); + if ( child == firstChild() ) + m_first = child->nextSibling(); + if ( child == lastChild() ) + m_last = child->previousSibling(); + } + child->setParent( 0 ); + child->setPreviousSibling( 0 ); + child->setNextSibling( 0 ); + if ( !child->isText() ) { + RenderContainer *c = static_cast<RenderContainer *>(child); + c->m_first = 0; + c->m_next = 0; + } + child->detach(); + } + child = next; + } + if ( parent() ) + parent()->removeLeftoverAnonymousBoxes(); +} + +#undef DEBUG_LAYOUT diff --git a/tdehtml/rendering/render_container.h b/tdehtml/rendering/render_container.h new file mode 100644 index 000000000..44ff88384 --- /dev/null +++ b/tdehtml/rendering/render_container.h @@ -0,0 +1,85 @@ +/* + * This file is part of the html renderer for KDE. + * + * Copyright (C) 2001 Antti Koivisto (koivisto@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef render_container_h +#define render_container_h + +#include "render_object.h" + +namespace tdehtml +{ + + +/** + * Base class for rendering objects that can have children + */ +class RenderContainer : public RenderObject +{ +public: + RenderContainer(DOM::NodeImpl* node); + + void detach(); + + RenderObject *firstChild() const { return m_first; } + RenderObject *lastChild() const { return m_last; } + + virtual bool childAllowed() const { + // Prevent normal children when we are replaced by generated content + if (style()) return style()->useNormalContent(); + return true; + } + + virtual void addChild(RenderObject *newChild, RenderObject *beforeChild = 0); + + virtual RenderObject* removeChildNode(RenderObject* child); + virtual void appendChildNode(RenderObject* child); + virtual void insertChildNode(RenderObject* child, RenderObject* before); + + virtual void layout(); + virtual void calcMinMaxWidth() { setMinMaxKnown( true ); } + + virtual void removeLeftoverAnonymousBoxes(); + + virtual void setStyle(RenderStyle* _style); + +protected: + // Generate CSS content + void createGeneratedContent(); + void updateReplacedContent(); + + void updatePseudoChildren(); + void updatePseudoChild(RenderStyle::PseudoId type); + + RenderContainer* pseudoContainer( RenderStyle::PseudoId type ) const; + void addPseudoContainer(RenderObject* child); +private: + + void setFirstChild(RenderObject *first) { m_first = first; } + void setLastChild(RenderObject *last) { m_last = last; } + +protected: + + RenderObject *m_first; + RenderObject *m_last; +}; + +} +#endif diff --git a/tdehtml/rendering/render_flow.cpp b/tdehtml/rendering/render_flow.cpp new file mode 100644 index 000000000..71456d0a8 --- /dev/null +++ b/tdehtml/rendering/render_flow.cpp @@ -0,0 +1,412 @@ +/** + * This file is part of the html renderer for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999-2003 Antti Koivisto (koivisto@kde.org) + * (C) 2002-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003-2006 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ +// ------------------------------------------------------------------------- + +#include <kdebug.h> +#include <assert.h> +#include <tqpainter.h> +#include <kglobal.h> + +#include "rendering/render_flow.h" +#include "rendering/render_text.h" +#include "rendering/render_table.h" +#include "rendering/render_canvas.h" +#include "rendering/render_inline.h" +#include "rendering/render_block.h" +#include "rendering/render_arena.h" +#include "rendering/render_line.h" +#include "xml/dom_nodeimpl.h" +#include "xml/dom_docimpl.h" +#include "misc/htmltags.h" +#include "html/html_formimpl.h" + +#include "tdehtmlview.h" + +using namespace DOM; +using namespace tdehtml; + +RenderFlow* RenderFlow::createFlow(DOM::NodeImpl* node, RenderStyle* style, RenderArena* arena) +{ + RenderFlow* result; + if (style->display() == INLINE) + result = new (arena) RenderInline(node); + else + result = new (arena) RenderBlock(node); + result->setStyle(style); + return result; +} + +RenderFlow* RenderFlow::continuationBefore(RenderObject* beforeChild) +{ + if (beforeChild && beforeChild->parent() == this) + return this; + + RenderFlow* curr = continuation(); + RenderFlow* nextToLast = this; + RenderFlow* last = this; + while (curr) { + if (beforeChild && beforeChild->parent() == curr) { + if (curr->firstChild() == beforeChild) + return last; + return curr; + } + + nextToLast = last; + last = curr; + curr = curr->continuation(); + } + + if (!beforeChild && !last->firstChild()) + return nextToLast; + return last; +} + +void RenderFlow::addChildWithContinuation(RenderObject* newChild, RenderObject* beforeChild) +{ + RenderFlow* flow = continuationBefore(beforeChild); + while(beforeChild && beforeChild->parent() != flow && !beforeChild->parent()->isAnonymousBlock()) { + // skip implicit containers around beforeChild + beforeChild = beforeChild->parent(); + } + RenderFlow* beforeChildParent = beforeChild ? static_cast<RenderFlow*>(beforeChild->parent()) : + (flow->continuation() ? flow->continuation() : flow); + + if (newChild->isFloatingOrPositioned()) + return beforeChildParent->addChildToFlow(newChild, beforeChild); + + // A continuation always consists of two potential candidates: an inline or an anonymous + // block box holding block children. + bool childInline = newChild->isInline(); + bool bcpInline = beforeChildParent->isInline(); + bool flowInline = flow->isInline(); + + if (flow == beforeChildParent) + return flow->addChildToFlow(newChild, beforeChild); + else { + // The goal here is to match up if we can, so that we can coalesce and create the + // minimal # of continuations needed for the inline. + if (childInline == bcpInline) + return beforeChildParent->addChildToFlow(newChild, beforeChild); + else if (flowInline == childInline) + return flow->addChildToFlow(newChild, 0); // Just treat like an append. + else + return beforeChildParent->addChildToFlow(newChild, beforeChild); + } +} + +void RenderFlow::addChild(RenderObject *newChild, RenderObject *beforeChild) +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(RenderFlow)::addChild( " << newChild->renderName() << + ", " << (beforeChild ? beforeChild->renderName() : "0") << " )" << endl; + kdDebug( 6040 ) << "current height = " << m_height << endl; +#endif + + if (continuation()) + return addChildWithContinuation(newChild, beforeChild); + return addChildToFlow(newChild, beforeChild); +} + +void RenderFlow::deleteInlineBoxes(RenderArena* arena) +{ + RenderBox::deleteInlineBoxes(arena); //In case we upcalled + //during construction + if (m_firstLineBox) { + if (!arena) + arena = renderArena(); + InlineRunBox *curr=m_firstLineBox, *next=0; + while (curr) { + next = curr->nextLineBox(); + curr->detach(arena); + curr = next; + } + m_firstLineBox = 0; + m_lastLineBox = 0; + } +} + +void RenderFlow::deleteLastLineBox(RenderArena* arena) +{ + if (m_lastLineBox) { + if (!arena) + arena = renderArena(); + InlineRunBox *curr=m_lastLineBox, *prev = m_lastLineBox; + if (m_firstLineBox == m_lastLineBox) + m_firstLineBox = m_lastLineBox = 0; + else { + prev = curr->prevLineBox(); + while (!prev->isInlineFlowBox()) { + prev = prev->prevLineBox(); + prev->detach(arena); + } + m_lastLineBox = static_cast<InlineFlowBox*>(prev); + prev->setNextLineBox(0); + } + if (curr->parent()) { + curr->parent()->removeFromLine(curr); + } + curr->detach(arena); + } +} + +InlineBox* RenderFlow::createInlineBox(bool makePlaceHolderBox, bool isRootLineBox) +{ + if ( !isRootLineBox && + (isReplaced() || makePlaceHolderBox) ) // Inline tables and inline blocks + return RenderBox::createInlineBox(false, false); // (or positioned element placeholders). + + InlineFlowBox* flowBox = 0; + if (isInlineFlow()) + flowBox = new (renderArena()) InlineFlowBox(this); + else + flowBox = new (renderArena()) RootInlineBox(this); + + if (!m_firstLineBox) { + m_firstLineBox = m_lastLineBox = flowBox; + } else { + m_lastLineBox->setNextLineBox(flowBox); + flowBox->setPreviousLineBox(m_lastLineBox); + m_lastLineBox = flowBox; + } + + return flowBox; +} + +void RenderFlow::paintLines(PaintInfo& i, int _tx, int _ty) +{ + // Only paint during the foreground/selection phases. + if (i.phase != PaintActionForeground && i.phase != PaintActionSelection && i.phase != PaintActionOutline) + return; + + if (!firstLineBox()) + return; + + // We can check the first box and last box and avoid painting if we don't + // intersect. This is a quick short-circuit that we can take to avoid walking any lines. + // FIXME: This check is flawed in two extremely obscure ways. + // (1) If some line in the middle has a huge overflow, it might actually extend below the last line. + // (2) The overflow from an inline block on a line is not reported to the line. + int maxOutlineSize = maximalOutlineSize(i.phase); + int yPos = firstLineBox()->root()->topOverflow() - maxOutlineSize; + int h = maxOutlineSize + lastLineBox()->root()->bottomOverflow() - yPos; + yPos += _ty; + if ((yPos >= i.r.y() + i.r.height()) || (yPos + h <= i.r.y())) + return; + for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextFlowBox()) { + yPos = curr->root()->topOverflow() - maxOutlineSize; + h = curr->root()->bottomOverflow() + maxOutlineSize - yPos; + yPos += _ty; + if ((yPos < i.r.y() + i.r.height()) && (yPos + h > i.r.y())) + curr->paint(i, _tx, _ty); + } + + if (i.phase == PaintActionOutline && i.outlineObjects) { + TQValueList<RenderFlow *>::iterator it;; + for( it = (*i.outlineObjects).begin(); it != (*i.outlineObjects).end(); ++it ) + if ((*it)->isRenderInline()) + static_cast<RenderInline*>(*it)->paintOutlines(i.p, _tx, _ty); + i.outlineObjects->clear(); + } +} + + +bool RenderFlow::hitTestLines(NodeInfo& i, int x, int y, int tx, int ty, HitTestAction hitTestAction) +{ + (void) hitTestAction; + /* + if (hitTestAction != HitTestForeground) // ### port hitTest + return false; + */ + + if (!firstLineBox()) + return false; + + // We can check the first box and last box and avoid hit testing if we don't + // contain the point. This is a quick short-circuit that we can take to avoid walking any lines. + // FIXME: This check is flawed in two extremely obscure ways. + // (1) If some line in the middle has a huge overflow, it might actually extend below the last line. + // (2) The overflow from an inline block on a line is not reported to the line. + if ((y >= ty + lastLineBox()->root()->bottomOverflow()) || (y < ty + firstLineBox()->root()->topOverflow())) + return false; + + // See if our root lines contain the point. If so, then we hit test + // them further. Note that boxes can easily overlap, so we can't make any assumptions + // based off positions of our first line box or our last line box. + for (InlineFlowBox* curr = lastLineBox(); curr; curr = curr->prevFlowBox()) { + if (y >= ty + curr->root()->topOverflow() && y < ty + curr->root()->bottomOverflow()) { + bool inside = curr->nodeAtPoint(i, x, y, tx, ty); + if (inside) { + setInnerNode(i); + return true; + } + } + } + + return false; +} + + +void RenderFlow::repaint(Priority prior) +{ + if (isInlineFlow()) { + // Find our leftmost position. + int left = 0; + // root inline box not reliably availabe during relayout + int top = firstLineBox() ? ( + needsLayout() ? firstLineBox()->xPos() : firstLineBox()->root()->topOverflow() + ) : 0; + for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) + if (curr == firstLineBox() || curr->xPos() < left) + left = curr->xPos(); + + // Now invalidate a rectangle. + int ow = style() ? style()->outlineSize() : 0; + + // We need to add in the relative position offsets of any inlines (including us) up to our + // containing block. + RenderBlock* cb = containingBlock(); + for (RenderObject* inlineFlow = this; inlineFlow && inlineFlow->isInlineFlow() && inlineFlow != cb; + inlineFlow = inlineFlow->parent()) { + if (inlineFlow->style() && inlineFlow->style()->position() == RELATIVE && inlineFlow->layer()) { + KHTMLAssert(inlineFlow->isBox()); + static_cast<RenderBox*>(inlineFlow)->relativePositionOffset(left, top); + } + } + + RootInlineBox *lastRoot = lastLineBox() && !needsLayout() ? lastLineBox()->root() : 0; + containingBlock()->repaintRectangle(-ow+left, -ow+top, + width()+ow*2, + (lastRoot ? lastRoot->bottomOverflow() - top : height())+ow*2, prior); + } + else { + if (firstLineBox() && firstLineBox()->topOverflow() < 0) { + int ow = style() ? style()->outlineSize() : 0; + repaintRectangle(-ow, -ow+firstLineBox()->topOverflow(), + effectiveWidth()+ow*2, effectiveHeight()+ow*2, prior); + } + else + return RenderBox::repaint(prior); + } +} + +int +RenderFlow::lowestPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int bottom = RenderBox::lowestPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return bottom; + + // FIXME: Come up with a way to use the layer tree to avoid visiting all the kids. + // For now, we have to descend into all the children, since we may have a huge abs div inside + // a tiny rel div buried somewhere deep in our child tree. In this case we have to get to + // the abs div. + for (RenderObject *c = firstChild(); c; c = c->nextSibling()) { + if (!c->isFloatingOrPositioned() && !c->isText() && !c->isInlineFlow()) { + int lp = c->yPos() + c->lowestPosition(false); + bottom = kMax(bottom, lp); + } + } + + if (isRelPositioned()) { + int x; + relativePositionOffset(x, bottom); + } + + return bottom; +} + +int RenderFlow::rightmostPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int right = RenderBox::rightmostPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return right; + + // FIXME: Come up with a way to use the layer tree to avoid visiting all the kids. + // For now, we have to descend into all the children, since we may have a huge abs div inside + // a tiny rel div buried somewhere deep in our child tree. In this case we have to get to + // the abs div. + for (RenderObject *c = firstChild(); c; c = c->nextSibling()) { + if (!c->isFloatingOrPositioned() && !c->isText() && !c->isInlineFlow()) { + int rp = c->xPos() + c->rightmostPosition(false); + right = kMax(right, rp); + } + } + + if (isRelPositioned()) { + int y; + relativePositionOffset(right, y); + } + + return right; +} + +int RenderFlow::leftmostPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int left = RenderBox::leftmostPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return left; + + // FIXME: Come up with a way to use the layer tree to avoid visiting all the kids. + // For now, we have to descend into all the children, since we may have a huge abs div inside + // a tiny rel div buried somewhere deep in our child tree. In this case we have to get to + // the abs div. + for (RenderObject *c = firstChild(); c; c = c->nextSibling()) { + if (!c->isFloatingOrPositioned() && !c->isText() && !c->isInlineFlow()) { + int lp = c->xPos() + c->leftmostPosition(false); + left = kMin(left, lp); + } + } + + if (isRelPositioned()) { + int y; + relativePositionOffset(left, y); + } + + return left; +} + +int RenderFlow::highestPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int top = RenderBox::highestPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return top; + + // FIXME: Come up with a way to use the layer tree to avoid visiting all the kids. + // For now, we have to descend into all the children, since we may have a huge abs div inside + // a tiny rel div buried somewhere deep in our child tree. In this case we have to get to + // the abs div. + for (RenderObject *c = firstChild(); c; c = c->nextSibling()) { + if (!c->isFloatingOrPositioned() && !c->isText() && !c->isInlineFlow()) { + int hp = c->yPos() + c->highestPosition(false); + top = kMin(top, hp); + } + } + + if (isRelPositioned()) { + int x; + relativePositionOffset(x, top); + } + + return top; +} diff --git a/tdehtml/rendering/render_flow.h b/tdehtml/rendering/render_flow.h new file mode 100644 index 000000000..684968bc1 --- /dev/null +++ b/tdehtml/rendering/render_flow.h @@ -0,0 +1,96 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999-2003 Antti Koivisto (koivisto@kde.org) + * (C) 2002-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_FLOW_H +#define RENDER_FLOW_H + +#include "render_box.h" +#include "bidi.h" +#include "render_line.h" + +namespace tdehtml { + +/** + * all geometry managing stuff is only in the block elements. + * + * Inline elements don't layout themselves, but the whole paragraph + * gets flowed by the surrounding block element. This is, because + * one needs to know the whole paragraph to calculate bidirectional + * behaviour of text, so putting the layouting routines in the inline + * elements is impossible. + */ +class RenderFlow : public RenderBox +{ +public: + RenderFlow(DOM::NodeImpl* node) + : RenderBox(node) + { m_continuation = 0; m_firstLineBox = 0; m_lastLineBox = 0; } + + virtual RenderFlow* continuation() const { return m_continuation; } + void setContinuation(RenderFlow* c) { m_continuation = c; } + RenderFlow* continuationBefore(RenderObject* beforeChild); + + void addChildWithContinuation(RenderObject* newChild, RenderObject* beforeChild); + virtual void addChildToFlow(RenderObject* newChild, RenderObject* beforeChild) = 0; + virtual void addChild(RenderObject *newChild, RenderObject *beforeChild = 0); + + static RenderFlow* createFlow(DOM::NodeImpl* node, RenderStyle* style, RenderArena* arena); + + virtual void deleteLastLineBox(RenderArena* arena=0); + virtual void deleteInlineBoxes(RenderArena* arena=0); + + + InlineFlowBox* firstLineBox() const { return m_firstLineBox; } + InlineFlowBox* lastLineBox() const { return m_lastLineBox; } + + virtual InlineBox* createInlineBox(bool makePlaceHolderBox, bool isRootLineBox); + + void paintLines(PaintInfo& i, int _tx, int _ty); + bool hitTestLines(NodeInfo& i, int x, int y, int tx, int ty, HitTestAction hitTestAction); + + virtual void repaint(Priority p=NormalPriority); + + virtual int highestPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int lowestPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int rightmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + virtual int leftmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const; + +protected: + // An inline can be split with blocks occurring in between the inline content. + // When this occurs we need a pointer to our next object. We can basically be + // split into a sequence of inlines and blocks. The continuation will either be + // an anonymous block (that houses other blocks) or it will be an inline flow. + RenderFlow* m_continuation; + + // For block flows, each box represents the root inline box for a line in the + // paragraph. + // For inline flows, each box represents a portion of that inline. + InlineFlowBox* m_firstLineBox; + InlineFlowBox* m_lastLineBox; +}; + + +} //namespace + +#endif diff --git a/tdehtml/rendering/render_form.cpp b/tdehtml/rendering/render_form.cpp new file mode 100644 index 000000000..7fe009a7f --- /dev/null +++ b/tdehtml/rendering/render_form.cpp @@ -0,0 +1,1914 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2000 Dirk Mueller (mueller@kde.org) + * (C) 2006 Maksim Orlovich (maksim@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include <kcompletionbox.h> +#include <kcursor.h> +#include <kdebug.h> +#include <kfiledialog.h> +#include <kfind.h> +#include <kfinddialog.h> +#include <kiconloader.h> +#include <klocale.h> +#include <kmessagebox.h> +#include <kreplace.h> +#include <kreplacedialog.h> +#include <tdespell.h> +#include <kurlcompletion.h> +#include <twin.h> + +#include <tqstyle.h> + +#include "misc/helper.h" +#include "xml/dom2_eventsimpl.h" +#include "html/html_formimpl.h" +#include "misc/htmlhashes.h" + +#include "rendering/render_form.h" +#include <assert.h> + +#include "tdehtmlview.h" +#include "tdehtml_ext.h" +#include "xml/dom_docimpl.h" + +#include <tqpopupmenu.h> +#include <tqbitmap.h> + +using namespace tdehtml; + +RenderFormElement::RenderFormElement(HTMLGenericFormElementImpl *element) + : RenderWidget(element) +{ + // init RenderObject attributes + setInline(true); // our object is Inline + + m_state = 0; +} + +RenderFormElement::~RenderFormElement() +{ +} + +short RenderFormElement::baselinePosition( bool f ) const +{ + return RenderWidget::baselinePosition( f ) - 2 - style()->fontMetrics().descent(); +} + +void RenderFormElement::updateFromElement() +{ + m_widget->setEnabled(!element()->disabled()); + RenderWidget::updateFromElement(); +} + +void RenderFormElement::layout() +{ + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + + // minimum height + m_height = 0; + + calcWidth(); + calcHeight(); + + if ( m_widget ) + resizeWidget(m_width-borderLeft()-borderRight()-paddingLeft()-paddingRight(), + m_height-borderTop()-borderBottom()-paddingTop()-paddingBottom()); + + setNeedsLayout(false); +} + +TQ_Alignment RenderFormElement::textAlignment() const +{ + switch (style()->textAlign()) { + case LEFT: + case KHTML_LEFT: + return Qt::AlignLeft; + case RIGHT: + case KHTML_RIGHT: + return Qt::AlignRight; + case CENTER: + case KHTML_CENTER: + return Qt::AlignHCenter; + case JUSTIFY: + // Just fall into the auto code for justify. + case TAAUTO: + return style()->direction() == RTL ? Qt::AlignRight : Qt::AlignLeft; + } + assert(false); // Should never be reached. + return Qt::AlignLeft; +} + +// ------------------------------------------------------------------------- + +RenderButton::RenderButton(HTMLGenericFormElementImpl *element) + : RenderFormElement(element) +{ +} + +short RenderButton::baselinePosition( bool f ) const +{ + return RenderWidget::baselinePosition( f ) - 2; +} + +// ------------------------------------------------------------------------------- + + +RenderCheckBox::RenderCheckBox(HTMLInputElementImpl *element) + : RenderButton(element) +{ + TQCheckBox* b = new TQCheckBox(view()->viewport(), "__tdehtml"); + b->setAutoMask(true); + b->setMouseTracking(true); + setQWidget(b); + + // prevent firing toggled() signals on initialization + b->setChecked(element->checked()); + + connect(b,TQT_SIGNAL(stateChanged(int)),this,TQT_SLOT(slotStateChanged(int))); +} + + +void RenderCheckBox::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + TQCheckBox *cb = static_cast<TQCheckBox *>( m_widget ); + TQSize s( cb->style().pixelMetric( TQStyle::PM_IndicatorWidth ), + cb->style().pixelMetric( TQStyle::PM_IndicatorHeight ) ); + setIntrinsicWidth( s.width() ); + setIntrinsicHeight( s.height() ); + + RenderButton::calcMinMaxWidth(); +} + +void RenderCheckBox::updateFromElement() +{ + widget()->setChecked(element()->checked()); + + RenderButton::updateFromElement(); +} + +void RenderCheckBox::slotStateChanged(int state) +{ + element()->setChecked(state == TQButton::On); + element()->setIndeterminate(state == TQButton::NoChange); + + ref(); + element()->onChange(); + deref(); +} + +// ------------------------------------------------------------------------------- + +RenderRadioButton::RenderRadioButton(HTMLInputElementImpl *element) + : RenderButton(element) +{ + TQRadioButton* b = new TQRadioButton(view()->viewport(), "__tdehtml"); + b->setMouseTracking(true); + setQWidget(b); + + // prevent firing toggled() signals on initialization + b->setChecked(element->checked()); + + connect(b,TQT_SIGNAL(toggled(bool)),this,TQT_SLOT(slotToggled(bool))); +} + +void RenderRadioButton::updateFromElement() +{ + widget()->setChecked(element()->checked()); + + RenderButton::updateFromElement(); +} + +void RenderRadioButton::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + TQRadioButton *rb = static_cast<TQRadioButton *>( m_widget ); + TQSize s( rb->style().pixelMetric( TQStyle::PM_ExclusiveIndicatorWidth ), + rb->style().pixelMetric( TQStyle::PM_ExclusiveIndicatorHeight ) ); + setIntrinsicWidth( s.width() ); + setIntrinsicHeight( s.height() ); + + RenderButton::calcMinMaxWidth(); +} + +void RenderRadioButton::slotToggled(bool activated) +{ + if(activated) { + ref(); + element()->onChange(); + deref(); + } +} + +// ------------------------------------------------------------------------------- + + +RenderSubmitButton::RenderSubmitButton(HTMLInputElementImpl *element) + : RenderButton(element) +{ + TQPushButton* p = new TQPushButton(view()->viewport(), "__tdehtml"); + setQWidget(p); + p->setAutoMask(true); + p->setMouseTracking(true); +} + +TQString RenderSubmitButton::rawText() +{ + TQString value = element()->valueWithDefault().string(); + value = value.stripWhiteSpace(); + TQString raw; + for(unsigned int i = 0; i < value.length(); i++) { + raw += value[i]; + if(value[i] == '&') + raw += '&'; + } + return raw; +} + +void RenderSubmitButton::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + TQString raw = rawText(); + TQPushButton* pb = static_cast<TQPushButton*>(m_widget); + pb->setText(raw); + pb->setFont(style()->font()); + + bool empty = raw.isEmpty(); + if ( empty ) + raw = TQString::fromLatin1("X"); + TQFontMetrics fm = pb->fontMetrics(); + TQSize ts = fm.size( ShowPrefix, raw); + TQSize s(pb->style().tqsizeFromContents( TQStyle::CT_PushButton, pb, ts ) + .expandedTo(TQApplication::globalStrut())); + int margin = pb->style().pixelMetric( TQStyle::PM_ButtonMargin, pb) + + pb->style().pixelMetric( TQStyle::PM_DefaultFrameWidth, pb ) * 2; + int w = ts.width() + margin; + int h = s.height(); + if (pb->isDefault() || pb->autoDefault()) { + int dbw = pb->style().pixelMetric( TQStyle::PM_ButtonDefaultIndicator, pb ) * 2; + w += dbw; + } + + // add 30% margins to the width (heuristics to make it look similar to IE) + s = TQSize( w*13/10, h ).expandedTo(TQApplication::globalStrut()); + + setIntrinsicWidth( s.width() ); + setIntrinsicHeight( s.height() ); + + RenderButton::calcMinMaxWidth(); +} + +void RenderSubmitButton::updateFromElement() +{ + TQString oldText = static_cast<TQPushButton*>(m_widget)->text(); + TQString newText = rawText(); + static_cast<TQPushButton*>(m_widget)->setText(newText); + if ( oldText != newText ) + setNeedsLayoutAndMinMaxRecalc(); + RenderFormElement::updateFromElement(); +} + +short RenderSubmitButton::baselinePosition( bool f ) const +{ + return RenderFormElement::baselinePosition( f ); +} + +// ------------------------------------------------------------------------------- + +RenderResetButton::RenderResetButton(HTMLInputElementImpl *element) + : RenderSubmitButton(element) +{ +} + +// ------------------------------------------------------------------------------- + +LineEditWidget::LineEditWidget(DOM::HTMLInputElementImpl* input, KHTMLView* view, TQWidget* parent) + : KLineEdit(parent, "__tdehtml"), m_input(input), m_view(view), m_spell(0) +{ + setMouseTracking(true); + KActionCollection *ac = new KActionCollection(this); + m_spellAction = KStdAction::spelling( TQT_TQOBJECT(this), TQT_SLOT( slotCheckSpelling() ), ac ); +} + +LineEditWidget::~LineEditWidget() +{ + delete m_spell; + m_spell = 0L; +} + +void LineEditWidget::slotCheckSpelling() +{ + if ( text().isEmpty() ) { + return; + } + + delete m_spell; + m_spell = new KSpell( this, i18n( "Spell Checking" ), TQT_TQOBJECT(this), TQT_SLOT( slotSpellCheckReady( KSpell *) ), 0, true, true); + + connect( m_spell, TQT_SIGNAL( death() ),this, TQT_SLOT( spellCheckerFinished() ) ); + connect( m_spell, TQT_SIGNAL( misspelling( const TQString &, const TQStringList &, unsigned int ) ),this, TQT_SLOT( spellCheckerMisspelling( const TQString &, const TQStringList &, unsigned int ) ) ); + connect( m_spell, TQT_SIGNAL( corrected( const TQString &, const TQString &, unsigned int ) ),this, TQT_SLOT( spellCheckerCorrected( const TQString &, const TQString &, unsigned int ) ) ); +} + +void LineEditWidget::spellCheckerMisspelling( const TQString &_text, const TQStringList &, unsigned int pos) +{ + highLightWord( _text.length(),pos ); +} + +void LineEditWidget::highLightWord( unsigned int length, unsigned int pos ) +{ + setSelection ( pos, length ); +} + +void LineEditWidget::spellCheckerCorrected( const TQString &old, const TQString &corr, unsigned int pos ) +{ + if( old!= corr ) + { + setSelection ( pos, old.length() ); + insert( corr ); + setSelection ( pos, corr.length() ); + } +} + +void LineEditWidget::spellCheckerFinished() +{ +} + +void LineEditWidget::slotSpellCheckReady( KSpell *s ) +{ + s->check( text() ); + connect( s, TQT_SIGNAL( done( const TQString & ) ), this, TQT_SLOT( slotSpellCheckDone( const TQString & ) ) ); +} + +void LineEditWidget::slotSpellCheckDone( const TQString &s ) +{ + if( s != text() ) + setText( s ); +} + + +TQPopupMenu *LineEditWidget::createPopupMenu() +{ + TQPopupMenu *popup = KLineEdit::createPopupMenu(); + + if ( !popup ) { + return 0L; + } + + connect( popup, TQT_SIGNAL( activated( int ) ), + this, TQT_SLOT( extendedMenuActivated( int ) ) ); + + if (m_input->autoComplete()) { + popup->insertSeparator(); + int id = popup->insertItem( SmallIconSet("edit"), i18n("&Edit History..."), EditHistory ); + popup->setItemEnabled( id, (compObj() && !compObj()->isEmpty()) ); + id = popup->insertItem( SmallIconSet("history_clear"), i18n("Clear &History"), ClearHistory ); + popup->setItemEnabled( id, (compObj() && !compObj()->isEmpty()) ); + } + + if (echoMode() == TQLineEdit::Normal && + !isReadOnly()) { + popup->insertSeparator(); + + m_spellAction->plug(popup); + m_spellAction->setEnabled( !text().isEmpty() ); + } + + return popup; +} + + +void LineEditWidget::extendedMenuActivated( int id) +{ + switch ( id ) + { + case ClearHistory: + m_view->clearCompletionHistory(m_input->name().string()); + if (compObj()) + compObj()->clear(); + case EditHistory: + { + KHistoryComboEditor dlg( compObj() ? compObj()->items() : TQStringList(), this ); + connect( &dlg, TQT_SIGNAL( removeFromHistory(const TQString&) ), TQT_SLOT( slotRemoveFromHistory(const TQString&)) ); + dlg.exec(); + } + default: + break; + } +} + +void LineEditWidget::slotRemoveFromHistory(const TQString &entry) +{ + m_view->removeFormCompletionItem(m_input->name().string(), entry); + if (compObj()) + compObj()->removeItem(entry); +} + + +bool LineEditWidget::event( TQEvent *e ) +{ + if (KLineEdit::event(e)) + return true; + + if ( e->type() == TQEvent::AccelAvailable && isReadOnly() ) { + TQKeyEvent* ke = (TQKeyEvent*) e; + if ( ke->state() & ControlButton ) { + switch ( ke->key() ) { + case Key_Left: + case Key_Right: + case Key_Up: + case Key_Down: + case Key_Home: + case Key_End: + ke->accept(); + default: + break; + } + } + } + return false; +} + +void LineEditWidget::mouseMoveEvent(TQMouseEvent *e) +{ + // hack to prevent Qt from calling setCursor on the widget + setDragEnabled(false); + KLineEdit::mouseMoveEvent(e); + setDragEnabled(true); +} + + +// ----------------------------------------------------------------------------- + +RenderLineEdit::RenderLineEdit(HTMLInputElementImpl *element) + : RenderFormElement(element) +{ + LineEditWidget *edit = new LineEditWidget(element, view(), view()->viewport()); + connect(edit,TQT_SIGNAL(returnPressed()), this, TQT_SLOT(slotReturnPressed())); + connect(edit,TQT_SIGNAL(textChanged(const TQString &)),this,TQT_SLOT(slotTextChanged(const TQString &))); + + if(element->inputType() == HTMLInputElementImpl::PASSWORD) + edit->setEchoMode( TQLineEdit::Password ); + + if ( element->autoComplete() ) { + TQStringList completions = view()->formCompletionItems(element->name().string()); + if (completions.count()) { + edit->completionObject()->setItems(completions); + edit->setContextMenuEnabled(true); + edit->completionBox()->setTabHandling( false ); + } + } + + setQWidget(edit); +} + +void RenderLineEdit::setStyle(RenderStyle* _style) +{ + RenderFormElement::setStyle( _style ); + + widget()->setAlignment(textAlignment()); +} + +void RenderLineEdit::highLightWord( unsigned int length, unsigned int pos ) +{ + LineEditWidget* w = static_cast<LineEditWidget*>(m_widget); + if ( w ) + w->highLightWord( length, pos ); +} + + +void RenderLineEdit::slotReturnPressed() +{ + // don't submit the form when return was pressed in a completion-popup + KCompletionBox *box = widget()->completionBox(false); + + if ( box && box->isVisible() && box->currentItem() != -1 ) { + box->hide(); + return; + } + + // Emit onChange if necessary + // Works but might not be enough, dirk said he had another solution at + // hand (can't remember which) - David + handleFocusOut(); + + HTMLFormElementImpl* fe = element()->form(); + if ( fe ) + fe->submitFromKeyboard(); +} + +void RenderLineEdit::handleFocusOut() +{ + if ( widget() && widget()->edited() ) { + element()->onChange(); + widget()->setEdited( false ); + } +} + +void RenderLineEdit::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + const TQFontMetrics &fm = style()->fontMetrics(); + TQSize s; + + int size = element()->size(); + + int h = fm.lineSpacing(); + int w = fm.width( 'x' ) * (size > 0 ? size+1 : 17); // "some" + s = TQSize(w + 2 + 2*widget()->frameWidth(), + kMax(h, 14) + 2 + 2*widget()->frameWidth()) + .expandedTo(TQApplication::globalStrut()); + + setIntrinsicWidth( s.width() ); + setIntrinsicHeight( s.height() ); + + RenderFormElement::calcMinMaxWidth(); +} + +void RenderLineEdit::updateFromElement() +{ + int ml = element()->maxLength(); + if ( ml < 0 ) + ml = 32767; + + if ( widget()->maxLength() != ml ) { + widget()->setMaxLength( ml ); + } + + if (element()->value().string() != widget()->text()) { + widget()->blockSignals(true); + int pos = widget()->cursorPosition(); + widget()->setText(element()->value().string()); + + widget()->setEdited( false ); + + widget()->setCursorPosition(pos); + widget()->blockSignals(false); + } + widget()->setReadOnly(element()->readOnly()); + + RenderFormElement::updateFromElement(); +} + +void RenderLineEdit::slotTextChanged(const TQString &string) +{ + // don't use setValue here! + element()->m_value = string; + element()->m_unsubmittedFormChange = true; +} + +void RenderLineEdit::select() +{ + static_cast<LineEditWidget*>(m_widget)->selectAll(); +} + +long RenderLineEdit::selectionStart() +{ + LineEditWidget* w = static_cast<LineEditWidget*>(m_widget); + if (w->hasSelectedText()) + return w->selectionStart(); + else + return w->cursorPosition(); +} + + +long RenderLineEdit::selectionEnd() +{ + LineEditWidget* w = static_cast<LineEditWidget*>(m_widget); + if (w->hasSelectedText()) + return w->selectionStart() + w->selectedText().length(); + else + return w->cursorPosition(); +} + +void RenderLineEdit::setSelectionStart(long pos) +{ + LineEditWidget* w = static_cast<LineEditWidget*>(m_widget); + //See whether we have a non-empty selection now. + long end = selectionEnd(); + if (end > pos) + w->setSelection(pos, end - pos); + w->setCursorPosition(pos); +} + +void RenderLineEdit::setSelectionEnd(long pos) +{ + LineEditWidget* w = static_cast<LineEditWidget*>(m_widget); + //See whether we have a non-empty selection now. + long start = selectionStart(); + if (start < pos) + w->setSelection(start, pos - start); + + w->setCursorPosition(pos); +} + +void RenderLineEdit::setSelectionRange(long start, long end) +{ + LineEditWidget* w = static_cast<LineEditWidget*>(m_widget); + w->setCursorPosition(end); + w->setSelection(start, end - start); +} + +// --------------------------------------------------------------------------- + +RenderFieldset::RenderFieldset(HTMLGenericFormElementImpl *element) + : RenderBlock(element) +{ +} + +RenderObject* RenderFieldset::layoutLegend(bool relayoutChildren) +{ + RenderObject* legend = findLegend(); + if (legend) { + if (relayoutChildren) + legend->setNeedsLayout(true); + legend->layoutIfNeeded(); + + int xPos = borderLeft() + paddingLeft() + legend->marginLeft(); + if (style()->direction() == RTL) + xPos = m_width - paddingRight() - borderRight() - legend->width() - legend->marginRight(); + int b = borderTop(); + int h = legend->height(); + legend->setPos(xPos, kMax((b-h)/2, 0)); + m_height = kMax(b,h) + paddingTop(); + } + return legend; +} + +RenderObject* RenderFieldset::findLegend() +{ + for (RenderObject* legend = firstChild(); legend; legend = legend->nextSibling()) { + if (!legend->isFloatingOrPositioned() && legend->element() && + legend->element()->id() == ID_LEGEND) + return legend; + } + return 0; +} + +void RenderFieldset::paintBoxDecorations(PaintInfo& pI, int _tx, int _ty) +{ + //kdDebug( 6040 ) << renderName() << "::paintDecorations()" << endl; + + RenderObject* legend = findLegend(); + if (!legend) + return RenderBlock::paintBoxDecorations(pI, _tx, _ty); + + int w = width(); + int h = height() + borderTopExtra() + borderBottomExtra(); + int yOff = (legend->yPos() > 0) ? 0 : (legend->height()-borderTop())/2; + h -= yOff; + _ty += yOff - borderTopExtra(); + + int my = kMax(_ty,pI.r.y()); + int end = kMin( pI.r.y() + pI.r.height(), _ty + h ); + int mh = end - my; + + paintBackground(pI.p, style()->backgroundColor(), style()->backgroundLayers(), my, mh, _tx, _ty, w, h); + + if ( style()->hasBorder() ) + paintBorderMinusLegend(pI.p, _tx, _ty, w, h, style(), legend->xPos(), legend->width()); +} + +void RenderFieldset::paintBorderMinusLegend(TQPainter *p, int _tx, int _ty, int w, int h, + const RenderStyle* style, int lx, int lw) +{ + + const TQColor& tc = style->borderTopColor(); + const TQColor& bc = style->borderBottomColor(); + + EBorderStyle ts = style->borderTopStyle(); + EBorderStyle bs = style->borderBottomStyle(); + EBorderStyle ls = style->borderLeftStyle(); + EBorderStyle rs = style->borderRightStyle(); + + bool render_t = ts > BHIDDEN; + bool render_l = ls > BHIDDEN; + bool render_r = rs > BHIDDEN; + bool render_b = bs > BHIDDEN; + + if(render_t) { + drawBorder(p, _tx, _ty, _tx + lx, _ty + style->borderTopWidth(), BSTop, tc, style->color(), ts, + (render_l && (ls == DOTTED || ls == DASHED || ls == DOUBLE)?style->borderLeftWidth():0), 0); + drawBorder(p, _tx+lx+lw, _ty, _tx + w, _ty + style->borderTopWidth(), BSTop, tc, style->color(), ts, + 0, (render_r && (rs == DOTTED || rs == DASHED || rs == DOUBLE)?style->borderRightWidth():0)); + } + + if(render_b) + drawBorder(p, _tx, _ty + h - style->borderBottomWidth(), _tx + w, _ty + h, BSBottom, bc, style->color(), bs, + (render_l && (ls == DOTTED || ls == DASHED || ls == DOUBLE)?style->borderLeftWidth():0), + (render_r && (rs == DOTTED || rs == DASHED || rs == DOUBLE)?style->borderRightWidth():0)); + + if(render_l) + { + const TQColor& lc = style->borderLeftColor(); + + bool ignore_top = + (tc == lc) && + (ls >= OUTSET) && + (ts == DOTTED || ts == DASHED || ts == SOLID || ts == OUTSET); + + bool ignore_bottom = + (bc == lc) && + (ls >= OUTSET) && + (bs == DOTTED || bs == DASHED || bs == SOLID || bs == INSET); + + drawBorder(p, _tx, _ty, _tx + style->borderLeftWidth(), _ty + h, BSLeft, lc, style->color(), ls, + ignore_top?0:style->borderTopWidth(), + ignore_bottom?0:style->borderBottomWidth()); + } + + if(render_r) + { + const TQColor& rc = style->borderRightColor(); + + bool ignore_top = + (tc == rc) && + (rs >= DOTTED || rs == INSET) && + (ts == DOTTED || ts == DASHED || ts == SOLID || ts == OUTSET); + + bool ignore_bottom = + (bc == rc) && + (rs >= DOTTED || rs == INSET) && + (bs == DOTTED || bs == DASHED || bs == SOLID || bs == INSET); + + drawBorder(p, _tx + w - style->borderRightWidth(), _ty, _tx + w, _ty + h, BSRight, rc, style->color(), rs, + ignore_top?0:style->borderTopWidth(), + ignore_bottom?0:style->borderBottomWidth()); + } +} + +void RenderFieldset::setStyle(RenderStyle* _style) +{ + RenderBlock::setStyle(_style); + + // WinIE renders fieldsets with display:inline like they're inline-blocks. For us, + // an inline-block is just a block element with replaced set to true and inline set + // to true. Ensure that if we ended up being inline that we set our replaced flag + // so that we're treated like an inline-block. + if (isInline()) + setReplaced(true); +} + +// ------------------------------------------------------------------------- + +RenderFileButton::RenderFileButton(HTMLInputElementImpl *element) + : RenderFormElement(element) +{ + KURLRequester* w = new KURLRequester( view()->viewport(), "__tdehtml" ); + + w->setMode(KFile::File | KFile::ExistingOnly); + w->completionObject()->setDir(TDEGlobalSettings::documentPath()); + + connect(w->lineEdit(), TQT_SIGNAL(returnPressed()), this, TQT_SLOT(slotReturnPressed())); + connect(w->lineEdit(), TQT_SIGNAL(textChanged(const TQString &)),this,TQT_SLOT(slotTextChanged(const TQString &))); + connect(w, TQT_SIGNAL(urlSelected(const TQString &)),this,TQT_SLOT(slotUrlSelected(const TQString &))); + + setQWidget(w); + m_haveFocus = false; +} + + + +void RenderFileButton::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + const TQFontMetrics &fm = style()->fontMetrics(); + int size = element()->size(); + + int h = fm.lineSpacing(); + int w = fm.width( 'x' ) * (size > 0 ? size+1 : 17); // "some" + KLineEdit* edit = static_cast<KURLRequester*>( m_widget )->lineEdit(); + TQSize s = edit->style().tqsizeFromContents(TQStyle::CT_LineEdit, + edit, + TQSize(w + 2 + 2*edit->frameWidth(), kMax(h, 14) + 2 + 2*edit->frameWidth())) + .expandedTo(TQApplication::globalStrut()); + TQSize bs = static_cast<KURLRequester*>( m_widget )->minimumSizeHint() - edit->minimumSizeHint(); + + setIntrinsicWidth( s.width() + bs.width() ); + setIntrinsicHeight( kMax(s.height(), bs.height()) ); + + RenderFormElement::calcMinMaxWidth(); +} + +void RenderFileButton::handleFocusOut() +{ + if ( widget()->lineEdit() && widget()->lineEdit()->edited() ) { + element()->onChange(); + widget()->lineEdit()->setEdited( false ); + } +} + +void RenderFileButton::updateFromElement() +{ + KLineEdit* edit = widget()->lineEdit(); + edit->blockSignals(true); + edit->setText(element()->value().string()); + edit->blockSignals(false); + edit->setEdited( false ); + + RenderFormElement::updateFromElement(); +} + +void RenderFileButton::slotReturnPressed() +{ + handleFocusOut(); + + if (element()->form()) + element()->form()->submitFromKeyboard(); +} + +void RenderFileButton::slotTextChanged(const TQString &/*string*/) +{ + element()->m_value = KURL( widget()->url() ).prettyURL( 0, KURL::StripFileProtocol ); +} + +void RenderFileButton::slotUrlSelected(const TQString &) +{ + element()->onChange(); +} + +void RenderFileButton::select() +{ + widget()->lineEdit()->selectAll(); +} + +// ------------------------------------------------------------------------- + +RenderLabel::RenderLabel(HTMLGenericFormElementImpl *element) + : RenderFormElement(element) +{ + +} + +// ------------------------------------------------------------------------- + +RenderLegend::RenderLegend(HTMLGenericFormElementImpl *element) + : RenderBlock(element) +{ +} + +// ------------------------------------------------------------------------------- + +ComboBoxWidget::ComboBoxWidget(TQWidget *parent) + : KComboBox(false, parent, "__tdehtml") +{ + setAutoMask(true); + if (listBox()) listBox()->installEventFilter(this); + setMouseTracking(true); +} + +bool ComboBoxWidget::event(TQEvent *e) +{ + if (KComboBox::event(e)) + return true; + if (e->type()==TQEvent::KeyPress) + { + TQKeyEvent *ke = TQT_TQKEYEVENT(e); + switch(ke->key()) + { + case Key_Return: + case Key_Enter: + popup(); + ke->accept(); + return true; + default: + return false; + } + } + return false; +} + +bool ComboBoxWidget::eventFilter(TQObject *dest, TQEvent *e) +{ + if (TQT_BASE_OBJECT(dest)==TQT_BASE_OBJECT(listBox()) && e->type()==TQEvent::KeyPress) + { + TQKeyEvent *ke = TQT_TQKEYEVENT(e); + bool forward = false; + switch(ke->key()) + { + case Key_Tab: + forward=true; + case Key_BackTab: + // ugly hack. emulate popdownlistbox() (private in TQComboBox) + // we re-use ke here to store the reference to the generated event. + ke = new TQKeyEvent(TQEvent::KeyPress, Key_Escape, 0, 0); + TQApplication::sendEvent(dest,ke); + focusNextPrevChild(forward); + delete ke; + return true; + default: + return KComboBox::eventFilter(dest, e); + } + } + return KComboBox::eventFilter(dest, e); +} + +// ------------------------------------------------------------------------- + +RenderSelect::RenderSelect(HTMLSelectElementImpl *element) + : RenderFormElement(element) +{ + m_ignoreSelectEvents = false; + m_multiple = element->multiple(); + m_size = element->size(); + m_useListBox = (m_multiple || m_size > 1); + m_selectionChanged = true; + m_optionsChanged = true; + + if(m_useListBox) + setQWidget(createListBox()); + else + setQWidget(createComboBox()); +} + +void RenderSelect::updateFromElement() +{ + m_ignoreSelectEvents = true; + + // change widget type + bool oldMultiple = m_multiple; + unsigned oldSize = m_size; + bool oldListbox = m_useListBox; + + m_multiple = element()->multiple(); + m_size = element()->size(); + m_useListBox = (m_multiple || m_size > 1); + + if (oldMultiple != m_multiple || oldSize != m_size) { + if (m_useListBox != oldListbox) { + // type of select has changed + if(m_useListBox) + setQWidget(createListBox()); + else + setQWidget(createComboBox()); + } + + if (m_useListBox && oldMultiple != m_multiple) { + static_cast<KListBox*>(m_widget)->setSelectionMode(m_multiple ? TQListBox::Extended : TQListBox::Single); + } + m_selectionChanged = true; + m_optionsChanged = true; + } + + // update contents listbox/combobox based on options in m_element + if ( m_optionsChanged ) { + if (element()->m_recalcListItems) + element()->recalcListItems(); + TQMemArray<HTMLGenericFormElementImpl*> listItems = element()->listItems(); + int listIndex; + + if(m_useListBox) { + static_cast<KListBox*>(m_widget)->clear(); + } + + else + static_cast<KComboBox*>(m_widget)->clear(); + + for (listIndex = 0; listIndex < int(listItems.size()); listIndex++) { + if (listItems[listIndex]->id() == ID_OPTGROUP) { + DOMString text = listItems[listIndex]->getAttribute(ATTR_LABEL); + if (text.isNull()) + text = ""; + + if(m_useListBox) { + TQListBoxText *item = new TQListBoxText(TQString(text.implementation()->s, text.implementation()->l)); + static_cast<KListBox*>(m_widget) + ->insertItem(item, listIndex); + item->setSelectable(false); + } + else { + static_cast<KComboBox*>(m_widget) + ->insertItem(TQString(text.implementation()->s, text.implementation()->l), listIndex); + static_cast<KComboBox*>(m_widget)->listBox()->item(listIndex)->setSelectable(false); + } + } + else if (listItems[listIndex]->id() == ID_OPTION) { + HTMLOptionElementImpl* optElem = static_cast<HTMLOptionElementImpl*>(listItems[listIndex]); + TQString text = optElem->text().string(); + if (optElem->parentNode()->id() == ID_OPTGROUP) + { + // Prefer label if set + DOMString label = optElem->getAttribute(ATTR_LABEL); + if (!label.isEmpty()) + text = label.string(); + text = TQString::fromLatin1(" ")+text; + } + + if(m_useListBox) { + KListBox *l = static_cast<KListBox*>(m_widget); + l->insertItem(text, listIndex); + DOMString disabled = optElem->getAttribute(ATTR_DISABLED); + if (!disabled.isNull() && l->item( listIndex )) { + l->item( listIndex )->setSelectable( false ); + } + } else + static_cast<KComboBox*>(m_widget)->insertItem(text, listIndex); + } + else + KHTMLAssert(false); + m_selectionChanged = true; + } + + // TQComboBox caches the size hint unless you call setFont (ref: TT docu) + if(!m_useListBox) { + KComboBox *that = static_cast<KComboBox*>(m_widget); + that->setFont( that->font() ); + } + setNeedsLayoutAndMinMaxRecalc(); + m_optionsChanged = false; + } + + // update selection + if (m_selectionChanged) { + updateSelection(); + } + + + m_ignoreSelectEvents = false; + + RenderFormElement::updateFromElement(); +} + +void RenderSelect::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + if (m_optionsChanged) + updateFromElement(); + + // ### ugly HACK FIXME!!! + setMinMaxKnown(); + layoutIfNeeded(); + setNeedsLayoutAndMinMaxRecalc(); + // ### end FIXME + + RenderFormElement::calcMinMaxWidth(); +} + +void RenderSelect::layout( ) +{ + KHTMLAssert(needsLayout()); + KHTMLAssert(minMaxKnown()); + + // ### maintain selection properly between type/size changes, and work + // out how to handle multiselect->singleselect (probably just select + // first selected one) + + // calculate size + if(m_useListBox) { + KListBox* w = static_cast<KListBox*>(m_widget); + + TQListBoxItem* p = w->firstItem(); + int width = 0; + int height = 0; + while(p) { + width = kMax(width, p->width(p->listBox())); + height = kMax(height, p->height(p->listBox())); + p = p->next(); + } + if ( !height ) + height = w->fontMetrics().height(); + if ( !width ) + width = w->fontMetrics().width( 'x' ); + + int size = m_size; + // check if multiple and size was not given or invalid + // Internet Exploder sets size to kMin(number of elements, 4) + // Netscape seems to simply set it to "number of elements" + // the average of that is IMHO kMin(number of elements, 10) + // so I did that ;-) + if(size < 1) + size = kMin(static_cast<KListBox*>(m_widget)->count(), 10u); + + width += 2*w->frameWidth() + w->verticalScrollBar()->sizeHint().width(); + height = size*height + 2*w->frameWidth(); + + setIntrinsicWidth( width ); + setIntrinsicHeight( height ); + } + else { + TQSize s(m_widget->sizeHint()); + setIntrinsicWidth( s.width() ); + setIntrinsicHeight( s.height() ); + } + + /// uuh, ignore the following line.. + setNeedsLayout(true); + RenderFormElement::layout(); + + // and now disable the widget in case there is no <option> given + TQMemArray<HTMLGenericFormElementImpl*> listItems = element()->listItems(); + + bool foundOption = false; + for (uint i = 0; i < listItems.size() && !foundOption; i++) + foundOption = (listItems[i]->id() == ID_OPTION); + + m_widget->setEnabled(foundOption && ! element()->disabled()); +} + +void RenderSelect::slotSelected(int index) // emitted by the combobox only +{ + if ( m_ignoreSelectEvents ) return; + + KHTMLAssert( !m_useListBox ); + + TQMemArray<HTMLGenericFormElementImpl*> listItems = element()->listItems(); + if(index >= 0 && index < int(listItems.size())) + { + bool found = ( listItems[index]->id() == ID_OPTION ); + + if ( !found ) { + // this one is not selectable, we need to find an option element + while ( ( unsigned ) index < listItems.size() ) { + if ( listItems[index]->id() == ID_OPTION ) { + found = true; + break; + } + ++index; + } + + if ( !found ) { + while ( index >= 0 ) { + if ( listItems[index]->id() == ID_OPTION ) { + found = true; + break; + } + --index; + } + } + } + + if ( found ) { + bool changed = false; + + for ( unsigned int i = 0; i < listItems.size(); ++i ) + if ( listItems[i]->id() == ID_OPTION && i != (unsigned int) index ) + { + HTMLOptionElementImpl* opt = static_cast<HTMLOptionElementImpl*>( listItems[i] ); + changed |= (opt->m_selected == true); + opt->m_selected = false; + } + + HTMLOptionElementImpl* opt = static_cast<HTMLOptionElementImpl*>(listItems[index]); + changed |= (opt->m_selected == false); + opt->m_selected = true; + + if ( index != static_cast<ComboBoxWidget*>( m_widget )->currentItem() ) + static_cast<ComboBoxWidget*>( m_widget )->setCurrentItem( index ); + + // When selecting an optgroup item, and we move forward to we + // shouldn't emit onChange. Hence this bool, the if above doesn't do it. + if ( changed ) + { + ref(); + element()->onChange(); + deref(); + } + } + } +} + + +void RenderSelect::slotSelectionChanged() // emitted by the listbox only +{ + if ( m_ignoreSelectEvents ) return; + + // don't use listItems() here as we have to avoid recalculations - changing the + // option list will make use update options not in the way the user expects them + TQMemArray<HTMLGenericFormElementImpl*> listItems = element()->m_listItems; + for ( unsigned i = 0; i < listItems.count(); i++ ) + // don't use setSelected() here because it will cause us to be called + // again with updateSelection. + if ( listItems[i]->id() == ID_OPTION ) + static_cast<HTMLOptionElementImpl*>( listItems[i] ) + ->m_selected = static_cast<KListBox*>( m_widget )->isSelected( i ); + + ref(); + element()->onChange(); + deref(); +} + +void RenderSelect::setOptionsChanged(bool _optionsChanged) +{ + m_optionsChanged = _optionsChanged; +} + +KListBox* RenderSelect::createListBox() +{ + KListBox *lb = new KListBox(view()->viewport(), "__tdehtml"); + lb->setSelectionMode(m_multiple ? TQListBox::Extended : TQListBox::Single); + // ### looks broken + //lb->setAutoMask(true); + connect( lb, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotSelectionChanged() ) ); +// connect( lb, TQT_SIGNAL( clicked( TQListBoxItem * ) ), this, TQT_SLOT( slotClicked() ) ); + m_ignoreSelectEvents = false; + lb->setMouseTracking(true); + + return lb; +} + +ComboBoxWidget *RenderSelect::createComboBox() +{ + ComboBoxWidget *cb = new ComboBoxWidget(view()->viewport()); + connect(cb, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotSelected(int))); + return cb; +} + +void RenderSelect::updateSelection() +{ + TQMemArray<HTMLGenericFormElementImpl*> listItems = element()->listItems(); + int i; + if (m_useListBox) { + // if multi-select, we select only the new selected index + KListBox *listBox = static_cast<KListBox*>(m_widget); + for (i = 0; i < int(listItems.size()); i++) + listBox->setSelected(i,listItems[i]->id() == ID_OPTION && + static_cast<HTMLOptionElementImpl*>(listItems[i])->selected()); + } + else { + bool found = false; + unsigned firstOption = listItems.size(); + i = listItems.size(); + while (i--) + if (listItems[i]->id() == ID_OPTION) { + if (found) + static_cast<HTMLOptionElementImpl*>(listItems[i])->m_selected = false; + else if (static_cast<HTMLOptionElementImpl*>(listItems[i])->selected()) { + static_cast<KComboBox*>( m_widget )->setCurrentItem(i); + found = true; + } + firstOption = i; + } + + Q_ASSERT(firstOption == listItems.size() || found); + } + + m_selectionChanged = false; +} + + +// ------------------------------------------------------------------------- + +TextAreaWidget::TextAreaWidget(int wrap, TQWidget* parent) + : KTextEdit(parent, "__tdehtml"), m_findDlg(0), m_find(0), m_repDlg(0), m_replace(0) +{ + if(wrap != DOM::HTMLTextAreaElementImpl::ta_NoWrap) { + setWordWrap(TQTextEdit::WidgetWidth); + setHScrollBarMode( AlwaysOff ); + setVScrollBarMode( AlwaysOn ); + } + else { + setWordWrap(TQTextEdit::NoWrap); + setHScrollBarMode( Auto ); + setVScrollBarMode( Auto ); + } + KCursor::setAutoHideCursor(viewport(), true); + setTextFormat(TQTextEdit::PlainText); + setAutoMask(true); + setMouseTracking(true); + + KActionCollection *ac = new KActionCollection(this); + m_findAction = KStdAction::find( TQT_TQOBJECT(this), TQT_SLOT( slotFind() ), ac ); + m_findNextAction = KStdAction::findNext( TQT_TQOBJECT(this), TQT_SLOT( slotFindNext() ), ac ); + m_replaceAction = KStdAction::replace( TQT_TQOBJECT(this), TQT_SLOT( slotReplace() ), ac ); +} + + +TextAreaWidget::~TextAreaWidget() +{ + delete m_replace; + m_replace = 0L; + delete m_find; + m_find = 0L; + delete m_repDlg; + m_repDlg = 0L; + delete m_findDlg; + m_findDlg = 0L; +} + + +TQPopupMenu *TextAreaWidget::createPopupMenu(const TQPoint& pos) +{ + TQPopupMenu *popup = KTextEdit::createPopupMenu(pos); + + if ( !popup ) { + return 0L; + } + + if (!isReadOnly()) { + popup->insertSeparator(); + + m_findAction->plug(popup); + m_findAction->setEnabled( !text().isEmpty() ); + + m_findNextAction->plug(popup); + m_findNextAction->setEnabled( m_find != 0 ); + + m_replaceAction->plug(popup); + m_replaceAction->setEnabled( !text().isEmpty() ); + } + + return popup; +} + + +void TextAreaWidget::slotFindHighlight(const TQString& text, int matchingIndex, int matchingLength) +{ + Q_UNUSED(text) + //kdDebug() << "Highlight: [" << text << "] mi:" << matchingIndex << " ml:" << matchingLength << endl; + if (sender() == m_replace) { + setSelection(m_repPara, matchingIndex, m_repPara, matchingIndex + matchingLength); + setCursorPosition(m_repPara, matchingIndex); + } else { + setSelection(m_findPara, matchingIndex, m_findPara, matchingIndex + matchingLength); + setCursorPosition(m_findPara, matchingIndex); + } + ensureCursorVisible(); +} + + +void TextAreaWidget::slotReplaceText(const TQString &text, int replacementIndex, int /*replacedLength*/, int matchedLength) { + Q_UNUSED(text) + //kdDebug() << "Replace: [" << text << "] ri:" << replacementIndex << " rl:" << replacedLength << " ml:" << matchedLength << endl; + setSelection(m_repPara, replacementIndex, m_repPara, replacementIndex + matchedLength); + removeSelectedText(); + insertAt(m_repDlg->replacement(), m_repPara, replacementIndex); + if (m_replace->options() & KReplaceDialog::PromptOnReplace) { + ensureCursorVisible(); + } +} + + +void TextAreaWidget::slotDoReplace() +{ + if (!m_repDlg) { + // Should really assert() + return; + } + + delete m_replace; + m_replace = new KReplace(m_repDlg->pattern(), m_repDlg->replacement(), m_repDlg->options(), this); + if (m_replace->options() & KFindDialog::FromCursor) { + getCursorPosition(&m_repPara, &m_repIndex); + } else if (m_replace->options() & KFindDialog::FindBackwards) { + m_repPara = paragraphs() - 1; + m_repIndex = paragraphLength(m_repPara) - 1; + } else { + m_repPara = 0; + m_repIndex = 0; + } + + // Connect highlight signal to code which handles highlighting + // of found text. + connect(m_replace, TQT_SIGNAL(highlight(const TQString &, int, int)), + this, TQT_SLOT(slotFindHighlight(const TQString &, int, int))); + connect(m_replace, TQT_SIGNAL(findNext()), this, TQT_SLOT(slotReplaceNext())); + connect(m_replace, TQT_SIGNAL(replace(const TQString &, int, int, int)), + this, TQT_SLOT(slotReplaceText(const TQString &, int, int, int))); + + m_repDlg->close(); + slotReplaceNext(); +} + + +void TextAreaWidget::slotReplaceNext() +{ + if (!m_replace) { + // assert? + return; + } + + if (!(m_replace->options() & KReplaceDialog::PromptOnReplace)) { + viewport()->setUpdatesEnabled(false); + } + + KFind::Result res = KFind::NoMatch; + while (res == KFind::NoMatch) { + // If we're done..... + if (m_replace->options() & KFindDialog::FindBackwards) { + if (m_repIndex == 0 && m_repPara == 0) { + break; + } + } else { + if (m_repPara == paragraphs() - 1 && + m_repIndex == paragraphLength(m_repPara) - 1) { + break; + } + } + + if (m_replace->needData()) { + m_replace->setData(text(m_repPara), m_repIndex); + } + + res = m_replace->replace(); + + if (res == KFind::NoMatch) { + if (m_replace->options() & KFindDialog::FindBackwards) { + if (m_repPara == 0) { + m_repIndex = 0; + } else { + m_repPara--; + m_repIndex = paragraphLength(m_repPara) - 1; + } + } else { + if (m_repPara == paragraphs() - 1) { + m_repIndex = paragraphLength(m_repPara) - 1; + } else { + m_repPara++; + m_repIndex = 0; + } + } + } + } + + if (!(m_replace->options() & KReplaceDialog::PromptOnReplace)) { + viewport()->setUpdatesEnabled(true); + repaintChanged(); + } + + if (res == KFind::NoMatch) { // at end + m_replace->displayFinalDialog(); + delete m_replace; + m_replace = 0; + ensureCursorVisible(); + //or if ( m_replace->shouldRestart() ) { reinit (w/o FromCursor) and call slotReplaceNext(); } + } else { + //m_replace->closeReplaceNextDialog(); + } +} + + +void TextAreaWidget::slotDoFind() +{ + if (!m_findDlg) { + // Should really assert() + return; + } + + delete m_find; + m_find = new KFind(m_findDlg->pattern(), m_findDlg->options(), this); + if (m_find->options() & KFindDialog::FromCursor) { + getCursorPosition(&m_findPara, &m_findIndex); + } else if (m_find->options() & KFindDialog::FindBackwards) { + m_findPara = paragraphs() - 1; + m_findIndex = paragraphLength(m_findPara) - 1; + } else { + m_findPara = 0; + m_findIndex = 0; + } + + // Connect highlight signal to code which handles highlighting + // of found text. + connect(m_find, TQT_SIGNAL(highlight(const TQString &, int, int)), + this, TQT_SLOT(slotFindHighlight(const TQString &, int, int))); + connect(m_find, TQT_SIGNAL(findNext()), this, TQT_SLOT(slotFindNext())); + + m_findDlg->close(); + m_find->closeFindNextDialog(); + slotFindNext(); +} + + +void TextAreaWidget::slotFindNext() +{ + if (!m_find) { + // assert? + return; + } + + KFind::Result res = KFind::NoMatch; + while (res == KFind::NoMatch) { + // If we're done..... + if (m_find->options() & KFindDialog::FindBackwards) { + if (m_findIndex == 0 && m_findPara == 0) { + break; + } + } else { + if (m_findPara == paragraphs() - 1 && + m_findIndex == paragraphLength(m_findPara) - 1) { + break; + } + } + + if (m_find->needData()) { + m_find->setData(text(m_findPara), m_findIndex); + } + + res = m_find->find(); + + if (res == KFind::NoMatch) { + if (m_find->options() & KFindDialog::FindBackwards) { + if (m_findPara == 0) { + m_findIndex = 0; + } else { + m_findPara--; + m_findIndex = paragraphLength(m_findPara) - 1; + } + } else { + if (m_findPara == paragraphs() - 1) { + m_findIndex = paragraphLength(m_findPara) - 1; + } else { + m_findPara++; + m_findIndex = 0; + } + } + } + } + + if (res == KFind::NoMatch) { // at end + m_find->displayFinalDialog(); + delete m_find; + m_find = 0; + //or if ( m_find->shouldRestart() ) { reinit (w/o FromCursor) and call slotFindNext(); } + } else { + //m_find->closeFindNextDialog(); + } +} + + +void TextAreaWidget::slotFind() +{ + if( text().isEmpty() ) // saves having to track the text changes + return; + + if ( m_findDlg ) { + KWin::activateWindow( m_findDlg->winId() ); + } else { + m_findDlg = new KFindDialog(false, this, "KHTML Text Area Find Dialog"); + connect( m_findDlg, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotDoFind()) ); + } + m_findDlg->show(); +} + + +void TextAreaWidget::slotReplace() +{ + if( text().isEmpty() ) // saves having to track the text changes + return; + + if ( m_repDlg ) { + KWin::activateWindow( m_repDlg->winId() ); + } else { + m_repDlg = new KReplaceDialog(this, "KHTMLText Area Replace Dialog", 0, + TQStringList(), TQStringList(), false); + connect( m_repDlg, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotDoReplace()) ); + } + m_repDlg->show(); +} + + +bool TextAreaWidget::event( TQEvent *e ) +{ + if ( e->type() == TQEvent::AccelAvailable && isReadOnly() ) { + TQKeyEvent* ke = (TQKeyEvent*) e; + if ( ke->state() & ControlButton ) { + switch ( ke->key() ) { + case Key_Left: + case Key_Right: + case Key_Up: + case Key_Down: + case Key_Home: + case Key_End: + ke->accept(); + default: + break; + } + } + } + return KTextEdit::event( e ); +} + +// ------------------------------------------------------------------------- + +RenderTextArea::RenderTextArea(HTMLTextAreaElementImpl *element) + : RenderFormElement(element) +{ + scrollbarsStyled = false; + + TextAreaWidget *edit = new TextAreaWidget(element->wrap(), view()); + setQWidget(edit); + const KHTMLSettings *settings = view()->part()->settings(); + edit->setCheckSpellingEnabled( settings->autoSpellCheck() ); + edit->setTabChangesFocus( ! settings->allowTabulation() ); + + connect(edit,TQT_SIGNAL(textChanged()),this,TQT_SLOT(slotTextChanged())); +} + +RenderTextArea::~RenderTextArea() +{ + if ( element()->m_dirtyvalue ) { + element()->m_value = text(); + element()->m_dirtyvalue = false; + } +} + +void RenderTextArea::handleFocusOut() +{ + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + if ( w && element()->m_dirtyvalue ) { + element()->m_value = text(); + element()->m_dirtyvalue = false; + } + + if ( w && element()->m_changed ) { + element()->m_changed = false; + element()->onChange(); + } +} + +void RenderTextArea::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + const TQFontMetrics &m = style()->fontMetrics(); + w->setTabStopWidth(8 * m.width(" ")); + TQSize size( kMax(element()->cols(), 1L)*m.width('x') + w->frameWidth() + + w->verticalScrollBar()->sizeHint().width(), + kMax(element()->rows(), 1L)*m.lineSpacing() + w->frameWidth()*4 + + (w->wordWrap() == TQTextEdit::NoWrap ? + w->horizontalScrollBar()->sizeHint().height() : 0) + ); + + setIntrinsicWidth( size.width() ); + setIntrinsicHeight( size.height() ); + + RenderFormElement::calcMinMaxWidth(); +} + +void RenderTextArea::setStyle(RenderStyle* _style) +{ + bool unsubmittedFormChange = element()->m_unsubmittedFormChange; + + RenderFormElement::setStyle(_style); + + widget()->blockSignals(true); + widget()->setAlignment(textAlignment()); + widget()->blockSignals(false); + + scrollbarsStyled = false; + + element()->m_unsubmittedFormChange = unsubmittedFormChange; +} + +void RenderTextArea::layout() +{ + KHTMLAssert( needsLayout() ); + + RenderFormElement::layout(); + + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + + if (!scrollbarsStyled) { + w->horizontalScrollBar()->setPalette(style()->palette()); + w->verticalScrollBar()->setPalette(style()->palette()); + scrollbarsStyled=true; + } +} + +void RenderTextArea::updateFromElement() +{ + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + w->setReadOnly(element()->readOnly()); + TQString elementText = element()->value().string(); + if ( elementText != text() ) + { + w->blockSignals(true); + int line, col; + w->getCursorPosition( &line, &col ); + int cx = w->contentsX(); + int cy = w->contentsY(); + w->setText( elementText ); + w->setCursorPosition( line, col ); + w->scrollBy( cx, cy ); + w->blockSignals(false); + } + element()->m_dirtyvalue = false; + + RenderFormElement::updateFromElement(); +} + +void RenderTextArea::close( ) +{ + element()->setValue( element()->defaultValue() ); + + RenderFormElement::close(); +} + + +TQString RenderTextArea::text() +{ + TQString txt; + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + + if(element()->wrap() == DOM::HTMLTextAreaElementImpl::ta_Physical) { + // yeah, TQTextEdit has no accessor for getting the visually wrapped text + for (int p=0; p < w->paragraphs(); ++p) { + int ll = 0; + int lindex = w->lineOfChar(p, 0); + TQString paragraphText = w->text(p); + int pl = w->paragraphLength(p); + paragraphText = paragraphText.left(pl); //Snip invented space. + for (int l = 0; l < pl; ++l) { + if (lindex != w->lineOfChar(p, l)) { + paragraphText.insert(l+ll++, TQString::fromLatin1("\n")); + lindex = w->lineOfChar(p, l); + } + } + txt += paragraphText; + if (p < w->paragraphs() - 1) + txt += TQString::fromLatin1("\n"); + } + } + else + txt = w->text(); + + return txt; +} + +int RenderTextArea::queryParagraphInfo(int para, Mode m, int param) { + /* We have to be a bit careful here, as we need to match up the positions + to what our value returns here*/ + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + int length = 0; + + bool physWrap = element()->wrap() == DOM::HTMLTextAreaElementImpl::ta_Physical; + + TQString paragraphText = w->text(para); + int pl = w->paragraphLength(para); + int physicalPL = pl; + if (m == ParaPortionLength) + pl = param; + + if (physWrap) { + //Go through all the chars of paragraph, and count line changes, chars, etc. + int lindex = w->lineOfChar(para, 0); + for (int c = 0; c < pl; ++c) { + ++length; + // Is there a change after this char? + if (c+1 < physicalPL && lindex != w->lineOfChar(para, c+1)) { + lindex = w->lineOfChar(para, c+1); + ++length; + } + if (m == ParaPortionOffset && length > param) + return c; + } + } else { + //Make sure to count the LF, CR as appropriate. ### this is stupid now, simplify + for (int c = 0; c < pl; ++c) { + ++length; + if (m == ParaPortionOffset && length > param) + return c; + } + } + if (m == ParaPortionOffset) + return pl; + if (m == ParaPortionLength) + return length; + return length + 1; +} + +long RenderTextArea::computeCharOffset(int para, int index) { + if (para < 0) + return 0; + + long pos = 0; + for (int cp = 0; cp < para; ++cp) + pos += queryParagraphInfo(cp, ParaLength); + + if (index >= 0) + pos += queryParagraphInfo(para, ParaPortionLength, index); + return pos; +} + +void RenderTextArea::computeParagraphAndIndex(long offset, int* para, int* index) { + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + + if (!w->paragraphs()) { + *para = -1; + *index = -1; + return; + } + + //Find the paragraph that contains us.. + int containingPar = 0; + long endPos = 0; + long startPos = 0; + for (int p = 0; p < w->paragraphs(); ++p) { + int len = queryParagraphInfo(p, ParaLength); + endPos += len; + if (endPos > offset) { + containingPar = p; + break; + } + startPos += len; + } + + *para = containingPar; + + //Now, scan within the paragraph to find the position.. + long localOffset = offset - startPos; + + *index = queryParagraphInfo(containingPar, ParaPortionOffset, localOffset); +} + +void RenderTextArea::highLightWord( unsigned int length, unsigned int pos ) +{ + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + if ( w ) + w->highLightWord( length, pos ); +} + + +void RenderTextArea::slotTextChanged() +{ + element()->m_dirtyvalue = true; + element()->m_changed = true; + if (element()->m_value != text()) + element()->m_unsubmittedFormChange = true; +} + +void RenderTextArea::select() +{ + static_cast<TextAreaWidget *>(m_widget)->selectAll(); +} + +long RenderTextArea::selectionStart() +{ + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + int para, index, dummy1, dummy2; + w->getSelection(¶, &index, &dummy1, &dummy2); + if (para == -1 || index == -1) + w->getCursorPosition(¶, &index); + + return computeCharOffset(para, index); +} + +long RenderTextArea::selectionEnd() +{ + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + int para, index, dummy1, dummy2; + w->getSelection(&dummy1, &dummy2, ¶, &index); + if (para == -1 || index == -1) + w->getCursorPosition(¶, &index); + + return computeCharOffset(para, index); +} + +void RenderTextArea::setSelectionStart(long offset) { + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + int fromPara, fromIndex, toPara, toIndex; + w->getSelection(&fromPara, &fromIndex, &toPara, &toIndex); + computeParagraphAndIndex(offset, &fromPara, &fromIndex); + if (toPara == -1 || toIndex == -1) { + toPara = fromPara; + toIndex = fromIndex; + } + w->setSelection(fromPara, fromIndex, toPara, toIndex); +} + +void RenderTextArea::setSelectionEnd(long offset) { + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + int fromPara, fromIndex, toPara, toIndex; + w->getSelection(&fromPara, &fromIndex, &toPara, &toIndex); + computeParagraphAndIndex(offset, &toPara, &toIndex); + w->setSelection(fromPara, fromIndex, toPara, toIndex); +} + +void RenderTextArea::setSelectionRange(long start, long end) { + TextAreaWidget* w = static_cast<TextAreaWidget*>(m_widget); + int fromPara, fromIndex, toPara, toIndex; + computeParagraphAndIndex(start, &fromPara, &fromIndex); + computeParagraphAndIndex(end, &toPara, &toIndex); + w->setSelection(fromPara, fromIndex, toPara, toIndex); +} +// --------------------------------------------------------------------------- + +#include "render_form.moc" diff --git a/tdehtml/rendering/render_form.h b/tdehtml/rendering/render_form.h new file mode 100644 index 000000000..d1611c1e0 --- /dev/null +++ b/tdehtml/rendering/render_form.h @@ -0,0 +1,511 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_FORM_H +#define RENDER_FORM_H + +#include "rendering/render_replaced.h" +#include "rendering/render_image.h" +#include "rendering/render_flow.h" +#include "rendering/render_style.h" +#include "html/html_formimpl.h" + +class TQWidget; +class TQLineEdit; +class QListboxItem; + +#include <ktextedit.h> +#include <kurlrequester.h> +#include <klineedit.h> +#include <tqcheckbox.h> +#include <tqradiobutton.h> +#include <tqpushbutton.h> +#include <tqhbox.h> +#include <klistbox.h> +#include <kcombobox.h> +#include "dom/dom_misc.h" + +class KHTMLPartBrowserExtension; +class KSpell; +class KFindDialog; +class KReplaceDialog; +class KFind; +class KReplace; +class KAction; +class KURLRequester; + +namespace DOM { + class HTMLFormElementImpl; + class HTMLInputElementImpl; + class HTMLSelectElementImpl; + class HTMLGenericFormElementImpl; + class HTMLTextAreaElementImpl; +} + +namespace tdehtml { + +class DocLoader; + +// ------------------------------------------------------------------------- + +class RenderFormElement : public tdehtml::RenderWidget +{ +public: + RenderFormElement(DOM::HTMLGenericFormElementImpl* node); + virtual ~RenderFormElement(); + + virtual const char *renderName() const { return "RenderForm"; } + + virtual bool isFormElement() const { return true; } + + // form elements never have padding + virtual int paddingTop() const { return 0; } + virtual int paddingBottom() const { return 0; } + virtual int paddingLeft() const { return 0; } + virtual int paddingRight() const { return 0; } + + virtual void updateFromElement(); + + virtual void layout(); + virtual short baselinePosition( bool ) const; + + DOM::HTMLGenericFormElementImpl *element() const + { return static_cast<DOM::HTMLGenericFormElementImpl*>(RenderObject::element()); } + +protected: + virtual bool isRenderButton() const { return false; } + virtual bool isEditable() const { return false; } + TQ_Alignment textAlignment() const; + + TQPoint m_mousePos; + int m_state; +}; + +// ------------------------------------------------------------------------- + +// generic class for all buttons +class RenderButton : public RenderFormElement +{ + Q_OBJECT +public: + RenderButton(DOM::HTMLGenericFormElementImpl* node); + + virtual const char *renderName() const { return "RenderButton"; } + + virtual short baselinePosition( bool ) const; + + // don't even think about making this method virtual! + DOM::HTMLInputElementImpl* element() const + { return static_cast<DOM::HTMLInputElementImpl*>(RenderObject::element()); } + +protected: + virtual bool isRenderButton() const { return true; } +}; + +// ------------------------------------------------------------------------- + +class RenderCheckBox : public RenderButton +{ + Q_OBJECT +public: + RenderCheckBox(DOM::HTMLInputElementImpl* node); + + virtual const char *renderName() const { return "RenderCheckBox"; } + virtual void updateFromElement(); + virtual void calcMinMaxWidth(); + + virtual bool handleEvent(const DOM::EventImpl&) { return false; } + + TQCheckBox *widget() const { return static_cast<TQCheckBox*>(m_widget); } + +public slots: + virtual void slotStateChanged(int state); +}; + +// ------------------------------------------------------------------------- + +class RenderRadioButton : public RenderButton +{ + Q_OBJECT +public: + RenderRadioButton(DOM::HTMLInputElementImpl* node); + + virtual const char *renderName() const { return "RenderRadioButton"; } + + virtual void calcMinMaxWidth(); + virtual void updateFromElement(); + + virtual bool handleEvent(const DOM::EventImpl&) { return false; } + + TQRadioButton *widget() const { return static_cast<TQRadioButton*>(m_widget); } + +public slots: + virtual void slotToggled(bool); +}; + +// ------------------------------------------------------------------------- + +class RenderSubmitButton : public RenderButton +{ +public: + RenderSubmitButton(DOM::HTMLInputElementImpl *element); + + virtual const char *renderName() const { return "RenderSubmitButton"; } + + virtual void calcMinMaxWidth(); + virtual void updateFromElement(); + virtual short baselinePosition( bool ) const; +private: + TQString rawText(); +}; + +// ------------------------------------------------------------------------- + +class RenderImageButton : public RenderImage +{ +public: + RenderImageButton(DOM::HTMLInputElementImpl *element) + : RenderImage(element) {} + + virtual const char *renderName() const { return "RenderImageButton"; } +}; + + +// ------------------------------------------------------------------------- + +class RenderResetButton : public RenderSubmitButton +{ +public: + RenderResetButton(DOM::HTMLInputElementImpl *element); + + virtual const char *renderName() const { return "RenderResetButton"; } + +}; + +// ------------------------------------------------------------------------- + +class RenderPushButton : public RenderSubmitButton +{ +public: + RenderPushButton(DOM::HTMLInputElementImpl *element) + : RenderSubmitButton(element) {} + +}; + +// ------------------------------------------------------------------------- + +class RenderLineEdit : public RenderFormElement +{ + Q_OBJECT +public: + RenderLineEdit(DOM::HTMLInputElementImpl *element); + + virtual void calcMinMaxWidth(); + + virtual const char *renderName() const { return "RenderLineEdit"; } + virtual void updateFromElement(); + virtual void setStyle(RenderStyle *style); + + void select(); + + KLineEdit *widget() const { return static_cast<KLineEdit*>(m_widget); } + DOM::HTMLInputElementImpl* element() const + { return static_cast<DOM::HTMLInputElementImpl*>(RenderObject::element()); } + void highLightWord( unsigned int length, unsigned int pos ); + + long selectionStart(); + long selectionEnd(); + void setSelectionStart(long pos); + void setSelectionEnd(long pos); + void setSelectionRange(long start, long end); +public slots: + void slotReturnPressed(); + void slotTextChanged(const TQString &string); +protected: + virtual void handleFocusOut(); + +private: + virtual bool isEditable() const { return true; } + virtual bool canHaveBorder() const { return true; } +}; + +// ------------------------------------------------------------------------- + +class LineEditWidget : public KLineEdit +{ + Q_OBJECT +public: + LineEditWidget(DOM::HTMLInputElementImpl* input, + KHTMLView* view, TQWidget* parent); + ~LineEditWidget(); + void highLightWord( unsigned int length, unsigned int pos ); + +protected: + virtual bool event( TQEvent *e ); + virtual void mouseMoveEvent(TQMouseEvent *e); + virtual TQPopupMenu *createPopupMenu(); +private slots: + void extendedMenuActivated( int id); + void slotCheckSpelling(); + void slotSpellCheckReady( KSpell *s ); + void slotSpellCheckDone( const TQString &s ); + void spellCheckerMisspelling( const TQString &text, const TQStringList &, unsigned int pos); + void spellCheckerCorrected( const TQString &, const TQString &, unsigned int ); + void spellCheckerFinished(); + void slotRemoveFromHistory( const TQString & ); + +private: + enum LineEditMenuID { + ClearHistory, + EditHistory + }; + DOM::HTMLInputElementImpl* m_input; + KHTMLView* m_view; + KSpell *m_spell; + KAction *m_spellAction; +}; + +// ------------------------------------------------------------------------- + +class RenderFieldset : public RenderBlock +{ +public: + RenderFieldset(DOM::HTMLGenericFormElementImpl *element); + + virtual const char *renderName() const { return "RenderFieldSet"; } + virtual RenderObject* layoutLegend(bool relayoutChildren); + virtual void setStyle(RenderStyle* _style); + +protected: + virtual void paintBoxDecorations(PaintInfo& pI, int _tx, int _ty); + void paintBorderMinusLegend(TQPainter *p, int _tx, int _ty, int w, + int h, const RenderStyle *style, int lx, int lw); + RenderObject* findLegend(); +}; + +// ------------------------------------------------------------------------- + +class RenderFileButton : public RenderFormElement +{ + Q_OBJECT +public: + RenderFileButton(DOM::HTMLInputElementImpl *element); + + virtual const char *renderName() const { return "RenderFileButton"; } + virtual void calcMinMaxWidth(); + virtual void updateFromElement(); + void select(); + + KURLRequester *widget() const { return static_cast<KURLRequester*>(m_widget); } + + DOM::HTMLInputElementImpl *element() const + { return static_cast<DOM::HTMLInputElementImpl*>(RenderObject::element()); } + +public slots: + void slotReturnPressed(); + void slotTextChanged(const TQString &string); + void slotUrlSelected(const TQString &string); + +protected: + virtual void handleFocusOut(); + + virtual bool isEditable() const { return true; } + virtual bool canHaveBorder() const { return true; } + virtual bool acceptsSyntheticEvents() const { return false; } + + bool m_clicked; + bool m_haveFocus; +}; + + +// ------------------------------------------------------------------------- + +class RenderLabel : public RenderFormElement +{ +public: + RenderLabel(DOM::HTMLGenericFormElementImpl *element); + + virtual const char *renderName() const { return "RenderLabel"; } + +protected: + virtual bool canHaveBorder() const { return true; } +}; + + +// ------------------------------------------------------------------------- + +class RenderLegend : public RenderBlock +{ +public: + RenderLegend(DOM::HTMLGenericFormElementImpl *element); + + virtual const char *renderName() const { return "RenderLegend"; } +}; + +// ------------------------------------------------------------------------- + +class ComboBoxWidget : public KComboBox +{ +public: + ComboBoxWidget(TQWidget *parent); + +protected: + virtual bool event(TQEvent *); + virtual bool eventFilter(TQObject *dest, TQEvent *e); +}; + +// ------------------------------------------------------------------------- + +class RenderSelect : public RenderFormElement +{ + Q_OBJECT +public: + RenderSelect(DOM::HTMLSelectElementImpl *element); + + virtual const char *renderName() const { return "RenderSelect"; } + + virtual void calcMinMaxWidth(); + virtual void layout(); + + void setOptionsChanged(bool _optionsChanged); + + bool selectionChanged() { return m_selectionChanged; } + void setSelectionChanged(bool _selectionChanged) { m_selectionChanged = _selectionChanged; } + virtual void updateFromElement(); + + void updateSelection(); + + DOM::HTMLSelectElementImpl *element() const + { return static_cast<DOM::HTMLSelectElementImpl*>(RenderObject::element()); } + +protected: + KListBox *createListBox(); + ComboBoxWidget *createComboBox(); + + unsigned m_size; + bool m_multiple; + bool m_useListBox; + bool m_selectionChanged; + bool m_ignoreSelectEvents; + bool m_optionsChanged; + +protected slots: + void slotSelected(int index); + void slotSelectionChanged(); +}; + +// ------------------------------------------------------------------------- +class TextAreaWidget : public KTextEdit +{ + Q_OBJECT +public: + TextAreaWidget(int wrap, TQWidget* parent); + virtual ~TextAreaWidget(); + +protected: + virtual bool event (TQEvent *e ); + virtual TQPopupMenu *createPopupMenu(const TQPoint& pos); + virtual TQPopupMenu* createPopupMenu() { return KTextEdit::createPopupMenu(); } +private slots: + void slotFind(); + void slotDoFind(); + void slotFindNext(); + void slotReplace(); + void slotDoReplace(); + void slotReplaceNext(); + void slotReplaceText(const TQString&, int, int, int); + void slotFindHighlight(const TQString&, int, int); +private: + KFindDialog *m_findDlg; + KFind *m_find; + KReplaceDialog *m_repDlg; + KReplace *m_replace; + KAction *m_findAction; + KAction *m_findNextAction; + KAction *m_replaceAction; + int m_findIndex, m_findPara; + int m_repIndex, m_repPara; +}; + + +// ------------------------------------------------------------------------- + +class RenderTextArea : public RenderFormElement +{ + Q_OBJECT +public: + RenderTextArea(DOM::HTMLTextAreaElementImpl *element); + ~RenderTextArea(); + + virtual const char *renderName() const { return "RenderTextArea"; } + virtual void calcMinMaxWidth(); + virtual void layout(); + virtual void setStyle(RenderStyle *style); + + virtual void close ( ); + virtual void updateFromElement(); + + // don't even think about making this method virtual! + TextAreaWidget *widget() const { return static_cast<TextAreaWidget*>(m_widget); } + DOM::HTMLTextAreaElementImpl* element() const + { return static_cast<DOM::HTMLTextAreaElementImpl*>(RenderObject::element()); } + + TQString text(); + void highLightWord( unsigned int length, unsigned int pos ); + + void select(); + + long selectionStart(); + long selectionEnd(); + void setSelectionStart(long pos); + void setSelectionEnd(long pos); + void setSelectionRange(long start, long end); +protected slots: + void slotTextChanged(); + +protected: + virtual void handleFocusOut(); + + virtual bool isEditable() const { return true; } + virtual bool canHaveBorder() const { return true; } + + bool scrollbarsStyled; +private: + //Convert para, index -> offset + long computeCharOffset(int para, int index); + + //Convert offset -> para, index + void computeParagraphAndIndex(long offset, int* para, int* index); + + //Helper for doing the conversion.. + enum Mode { ParaLength, //Returns the length of the entire paragraph + ParaPortionLength, //Return length of paragraph portion set by threshold + ParaPortionOffset }; //Return offset that matches the length threshold. + int queryParagraphInfo(int para, Mode m, int param = -1); +}; + +// ------------------------------------------------------------------------- + +} //namespace + +#endif diff --git a/tdehtml/rendering/render_frames.cpp b/tdehtml/rendering/render_frames.cpp new file mode 100644 index 000000000..03d55fbfd --- /dev/null +++ b/tdehtml/rendering/render_frames.cpp @@ -0,0 +1,1025 @@ +/** + * This file is part of the KDE project. + * + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * (C) 2000 Simon Hausmann <hausmann@kde.org> + * (C) 2000 Stefan Schimanski (1Stein@gmx.de) + * (C) 2003 Apple Computer, Inc. + * (C) 2005 Niels Leenheer <niels.leenheer@gmail.com> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +//#define DEBUG_LAYOUT + +#include "rendering/render_frames.h" +#include "rendering/render_canvas.h" +#include "html/html_baseimpl.h" +#include "html/html_objectimpl.h" +#include "html/htmltokenizer.h" +#include "misc/htmlattrs.h" +#include "xml/dom2_eventsimpl.h" +#include "xml/dom_docimpl.h" +#include "misc/htmltags.h" +#include "tdehtmlview.h" +#include "tdehtml_part.h" +#include "misc/knsplugininstaller.h" + +#include <kapplication.h> +#include <kmessagebox.h> +#include <kmimetype.h> +#include <klocale.h> +#include <kdebug.h> +#include <tqtimer.h> +#include <tqpainter.h> +#include <tqcursor.h> + +#include <assert.h> + +using namespace tdehtml; +using namespace DOM; + +RenderFrameSet::RenderFrameSet( HTMLFrameSetElementImpl *frameSet) + : RenderBox(frameSet) +{ + // init RenderObject attributes + setInline(false); + + for (int k = 0; k < 2; ++k) { + m_gridLen[k] = -1; + m_gridDelta[k] = 0; + m_gridLayout[k] = 0; + } + + m_resizing = m_clientresizing= false; + + m_cursor = Qt::ArrowCursor; + + m_hSplit = -1; + m_vSplit = -1; + + m_hSplitVar = 0; + m_vSplitVar = 0; +} + +RenderFrameSet::~RenderFrameSet() +{ + for (int k = 0; k < 2; ++k) { + delete [] m_gridLayout[k]; + delete [] m_gridDelta[k]; + } + delete [] m_hSplitVar; + delete [] m_vSplitVar; +} + +bool RenderFrameSet::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inBox) +{ + RenderBox::nodeAtPoint(info, _x, _y, _tx, _ty, hitTestAction, inBox); + + bool inside = m_resizing || canResize(_x, _y); + + if ( inside && element() && !element()->noResize() && !info.readonly()) { + info.setInnerNode(element()); + info.setInnerNonSharedNode(element()); + } + + return inside || m_clientresizing; +} + +void RenderFrameSet::layout( ) +{ + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + + if ( !parent()->isFrameSet() ) { + KHTMLView* view = canvas()->view(); + m_width = view ? view->visibleWidth() : 0; + m_height = view ? view->visibleHeight() : 0; + } + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(FrameSet)::layout( ) width=" << width() << ", height=" << height() << endl; +#endif + + int remainingLen[2]; + remainingLen[1] = m_width - (element()->totalCols()-1)*element()->border(); + if(remainingLen[1]<0) remainingLen[1]=0; + remainingLen[0] = m_height - (element()->totalRows()-1)*element()->border(); + if(remainingLen[0]<0) remainingLen[0]=0; + + int availableLen[2]; + availableLen[0] = remainingLen[0]; + availableLen[1] = remainingLen[1]; + + if (m_gridLen[0] != element()->totalRows() || m_gridLen[1] != element()->totalCols()) { + // number of rows or cols changed + // need to zero out the deltas + m_gridLen[0] = element()->totalRows(); + m_gridLen[1] = element()->totalCols(); + for (int k = 0; k < 2; ++k) { + delete [] m_gridDelta[k]; + m_gridDelta[k] = new int[m_gridLen[k]]; + delete [] m_gridLayout[k]; + m_gridLayout[k] = new int[m_gridLen[k]]; + for (int i = 0; i < m_gridLen[k]; ++i) + m_gridDelta[k][i] = 0; + } + } + + for (int k = 0; k < 2; ++k) { + int totalRelative = 0; + int totalFixed = 0; + int totalPercent = 0; + int countRelative = 0; + int countFixed = 0; + int countPercent = 0; + int gridLen = m_gridLen[k]; + int* gridDelta = m_gridDelta[k]; + tdehtml::Length* grid = k ? element()->m_cols : element()->m_rows; + int* gridLayout = m_gridLayout[k]; + + if (grid) { + // First we need to investigate how many columns of each type we have and + // how much space these columns are going to require. + for (int i = 0; i < gridLen; ++i) { + // Count the total length of all of the fixed columns/rows -> totalFixed + // Count the number of columns/rows which are fixed -> countFixed + if (grid[i].isFixed()) { + gridLayout[i] = kMax(grid[i].value(), 0); + totalFixed += gridLayout[i]; + countFixed++; + } + + // Count the total percentage of all of the percentage columns/rows -> totalPercent + // Count the number of columns/rows which are percentages -> countPercent + if (grid[i].isPercent()) { + gridLayout[i] = kMax(grid[i].width(availableLen[k]), 0); + totalPercent += gridLayout[i]; + countPercent++; + } + + // Count the total relative of all the relative columns/rows -> totalRelative + // Count the number of columns/rows which are relative -> countRelative + if (grid[i].isRelative()) { + totalRelative += kMax(grid[i].value(), 1); + countRelative++; + } + } + + // Fixed columns/rows are our first priority. If there is not enough space to fit all fixed + // columns/rows we need to proportionally adjust their size. + if (totalFixed > remainingLen[k]) { + int remainingFixed = remainingLen[k]; + + for (int i = 0; i < gridLen; ++i) { + if (grid[i].isFixed()) { + gridLayout[i] = (gridLayout[i] * remainingFixed) / totalFixed; + remainingLen[k] -= gridLayout[i]; + } + } + } else { + remainingLen[k] -= totalFixed; + } + + // Percentage columns/rows are our second priority. Divide the remaining space proportionally + // over all percentage columns/rows. IMPORTANT: the size of each column/row is not relative + // to 100%, but to the total percentage. For example, if there are three columns, each of 75%, + // and the available space is 300px, each column will become 100px in width. + if (totalPercent > remainingLen[k]) { + int remainingPercent = remainingLen[k]; + + for (int i = 0; i < gridLen; ++i) { + if (grid[i].isPercent()) { + gridLayout[i] = (gridLayout[i] * remainingPercent) / totalPercent; + remainingLen[k] -= gridLayout[i]; + } + } + } else { + remainingLen[k] -= totalPercent; + } + + // Relative columns/rows are our last priority. Divide the remaining space proportionally + // over all relative columns/rows. IMPORTANT: the relative value of 0* is treated as 1*. + if (countRelative) { + int lastRelative = 0; + int remainingRelative = remainingLen[k]; + + for (int i = 0; i < gridLen; ++i) { + if (grid[i].isRelative()) { + gridLayout[i] = (kMax(grid[i].value(), 1) * remainingRelative) / totalRelative; + remainingLen[k] -= gridLayout[i]; + lastRelative = i; + } + } + + // If we could not evently distribute the available space of all of the relative + // columns/rows, the remainder will be added to the last column/row. + // For example: if we have a space of 100px and three columns (*,*,*), the remainder will + // be 1px and will be added to the last column: 33px, 33px, 34px. + if (remainingLen[k]) { + gridLayout[lastRelative] += remainingLen[k]; + remainingLen[k] = 0; + } + } + + // If we still have some left over space we need to divide it over the already existing + // columns/rows + if (remainingLen[k]) { + // Our first priority is to spread if over the percentage columns. The remaining + // space is spread evenly, for example: if we have a space of 100px, the columns + // definition of 25%,25% used to result in two columns of 25px. After this the + // columns will each be 50px in width. + if (countPercent && totalPercent) { + int remainingPercent = remainingLen[k]; + int changePercent = 0; + + for (int i = 0; i < gridLen; ++i) { + if (grid[i].isPercent()) { + changePercent = (remainingPercent * gridLayout[i]) / totalPercent; + gridLayout[i] += changePercent; + remainingLen[k] -= changePercent; + } + } + } else if (totalFixed) { + // Our last priority is to spread the remaining space over the fixed columns. + // For example if we have 100px of space and two column of each 40px, both + // columns will become exactly 50px. + int remainingFixed = remainingLen[k]; + int changeFixed = 0; + + for (int i = 0; i < gridLen; ++i) { + if (grid[i].isFixed()) { + changeFixed = (remainingFixed * gridLayout[i]) / totalFixed; + gridLayout[i] += changeFixed; + remainingLen[k] -= changeFixed; + } + } + } + } + + // If we still have some left over space we probably ended up with a remainder of + // a division. We can not spread it evenly anymore. If we have any percentage + // columns/rows simply spread the remainder equally over all available percentage columns, + // regardless of their size. + if (remainingLen[k] && countPercent) { + int remainingPercent = remainingLen[k]; + int changePercent = 0; + + for (int i = 0; i < gridLen; ++i) { + if (grid[i].isPercent()) { + changePercent = remainingPercent / countPercent; + gridLayout[i] += changePercent; + remainingLen[k] -= changePercent; + } + } + } + + // If we don't have any percentage columns/rows we only have fixed columns. Spread + // the remainder equally over all fixed columns/rows. + else if (remainingLen[k] && countFixed) { + int remainingFixed = remainingLen[k]; + int changeFixed = 0; + + for (int i = 0; i < gridLen; ++i) { + if (grid[i].isFixed()) { + changeFixed = remainingFixed / countFixed; + gridLayout[i] += changeFixed; + remainingLen[k] -= changeFixed; + } + } + } + + // Still some left over... simply add it to the last column, because it is impossible + // spread it evenly or equally. + if (remainingLen[k]) { + gridLayout[gridLen - 1] += remainingLen[k]; + } + + // now we have the final layout, distribute the delta over it + bool worked = true; + for (int i = 0; i < gridLen; ++i) { + if (gridLayout[i] && gridLayout[i] + gridDelta[i] <= 0) + worked = false; + gridLayout[i] += gridDelta[i]; + } + // now the delta's broke something, undo it and reset deltas + if (!worked) + for (int i = 0; i < gridLen; ++i) { + gridLayout[i] -= gridDelta[i]; + gridDelta[i] = 0; + } + } + else + gridLayout[0] = remainingLen[k]; + } + + positionFrames(); + + RenderObject *child = firstChild(); + if ( !child ) + goto end2; + + if(!m_hSplitVar && !m_vSplitVar) + { +#ifdef DEBUG_LAYOUT + kdDebug( 6031 ) << "calculationg fixed Splitters" << endl; +#endif + if(!m_vSplitVar && element()->totalCols() > 1) + { + m_vSplitVar = new bool[element()->totalCols()]; + for(int i = 0; i < element()->totalCols(); i++) m_vSplitVar[i] = true; + } + if(!m_hSplitVar && element()->totalRows() > 1) + { + m_hSplitVar = new bool[element()->totalRows()]; + for(int i = 0; i < element()->totalRows(); i++) m_hSplitVar[i] = true; + } + + for(int r = 0; r < element()->totalRows(); r++) + { + for(int c = 0; c < element()->totalCols(); c++) + { + bool fixed = false; + + if ( child->isFrameSet() ) + fixed = static_cast<RenderFrameSet *>(child)->element()->noResize(); + else + fixed = static_cast<RenderFrame *>(child)->element()->noResize(); + + if(fixed) + { +#ifdef DEBUG_LAYOUT + kdDebug( 6031 ) << "found fixed cell " << r << "/" << c << "!" << endl; +#endif + if( element()->totalCols() > 1) + { + if(c>0) m_vSplitVar[c-1] = false; + m_vSplitVar[c] = false; + } + if( element()->totalRows() > 1) + { + if(r>0) m_hSplitVar[r-1] = false; + m_hSplitVar[r] = false; + } + child = child->nextSibling(); + if(!child) goto end2; + } +#ifdef DEBUG_LAYOUT + else + kdDebug( 6031 ) << "not fixed: " << r << "/" << c << "!" << endl; +#endif + } + } + + } + RenderContainer::layout(); + end2: + setNeedsLayout(false); +} + +void RenderFrameSet::positionFrames() +{ + int r; + int c; + + RenderObject *child = firstChild(); + if ( !child ) + return; + + // NodeImpl *child = _first; + // if(!child) return; + + int yPos = 0; + + for(r = 0; r < element()->totalRows(); r++) + { + int xPos = 0; + for(c = 0; c < element()->totalCols(); c++) + { + child->setPos( xPos, yPos ); +#ifdef DEBUG_LAYOUT + kdDebug(6040) << "child frame at (" << xPos << "/" << yPos << ") size (" << m_gridLayout[1][c] << "/" << m_gridLayout[0][r] << ")" << endl; +#endif + // has to be resized and itself resize its contents + if ((m_gridLayout[1][c] != child->width()) || (m_gridLayout[0][r] != child->height())) { + child->setWidth( m_gridLayout[1][c] ); + child->setHeight( m_gridLayout[0][r] ); + child->setNeedsLayout(true); + child->layout(); + } + + xPos += m_gridLayout[1][c] + element()->border(); + child = child->nextSibling(); + + if ( !child ) + return; + + } + + yPos += m_gridLayout[0][r] + element()->border(); + } + + // all the remaining frames are hidden to avoid ugly + // spurious unflowed frames + while ( child ) { + child->setWidth( 0 ); + child->setHeight( 0 ); + child->setNeedsLayout(false); + + child = child->nextSibling(); + } +} + +bool RenderFrameSet::userResize( MouseEventImpl *evt ) +{ + if (needsLayout()) return false; + + bool res = false; + int _x = evt->clientX(); + int _y = evt->clientY(); + + if ( !m_resizing && evt->id() == EventImpl::MOUSEMOVE_EVENT || evt->id() == EventImpl::MOUSEDOWN_EVENT ) + { +#ifdef DEBUG_LAYOUT + kdDebug( 6031 ) << "mouseEvent:check" << endl; +#endif + + m_hSplit = -1; + m_vSplit = -1; + //bool resizePossible = true; + + // check if we're over a horizontal or vertical boundary + int pos = m_gridLayout[1][0] + xPos(); + for(int c = 1; c < element()->totalCols(); c++) + { + if(_x >= pos && _x <= pos+element()->border()) + { + if(m_vSplitVar && m_vSplitVar[c-1] == true) m_vSplit = c-1; +#ifdef DEBUG_LAYOUT + kdDebug( 6031 ) << "vsplit!" << endl; +#endif + res = true; + break; + } + pos += m_gridLayout[1][c] + element()->border(); + } + + pos = m_gridLayout[0][0] + yPos(); + for(int r = 1; r < element()->totalRows(); r++) + { + if( _y >= pos && _y <= pos+element()->border()) + { + if(m_hSplitVar && m_hSplitVar[r-1] == true) m_hSplit = r-1; +#ifdef DEBUG_LAYOUT + kdDebug( 6031 ) << "hsplitvar = " << m_hSplitVar << endl; + kdDebug( 6031 ) << "hsplit!" << endl; +#endif + res = true; + break; + } + pos += m_gridLayout[0][r] + element()->border(); + } +#ifdef DEBUG_LAYOUT + kdDebug( 6031 ) << m_hSplit << "/" << m_vSplit << endl; +#endif + } + + + m_cursor = Qt::ArrowCursor; + if(m_hSplit != -1 && m_vSplit != -1) + m_cursor = Qt::SizeAllCursor; + else if( m_vSplit != -1 ) + m_cursor = Qt::SizeHorCursor; + else if( m_hSplit != -1 ) + m_cursor = Qt::SizeVerCursor; + + if(!m_resizing && evt->id() == EventImpl::MOUSEDOWN_EVENT) + { + setResizing(true); + TDEApplication::setOverrideCursor(TQCursor(m_cursor)); + m_vSplitPos = _x; + m_hSplitPos = _y; + m_oldpos = -1; + } + + // ### check the resize is not going out of bounds. + if(m_resizing && evt->id() == EventImpl::MOUSEUP_EVENT) + { + setResizing(false); + TDEApplication::restoreOverrideCursor(); + + if(m_vSplit != -1 ) + { +#ifdef DEBUG_LAYOUT + kdDebug( 6031 ) << "split xpos=" << _x << endl; +#endif + int delta = m_vSplitPos - _x; + m_gridDelta[1][m_vSplit] -= delta; + m_gridDelta[1][m_vSplit+1] += delta; + } + if(m_hSplit != -1 ) + { +#ifdef DEBUG_LAYOUT + kdDebug( 6031 ) << "split ypos=" << _y << endl; +#endif + int delta = m_hSplitPos - _y; + m_gridDelta[0][m_hSplit] -= delta; + m_gridDelta[0][m_hSplit+1] += delta; + } + + // this just schedules the relayout + // important, otherwise the moving indicator is not correctly erased + setNeedsLayout(true); + } + + KHTMLView *view = canvas()->view(); + if ((m_resizing || evt->id() == EventImpl::MOUSEUP_EVENT) && view) { + TQPainter paint( view ); + paint.setPen( Qt::gray ); + paint.setBrush( Qt::gray ); + paint.setRasterOp( TQt::XorROP ); + TQRect r(xPos(), yPos(), width(), height()); + const int rBord = 3; + int sw = element()->border(); + int p = m_resizing ? (m_vSplit > -1 ? _x : _y) : -1; + if (m_vSplit > -1) { + if ( m_oldpos >= 0 ) + paint.drawRect( m_oldpos + sw/2 - rBord , r.y(), + 2*rBord, r.height() ); + if ( p >= 0 ) + paint.drawRect( p + sw/2 - rBord, r.y(), 2*rBord, r.height() ); + } else { + if ( m_oldpos >= 0 ) + paint.drawRect( r.x(), m_oldpos + sw/2 - rBord, + r.width(), 2*rBord ); + if ( p >= 0 ) + paint.drawRect( r.x(), p + sw/2 - rBord, r.width(), 2*rBord ); + } + m_oldpos = p; + } + + return res; +} + +void RenderFrameSet::setResizing(bool e) +{ + m_resizing = e; + for (RenderObject* p = parent(); p; p = p->parent()) + if (p->isFrameSet()) static_cast<RenderFrameSet*>(p)->m_clientresizing = m_resizing; +} + +bool RenderFrameSet::canResize( int _x, int _y ) +{ + // if we haven't received a layout, then the gridLayout doesn't contain useful data yet + if (needsLayout() || !m_gridLayout[0] || !m_gridLayout[1] ) return false; + + // check if we're over a horizontal or vertical boundary + int pos = m_gridLayout[1][0]; + for(int c = 1; c < element()->totalCols(); c++) + if(_x >= pos && _x <= pos+element()->border()) + return true; + + pos = m_gridLayout[0][0]; + for(int r = 1; r < element()->totalRows(); r++) + if( _y >= pos && _y <= pos+element()->border()) + return true; + + return false; +} + +#ifdef ENABLE_DUMP +void RenderFrameSet::dump(TQTextStream &stream, const TQString &ind) const +{ + RenderBox::dump(stream,ind); + stream << " totalrows=" << element()->totalRows(); + stream << " totalcols=" << element()->totalCols(); + + if ( m_hSplitVar ) + for (uint i = 0; i < (uint)element()->totalRows(); i++) { + stream << " hSplitvar(" << i << ")=" << m_hSplitVar[i]; + } + + if ( m_vSplitVar ) + for (uint i = 0; i < (uint)element()->totalCols(); i++) + stream << " vSplitvar(" << i << ")=" << m_vSplitVar[i]; +} +#endif + +/**************************************************************************************/ + +RenderPart::RenderPart(DOM::HTMLElementImpl* node) + : RenderWidget(node) +{ + // init RenderObject attributes + setInline(false); +} + +void RenderPart::setWidget( TQWidget *widget ) +{ +#ifdef DEBUG_LAYOUT + kdDebug(6031) << "RenderPart::setWidget()" << endl; +#endif + + setQWidget( widget ); + widget->setFocusPolicy(TQ_WheelFocus); + if(widget->inherits("KHTMLView")) + connect( widget, TQT_SIGNAL( cleared() ), this, TQT_SLOT( slotViewCleared() ) ); + + setNeedsLayoutAndMinMaxRecalc(); + + // make sure the scrollbars are set correctly for restore + // ### find better fix + slotViewCleared(); +} + +bool RenderPart::partLoadingErrorNotify(tdehtml::ChildFrame *, const KURL& , const TQString& ) +{ + return false; +} + +short RenderPart::intrinsicWidth() const +{ + return 300; +} + +int RenderPart::intrinsicHeight() const +{ + return 150; +} + +void RenderPart::slotViewCleared() +{ +} + +/***************************************************************************************/ + +RenderFrame::RenderFrame( DOM::HTMLFrameElementImpl *frame ) + : RenderPart(frame) +{ + setInline( false ); +} + +void RenderFrame::slotViewCleared() +{ + if(m_widget->inherits(TQSCROLLVIEW_OBJECT_NAME_STRING)) { +#ifdef DEBUG_LAYOUT + kdDebug(6031) << "frame is a scrollview!" << endl; +#endif + TQScrollView *view = static_cast<TQScrollView *>(m_widget); + if(!element()->frameBorder || !((static_cast<HTMLFrameSetElementImpl *>(element()->parentNode()))->frameBorder())) + view->setFrameStyle(TQFrame::NoFrame); + view->setVScrollBarMode(element()->scrolling ); + view->setHScrollBarMode(element()->scrolling ); + if(view->inherits("KHTMLView")) { +#ifdef DEBUG_LAYOUT + kdDebug(6031) << "frame is a KHTMLview!" << endl; +#endif + KHTMLView *htmlView = static_cast<KHTMLView *>(view); + if(element()->marginWidth != -1) htmlView->setMarginWidth(element()->marginWidth); + if(element()->marginHeight != -1) htmlView->setMarginHeight(element()->marginHeight); + } + } +} + +/****************************************************************************************/ + +RenderPartObject::RenderPartObject( DOM::HTMLElementImpl* element ) + : RenderPart( element ) +{ + // init RenderObject attributes + setInline(true); +} + +void RenderPartObject::updateWidget() +{ + TQString url; + KHTMLPart *part = m_view->part(); + + setNeedsLayoutAndMinMaxRecalc(); + + if (element()->id() == ID_IFRAME) { + + HTMLIFrameElementImpl *o = static_cast<HTMLIFrameElementImpl *>(element()); + url = o->url.string(); + if (!o->getDocument()->isURLAllowed(url)) return; + part->requestFrame( this, url, o->name.string(), TQStringList(), true ); + // ### this should be constant true - move iframe to somewhere else + } else { + + TQStringList params; + HTMLObjectBaseElementImpl * objbase = static_cast<HTMLObjectBaseElementImpl *>(element()); + url = objbase->url; + + for (NodeImpl* child = element()->firstChild(); child; child=child->nextSibling()) { + if ( child->id() == ID_PARAM ) { + HTMLParamElementImpl *p = static_cast<HTMLParamElementImpl *>( child ); + + TQString aStr = p->name(); + aStr += TQString::fromLatin1("=\""); + aStr += p->value(); + aStr += TQString::fromLatin1("\""); + TQString name_lower = p->name().lower(); + if (name_lower == TQString::fromLatin1("type") && objbase->id() != ID_APPLET) { + objbase->setServiceType(p->value()); + } else if (url.isEmpty() && + (name_lower == TQString::fromLatin1("src") || + name_lower == TQString::fromLatin1("movie") || + name_lower == TQString::fromLatin1("code"))) { + url = p->value(); + } + params.append(aStr); + } + } + if (element()->id() != ID_OBJECT) { + // add all attributes set on the embed object + NamedAttrMapImpl* a = objbase->attributes(); + if (a) { + for (unsigned long i = 0; i < a->length(); ++i) { + NodeImpl::Id id = a->idAt(i); + DOMString value = a->valueAt(i); + params.append(objbase->getDocument()->getName(NodeImpl::AttributeId, id).string() + "=\"" + value.string() + "\""); + } + } + } + params.append( TQString::fromLatin1("__KHTML__PLUGINEMBED=\"YES\"") ); + params.append( TQString::fromLatin1("__KHTML__PLUGINBASEURL=\"%1\"").arg(element()->getDocument()->baseURL().url())); + + HTMLEmbedElementImpl *embed = 0; + TQString classId; + TQString serviceType = objbase->serviceType; + if ( element()->id() == ID_EMBED ) { + + embed = static_cast<HTMLEmbedElementImpl *>( objbase ); + + } + else { // if(element()->id() == ID_OBJECT || element()->id() == ID_APPLET) + + // check for embed child object + for (NodeImpl *child = objbase->firstChild(); child; child = child->nextSibling()) + if ( child->id() == ID_EMBED ) { + embed = static_cast<HTMLEmbedElementImpl *>( child ); + break; + } + classId = objbase->classId; + + params.append( TQString::fromLatin1("__KHTML__CLASSID=\"%1\"").arg( classId ) ); + params.append( TQString::fromLatin1("__KHTML__CODEBASE=\"%1\"").arg( objbase->getAttribute(ATTR_CODEBASE).string() ) ); + if (!objbase->getAttribute(ATTR_WIDTH).isEmpty()) + params.append( TQString::fromLatin1("WIDTH=\"%1\"").arg( objbase->getAttribute(ATTR_WIDTH).string() ) ); + else if (embed && !embed->getAttribute(ATTR_WIDTH).isEmpty()) { + params.append( TQString::fromLatin1("WIDTH=\"%1\"").arg( embed->getAttribute(ATTR_WIDTH).string() ) ); + objbase->setAttribute(ATTR_WIDTH, embed->getAttribute(ATTR_WIDTH)); + } + if (!objbase->getAttribute(ATTR_HEIGHT).isEmpty()) + params.append( TQString::fromLatin1("HEIGHT=\"%1\"").arg( objbase->getAttribute(ATTR_HEIGHT).string() ) ); + else if (embed && !embed->getAttribute(ATTR_HEIGHT).isEmpty()) { + params.append( TQString::fromLatin1("HEIGHT=\"%1\"").arg( embed->getAttribute(ATTR_HEIGHT).string() ) ); + objbase->setAttribute(ATTR_HEIGHT, embed->getAttribute(ATTR_HEIGHT)); + } + + if ( embed ) { + // render embed object + url = embed->url; + if (!embed->serviceType.isEmpty()) + serviceType = embed->serviceType; + } else if (url.isEmpty() && objbase->classId.startsWith("java:")) { + serviceType = "application/x-java-applet"; + url = objbase->classId.mid(5); + } + if ( (serviceType.isEmpty() || + serviceType == "application/x-oleobject") && + !objbase->classId.isEmpty()) + { +#if 0 + // We have a clsid, means this is activex (Niko) + serviceType = "application/x-activex-handler"; +#endif + + if(classId.find(TQString::fromLatin1("D27CDB6E-AE6D-11cf-96B8-444553540000")) >= 0) { + // It is ActiveX, but the nsplugin system handling + // should also work, that's why we don't override the + // serviceType with application/x-activex-handler + // but let the KTrader in tdehtmlpart::createPart() detect + // the user's preference: launch with activex viewer or + // with nspluginviewer (Niko) + serviceType = "application/x-shockwave-flash"; + } + else if(classId.find(TQString::fromLatin1("CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA")) >= 0) + serviceType = "audio/x-pn-realaudio-plugin"; + else if(classId.find(TQString::fromLatin1("8AD9C840-044E-11D1-B3E9-00805F499D93")) >= 0 || + objbase->classId.find(TQString::fromLatin1("CAFEEFAC-0014-0000-0000-ABCDEFFEDCBA")) >= 0) + serviceType = "application/x-java-applet"; + // http://www.apple.com/quicktime/tools_tips/tutorials/activex.html + else if(classId.find(TQString::fromLatin1("02BF25D5-8C17-4B23-BC80-D3488ABDDC6B")) >= 0) + serviceType = "video/quicktime"; + // http://msdn.microsoft.com/library/en-us/dnwmt/html/adding_windows_media_to_web_pages__etse.asp?frame=true + else if(objbase->classId.find(TQString::fromLatin1("6BF52A52-394A-11d3-B153-00C04F79FAA6")) >= 0 || + classId.find(TQString::fromLatin1("22D6f312-B0F6-11D0-94AB-0080C74C7E95")) >= 0) + serviceType = "video/x-msvideo"; + + else + kdDebug(6031) << "ActiveX classId " << objbase->classId << endl; + + // TODO: add more plugins here + } + } + if ((url.isEmpty() && !embed && + (serviceType.isEmpty() || classId.isEmpty())) || + !document()->isURLAllowed(url) || + !part->requestObject( this, url, serviceType, params )) + objbase->renderAlternative(); + } +} + +// ugly.. +void RenderPartObject::close() +{ + RenderPart::close(); + + if ( element()->id() != ID_IFRAME ) + updateWidget(); + // deleted here +} + + +bool RenderPartObject::partLoadingErrorNotify( tdehtml::ChildFrame *childFrame, const KURL& url, const TQString& serviceType ) +{ + KHTMLPart *part = static_cast<KHTMLView *>(m_view)->part(); + kdDebug(6031) << "RenderPartObject::partLoadingErrorNotify serviceType=" << serviceType << endl; + // Check if we just tried with e.g. nsplugin + // and fallback to the activexhandler if there is a classid + // and a codebase, where we may download the ocx if it's missing + if( serviceType != "application/x-activex-handler" && element()->id()==ID_OBJECT ) { + + // check for embed child object + HTMLObjectElementImpl *o = static_cast<HTMLObjectElementImpl *>(element()); + HTMLEmbedElementImpl *embed = 0; + NodeImpl *child = o->firstChild(); + while ( child ) { + if ( child->id() == ID_EMBED ) + embed = static_cast<HTMLEmbedElementImpl *>( child ); + + child = child->nextSibling(); + } + if( embed && !o->classId.isEmpty() && + !( static_cast<ElementImpl *>(o)->getAttribute(ATTR_CODEBASE).string() ).isEmpty() ) + { + KParts::URLArgs args; + args.serviceType = "application/x-activex-handler"; + kdDebug(6031) << "set to activex" << endl; + if (part->requestObject( childFrame, url, args )) + return true; // success + + return false; + } + } + // Dissociate ourselves from the current event loop (to prevent crashes + // due to the message box staying up) + TQTimer::singleShot( 0, this, TQT_SLOT( slotPartLoadingErrorNotify() ) ); +#if 0 + Tokenizer *tokenizer = static_cast<DOM::DocumentImpl *>(part->document().handle())->tokenizer(); + if (tokenizer) tokenizer->setOnHold( true ); + slotPartLoadingErrorNotify(); + if (tokenizer) tokenizer->setOnHold( false ); +#endif + return false; +} + +void RenderPartObject::slotPartLoadingErrorNotify() +{ + // First we need to find out the servicetype - again - this code is too duplicated ! + HTMLEmbedElementImpl *embed = 0; + TQString serviceType; + if( element()->id()==ID_OBJECT ) { + + // check for embed child object + HTMLObjectElementImpl *o = static_cast<HTMLObjectElementImpl *>(element()); + serviceType = o->serviceType; + NodeImpl *child = o->firstChild(); + while ( child ) { + if ( child->id() == ID_EMBED ) + embed = static_cast<HTMLEmbedElementImpl *>( child ); + + child = child->nextSibling(); + } + + } else if( element()->id()==ID_EMBED ) { + embed = static_cast<HTMLEmbedElementImpl *>(element()); + } + if ( embed ) + serviceType = embed->serviceType; + + // prepare for the local eventloop in KMessageBox + ref(); + + KHTMLPart *part = static_cast<KHTMLView *>(m_view)->part(); + KParts::BrowserExtension *ext = part->browserExtension(); + if( embed && !embed->pluginPage.isEmpty() && ext ) { + // Prepare the mimetype to show in the question (comment if available, name as fallback) + TQString mimeName = serviceType; + KMimeType::Ptr mime = KMimeType::mimeType(serviceType); + if ( mime->name() != KMimeType::defaultMimeType() ) + mimeName = mime->comment(); + + // Check if we already asked the user, for this page + if (!mimeName.isEmpty() && part->docImpl() && !part->pluginPageQuestionAsked( serviceType ) ) + { + part->setPluginPageQuestionAsked( serviceType ); + bool pluginAvailable; + pluginAvailable = false; + // check if a pluginList file is in the config + if(KNSPluginInstallEngine::isActive()) + { + KNSPluginWizard pluginWizard(m_view, "pluginInstaller", mime); + if(pluginWizard.pluginAvailable()) { + pluginAvailable = true; + pluginWizard.exec(); + } + } + if(!pluginAvailable) { + // Prepare the URL to show in the question (host only if http, to make it short) + KURL pluginPageURL( embed->pluginPage ); + TQString shortURL = pluginPageURL.protocol() == "http" ? pluginPageURL.host() : pluginPageURL.prettyURL(); + int res = KMessageBox::questionYesNo( m_view, + i18n("No plugin found for '%1'.\nDo you want to download one from %2?").arg(mimeName).arg(shortURL), + i18n("Missing Plugin"), i18n("Download"), i18n("Do Not Download"), TQString("plugin-")+serviceType); + if ( res == KMessageBox::Yes ) + { + // Display vendor download page + ext->createNewWindow( pluginPageURL ); + return; + } + } + } + } + + // didn't work, render alternative content. + if ( element() && ( + element()->id() == ID_OBJECT || element()->id() == ID_EMBED || element()->id() == ID_APPLET)) + static_cast<HTMLObjectBaseElementImpl*>( element() )->renderAlternative(); + + deref(); +} + +void RenderPartObject::layout( ) +{ + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + + calcWidth(); + calcHeight(); + + RenderPart::layout(); + + setNeedsLayout(false); +} + +void RenderPartObject::slotViewCleared() +{ + if(m_widget->inherits(TQSCROLLVIEW_OBJECT_NAME_STRING) ) { +#ifdef DEBUG_LAYOUT + kdDebug(6031) << "iframe is a scrollview!" << endl; +#endif + TQScrollView *view = static_cast<TQScrollView *>(m_widget); + int frameStyle = TQFrame::NoFrame; + TQScrollView::ScrollBarMode scroll = TQScrollView::Auto; + int marginw = -1; + int marginh = -1; + if ( element()->id() == ID_IFRAME) { + HTMLIFrameElementImpl *frame = static_cast<HTMLIFrameElementImpl *>(element()); + if(frame->frameBorder) + frameStyle = TQFrame::Box; + scroll = frame->scrolling; + marginw = frame->marginWidth; + marginh = frame->marginHeight; + } + view->setFrameStyle(frameStyle); + view->setVScrollBarMode(scroll ); + view->setHScrollBarMode(scroll ); + if(view->inherits("KHTMLView")) { +#ifdef DEBUG_LAYOUT + kdDebug(6031) << "frame is a KHTMLview!" << endl; +#endif + KHTMLView *htmlView = static_cast<KHTMLView *>(view); + htmlView->setIgnoreWheelEvents( element()->id() == ID_IFRAME ); + if(marginw != -1) htmlView->setMarginWidth(marginw); + if(marginh != -1) htmlView->setMarginHeight(marginh); + } + } +} + + +#include "render_frames.moc" diff --git a/tdehtml/rendering/render_frames.h b/tdehtml/rendering/render_frames.h new file mode 100644 index 000000000..79171c747 --- /dev/null +++ b/tdehtml/rendering/render_frames.h @@ -0,0 +1,172 @@ +/* + * This file is part of the KDE project. + * + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * (C) 2000 Simon Hausmann <hausmann@kde.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef __render_frames_h__ +#define __render_frames_h__ + +#include "rendering/render_replaced.h" +#include "xml/dom_nodeimpl.h" +#include "html/html_baseimpl.h" +class KHTMLView; + +namespace DOM +{ + class HTMLFrameElementImpl; + class HTMLElementImpl; + class MouseEventImpl; +} + +namespace tdehtml +{ + class ChildFrame; + +class RenderFrameSet : public RenderBox +{ + friend class DOM::HTMLFrameSetElementImpl; +public: + RenderFrameSet( DOM::HTMLFrameSetElementImpl *frameSet ); + + virtual ~RenderFrameSet(); + + virtual const char *renderName() const { return "RenderFrameSet"; } + virtual bool isFrameSet() const { return true; } + + virtual void layout(); + + void positionFrames( ); + + bool resizing() const { return m_resizing; } + bool noResize() const { return element()->noResize(); } + + bool userResize( DOM::MouseEventImpl *evt ); + bool canResize( int _x, int _y); + void setResizing(bool e); + + Qt::CursorShape cursorShape() const { return m_cursor; } + + bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction hitTestAction, bool inside); + + DOM::HTMLFrameSetElementImpl *element() const + { return static_cast<DOM::HTMLFrameSetElementImpl*>(RenderObject::element()); } + +#ifdef ENABLE_DUMP + virtual void dump(TQTextStream &stream, const TQString &ind) const; +#endif + +private: + Qt::CursorShape m_cursor; + int m_oldpos; + int m_gridLen[2]; + int* m_gridDelta[2]; + int* m_gridLayout[2]; + + bool *m_hSplitVar; // is this split variable? + bool *m_vSplitVar; + + int m_hSplit; // the split currently resized + int m_vSplit; + int m_hSplitPos; + int m_vSplitPos; + + bool m_resizing; + bool m_clientresizing; +}; + +class RenderPart : public tdehtml::RenderWidget +{ + Q_OBJECT +public: + RenderPart(DOM::HTMLElementImpl* node); + + virtual const char *renderName() const { return "RenderPart"; } + + virtual void setWidget( TQWidget *widget ); + + /** + * Called by KHTMLPart to notify the frame object that loading the + * part was not successfuly. (called either asyncroniously after a + * after the servicetype of the given url (the one passed with requestObject) + * has been determined or syncroniously from within requestObject) + * + * The default implementation does nothing. + * + * Return false in the normal case, return true if a fallback was found + * and the url was successfully opened. + */ + virtual bool partLoadingErrorNotify( tdehtml::ChildFrame *childFrame, const KURL& url, const TQString& serviceType ); + + virtual short intrinsicWidth() const; + virtual int intrinsicHeight() const; + +public slots: + virtual void slotViewCleared(); +}; + +class RenderFrame : public tdehtml::RenderPart +{ + Q_OBJECT +public: + RenderFrame( DOM::HTMLFrameElementImpl *frame ); + + virtual const char *renderName() const { return "RenderFrame"; } + virtual bool isFrame() const { return true; } + + // frames never have padding + virtual int paddingTop() const { return 0; } + virtual int paddingBottom() const { return 0; } + virtual int paddingLeft() const { return 0; } + virtual int paddingRight() const { return 0; } + + DOM::HTMLFrameElementImpl *element() const + { return static_cast<DOM::HTMLFrameElementImpl*>(RenderObject::element()); } + +public slots: + void slotViewCleared(); +}; + +// I can hardly call the class RenderObject ;-) +class RenderPartObject : public tdehtml::RenderPart +{ + Q_OBJECT +public: + RenderPartObject( DOM::HTMLElementImpl * ); + + virtual const char *renderName() const { return "RenderPartObject"; } + + virtual void close(); + + virtual void layout( ); + virtual void updateWidget(); + + virtual bool canHaveBorder() const { return true; } + + virtual bool partLoadingErrorNotify( tdehtml::ChildFrame *childFrame, const KURL& url, const TQString& serviceType ); + +public slots: + void slotViewCleared(); +private slots: + void slotPartLoadingErrorNotify(); +}; + +} + +#endif diff --git a/tdehtml/rendering/render_generated.cpp b/tdehtml/rendering/render_generated.cpp new file mode 100644 index 000000000..2b793e504 --- /dev/null +++ b/tdehtml/rendering/render_generated.cpp @@ -0,0 +1,392 @@ +/** + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "rendering/render_generated.h" +#include "rendering/render_style.h" +#include "rendering/enumerate.h" +#include "rendering/counter_tree.h" +#include "css/css_valueimpl.h" + +using namespace tdehtml; +using namespace Enumerate; + +// ------------------------------------------------------------------------- + +RenderCounterBase::RenderCounterBase(DOM::NodeImpl* node) + : RenderText(node,0), m_counterNode(0) +{ +} + +void RenderCounterBase::layout() +{ + KHTMLAssert( needsLayout() ); + + if ( !minMaxKnown() ) + calcMinMaxWidth(); + + RenderText::layout(); +} + +void RenderCounterBase::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + generateContent(); + + if (str) str->deref(); + str = new DOM::DOMStringImpl(m_item.unicode(), m_item.length()); + str->ref(); + + RenderText::calcMinMaxWidth(); +} + + +void RenderCounterBase::updateContent() +{ + setMinMaxKnown(false); +} + +// ------------------------------------------------------------------------- + +RenderCounter::RenderCounter(DOM::NodeImpl* node, const DOM::CounterImpl* counter) + : RenderCounterBase(node), m_counter(counter) +{ +} + +TQString RenderCounter::toListStyleType(int value, int total, EListStyleType type) +{ + TQString item; + switch(type) + { + case LNONE: + break; +// Glyphs: (these values are not really used and instead handled by RenderGlyph) + case LDISC: + item = TQChar(0x2022); + break; + case LCIRCLE: + item = TQChar(0x25e6); + break; + case LSQUARE: + item = TQChar(0x25a0); + break; + case LBOX: + item = TQChar(0x25a1); + break; + case LDIAMOND: + item = TQChar(0x25c6); + break; +// Numeric: + case LDECIMAL: + item.setNum ( value ); + break; + case DECIMAL_LEADING_ZERO: { + int decimals = 2; + int t = total/100; + while (t>0) { + t = t/10; + decimals++; + } + decimals = kMax(decimals, 2); + TQString num = TQString::number(value); + item.fill('0',decimals-num.length()); + item.append(num); + break; + } + case ARABIC_INDIC: + item = toArabicIndic( value ); + break; + case LAO: + item = toLao( value ); + break; + case PERSIAN: + case URDU: + item = toPersianUrdu( value ); + break; + case THAI: + item = toThai( value ); + break; + case TIBETAN: + item = toTibetan( value ); + break; +// Algoritmic: + case LOWER_ROMAN: + item = toRoman( value, false ); + break; + case UPPER_ROMAN: + item = toRoman( value, true ); + break; + case HEBREW: + item = toHebrew( value ); + break; + case ARMENIAN: + item = toArmenian( value ); + break; + case GEORGIAN: + item = toGeorgian( value ); + break; +// Alphabetic: + case LOWER_ALPHA: + case LOWER_LATIN: + item = toLowerLatin( value ); + break; + case UPPER_ALPHA: + case UPPER_LATIN: + item = toUpperLatin( value ); + break; + case LOWER_GREEK: + item = toLowerGreek( value ); + break; + case UPPER_GREEK: + item = toUpperGreek( value ); + break; + case HIRAGANA: + item = toHiragana( value ); + break; + case HIRAGANA_IROHA: + item = toHiraganaIroha( value ); + break; + case KATAKANA: + item = toKatakana( value ); + break; + case KATAKANA_IROHA: + item = toKatakanaIroha( value ); + break; +// Ideographic: + case JAPANESE_FORMAL: + item = toJapaneseFormal( value ); + break; + case JAPANESE_INFORMAL: + item = toJapaneseInformal( value ); + break; + case SIMP_CHINESE_FORMAL: + item = toSimpChineseFormal( value ); + break; + case SIMP_CHINESE_INFORMAL: + item = toSimpChineseInformal( value ); + break; + case TRAD_CHINESE_FORMAL: + item = toTradChineseFormal( value ); + break; + case CJK_IDEOGRAPHIC: + // CSS 3 List says treat as trad-chinese-informal + case TRAD_CHINESE_INFORMAL: + item = toTradChineseInformal( value ); + break; + default: + item.setNum ( value ); + break; + } + return item; +} + +void RenderCounter::generateContent() +{ + bool counters; + counters = !m_counter->separator().isNull(); + + if (!m_counterNode) + m_counterNode = getCounter(m_counter->identifier().string(), true, counters); + + int value = m_counterNode->count(); + if (m_counterNode->isReset()) value = m_counterNode->value(); + int total = value; + if (m_counterNode->parent()) total = m_counterNode->parent()->total(); + m_item = toListStyleType(value, total, (EListStyleType)m_counter->listStyle()); + + if (counters) { + CounterNode *counter = m_counterNode->parent(); + // we deliberately do not render the root counter-node + while(counter->parent() && !(counter->isReset() && counter->parent()->isRoot())) { + value = counter->count(); + total = counter->parent()->total(); + m_item = toListStyleType(value, total, (EListStyleType)m_counter->listStyle()) + m_counter->separator().string() + m_item; + counter = counter->parent(); + }; + } + +} + +// ------------------------------------------------------------------------- + +RenderQuote::RenderQuote(DOM::NodeImpl* node, EQuoteContent type) + : RenderCounterBase(node), m_quoteType(type) +{ +} + + +int RenderQuote::quoteCount() const +{ + switch(m_quoteType) { + case OPEN_QUOTE: + case NO_OPEN_QUOTE: + return 1; + case CLOSE_QUOTE: + case NO_CLOSE_QUOTE: + return -1; + case NO_QUOTE: + return 0; + } + assert(false); + return 0; +} + +void RenderQuote::generateContent() +{ + bool visual; + if (m_quoteType == NO_CLOSE_QUOTE || m_quoteType == NO_OPEN_QUOTE) + visual = false; + else + visual = true; + + if (!m_counterNode) + m_counterNode = getCounter("-tdehtml-quotes", visual, false); + + int value = m_counterNode->count(); + if (m_counterNode->isReset()) value = m_counterNode->value(); + switch (m_quoteType) { + case OPEN_QUOTE: + m_item = style()->openQuote( value ); + break; + case CLOSE_QUOTE: + m_item = style()->closeQuote( value ); + break; + case NO_OPEN_QUOTE: + case NO_CLOSE_QUOTE: + case NO_QUOTE: + m_item = TQString(); + } +} + +// ------------------------------------------------------------------------- + +RenderGlyph::RenderGlyph(DOM::NodeImpl* node, EListStyleType type) + : RenderBox(node), m_type(type) +{ + setInline(true); +// setReplaced(true); +} + +void RenderGlyph::setStyle(RenderStyle *_style) +{ + RenderBox::setStyle(_style); + + const TQFontMetrics &fm = style()->fontMetrics(); + TQRect xSize= fm.boundingRect('x'); + m_height = xSize.height(); + m_width = xSize.width();; + + switch(m_type) { + // Glyphs: + case LDISC: + case LCIRCLE: + case LSQUARE: + case LBOX: + case LDIAMOND: + case LNONE: + break; + default: + // not a glyph ! + assert(false); + break; + } +} + +void RenderGlyph::calcMinMaxWidth() +{ + m_minWidth = m_width; + m_maxWidth = m_width; + + setMinMaxKnown(); +} + +short RenderGlyph::lineHeight(bool /*b*/) const +{ + return height(); +} + +short RenderGlyph::baselinePosition(bool /*b*/) const +{ + return height(); +} + +void RenderGlyph::paint(PaintInfo& paintInfo, int _tx, int _ty) +{ + if (paintInfo.phase != PaintActionForeground) + return; + + if (style()->visibility() != VISIBLE) return; + + _tx += m_x; + _ty += m_y; + + if((_ty > paintInfo.r.bottom()) || (_ty + m_height <= paintInfo.r.top())) + return; + + TQPainter* p = paintInfo.p; + + const TQColor color( style()->color() ); + p->setPen( color ); + + int xHeight = m_height; + int bulletWidth = (xHeight+1)/2; + int yoff = (xHeight - 1)/4; + TQRect marker(_tx, _ty + yoff, bulletWidth, bulletWidth); + + switch(m_type) { + case LDISC: + p->setBrush( color ); + p->drawEllipse( marker ); + return; + case LCIRCLE: + p->setBrush( Qt::NoBrush ); + p->drawEllipse( marker ); + return; + case LSQUARE: + p->setBrush( color ); + p->drawRect( marker ); + return; + case LBOX: + p->setBrush( Qt::NoBrush ); + p->drawRect( marker ); + return; + case LDIAMOND: { + static TQPointArray diamond(4); + int x = marker.x(); + int y = marker.y(); + int s = bulletWidth/2; + diamond[0] = TQPoint(x+s, y); + diamond[1] = TQPoint(x+2*s, y+s); + diamond[2] = TQPoint(x+s, y+2*s); + diamond[3] = TQPoint(x, y+s); + p->setBrush( color ); + p->drawConvexPolygon( diamond, 0, 4 ); + return; + } + case LNONE: + return; + default: + // not a glyph + assert(false); + } +} + diff --git a/tdehtml/rendering/render_generated.h b/tdehtml/rendering/render_generated.h new file mode 100644 index 000000000..4e6aa6053 --- /dev/null +++ b/tdehtml/rendering/render_generated.h @@ -0,0 +1,125 @@ +/* + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 2004,2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_GENERATED_H +#define RENDER_GENERATED_H + +#include "rendering/render_text.h" +#include "rendering/render_box.h" + +namespace DOM { + class CounterImpl; +} + +namespace tdehtml { + class CounterNode; + +// ----------------------------------------------------------------------------- + +class RenderCounterBase : public RenderText +{ +public: + RenderCounterBase(DOM::NodeImpl* node); + + virtual const char *renderName() const { return "RenderCounterBase"; } + + virtual void layout( ); + virtual void calcMinMaxWidth(); + virtual bool isCounter() const { return true; } + + virtual void generateContent() = 0; + void updateContent(); + +protected: + TQString m_item; + CounterNode *m_counterNode; // Cache of the counternode +}; + +// ----------------------------------------------------------------------------- + +class RenderCounter : public RenderCounterBase +{ +public: + RenderCounter(DOM::NodeImpl* node, const DOM::CounterImpl* counter); + virtual ~RenderCounter() {}; + + virtual const char *renderName() const { return "RenderCounter"; } + + virtual void generateContent(); + +protected: + TQString toListStyleType(int value, int total, EListStyleType type); + + const DOM::CounterImpl* m_counter; +}; + +// ----------------------------------------------------------------------------- + +class RenderQuote : public RenderCounterBase +{ +public: + RenderQuote(DOM::NodeImpl* node, EQuoteContent type); + virtual ~RenderQuote() {}; + + virtual const char *renderName() const { return "RenderQuote"; } + + virtual bool isQuote() const { return true; } + virtual int quoteCount() const; + + virtual void generateContent(); + +protected: + EQuoteContent m_quoteType; +}; + +// ----------------------------------------------------------------------------- + +// Is actually a special case of renderCounter for non-counted list-styles +// These have traditionally been drawn rather than use Unicode characters +class RenderGlyph : public RenderBox +{ +public: + RenderGlyph(DOM::NodeImpl* node, EListStyleType type); + virtual ~RenderGlyph() {}; + + virtual const char *renderName() const { return "RenderGlyph"; } + + virtual void paint(PaintInfo& paintInfo, int _tx, int _ty); + virtual void calcMinMaxWidth(); + + virtual void setStyle(RenderStyle *_style); + + virtual short lineHeight( bool firstLine ) const; + virtual short baselinePosition( bool firstLine ) const; + + virtual bool isGlyph() const { return true; } + + virtual void position(InlineBox* box, int /*from*/, int /*len*/, bool /*reverse*/) { + setPos( box->xPos(), box->yPos() ); + } + +protected: + EListStyleType m_type; +}; + +} //namespace + +#endif diff --git a/tdehtml/rendering/render_image.cpp b/tdehtml/rendering/render_image.cpp new file mode 100644 index 000000000..d382c9bd1 --- /dev/null +++ b/tdehtml/rendering/render_image.cpp @@ -0,0 +1,604 @@ +/** + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +//#define DEBUG_LAYOUT + +#include "render_image.h" +#include "render_canvas.h" + +#include <tqdrawutil.h> +#include <tqpainter.h> + +#include <kapplication.h> +#include <kdebug.h> +#include <kglobalsettings.h> + +#include "css/csshelper.h" +#include "misc/helper.h" +#include "misc/htmlattrs.h" +#include "misc/loader.h" +#include "misc/htmltags.h" +#include "html/html_formimpl.h" +#include "html/html_imageimpl.h" +#include "html/dtd.h" +#include "xml/dom2_eventsimpl.h" +#include "html/html_documentimpl.h" +#include "html/html_objectimpl.h" +#include "tdehtmlview.h" +#include "tdehtml_part.h" +#include <math.h> + +#include "loading_icon.cpp" + +using namespace DOM; +using namespace tdehtml; + +// ------------------------------------------------------------------------- + +RenderImage::RenderImage(NodeImpl *_element) + : RenderReplaced(_element) +{ + m_oldImage = m_cachedImage = 0; + + m_selectionState = SelectionNone; + berrorPic = false; + + const KHTMLSettings *settings = _element->getDocument()->view()->part()->settings(); + bUnfinishedImageFrame = settings->unfinishedImageFrame(); + + setIntrinsicWidth( 0 ); + setIntrinsicHeight( 0 ); +} + +RenderImage::~RenderImage() +{ + if(m_cachedImage) m_cachedImage->deref( this ); + if(m_oldImage) m_oldImage->deref( this ); +} + +TQPixmap RenderImage::pixmap() const +{ + return m_cachedImage ? m_cachedImage->pixmap() : TQPixmap(); +} + +void RenderImage::setStyle(RenderStyle* _style) +{ + RenderReplaced::setStyle(_style); + // init RenderObject attributes + //setOverhangingContents(style()->height().isPercent()); + setShouldPaintBackgroundOrBorder(true); +} + +void RenderImage::setContentObject(CachedObject* co ) +{ + if (co && m_cachedImage != co) + updateImage( static_cast<CachedImage*>( co ) ); +} + +void RenderImage::setPixmap( const TQPixmap &p, const TQRect& r, CachedImage *o) +{ + if ( o == m_oldImage ) + return; + + if(o != m_cachedImage) { + RenderReplaced::setPixmap(p, r, o); + return; + } + + bool iwchanged = false; + + if(o->isErrorImage()) { + int iw = p.width() + 8; + int ih = p.height() + 8; + + // we have an alt and the user meant it (its not a text we invented) + if ( element() && !alt.isEmpty() && !element()->getAttribute( ATTR_ALT ).isNull()) { + const TQFontMetrics &fm = style()->fontMetrics(); + TQRect br = fm.boundingRect ( 0, 0, 1024, 256, TQt::AlignAuto|TQt::WordBreak, alt.string() ); + if ( br.width() > iw ) + iw = br.width(); + if ( br.height() > ih ) + ih = br.height(); + } + + if ( iw != intrinsicWidth() ) { + setIntrinsicWidth( iw ); + iwchanged = true; + } + if ( ih != intrinsicHeight() ) { + setIntrinsicHeight( ih ); + iwchanged = true; + } + if ( element() && element()->id() == ID_OBJECT ) { + static_cast<HTMLObjectElementImpl*>( element() )->renderAlternative(); + return; + } + } + berrorPic = o->isErrorImage(); + + bool needlayout = false; + + // Image dimensions have been changed, see what needs to be done + if( o->pixmap_size().width() != intrinsicWidth() || + o->pixmap_size().height() != intrinsicHeight() || iwchanged ) + { +// tqDebug("image dimensions have been changed, old: %d/%d new: %d/%d", +// intrinsicWidth(), intrinsicHeight(), +// o->pixmap_size().width(), o->pixmap_size().height()); + + if(!o->isErrorImage()) { + setIntrinsicWidth( o->pixmap_size().width() ); + setIntrinsicHeight( o->pixmap_size().height() ); + } + + // lets see if we need to relayout at all.. + int oldwidth = m_width; + int oldheight = m_height; + int oldminwidth = m_minWidth; + m_minWidth = 0; + + if ( parent() ) { + calcWidth(); + calcHeight(); + } + + if(iwchanged || m_width != oldwidth || m_height != oldheight) + needlayout = true; + + m_minWidth = oldminwidth; + m_width = oldwidth; + m_height = oldheight; + } + + // we're not fully integrated in the tree yet.. we'll come back. + if ( !parent() ) + return; + + if(needlayout) + { + if (!selfNeedsLayout()) + setNeedsLayout(true); + if (minMaxKnown()) + setMinMaxKnown(false); + } + else + { + bool completeRepaint = !resizeCache.isNull(); + int cHeight = contentHeight(); + int scaledHeight = intrinsicHeight() ? ((o->valid_rect().height()*cHeight)/intrinsicHeight()) : 0; + + // don't bog down X server doing xforms + if(completeRepaint && cHeight >= 5 && o->valid_rect().height() < intrinsicHeight() && + (scaledHeight / (cHeight/5) == resizeCache.height() / (cHeight/5))) + return; + + resizeCache = TQPixmap(); // for resized animations + + if(completeRepaint) + repaintRectangle(borderLeft()+paddingLeft(), borderTop()+paddingTop(), contentWidth(), contentHeight()); + else + { + repaintRectangle(r.x() + borderLeft() + paddingLeft(), r.y() + borderTop() + paddingTop(), + r.width(), r.height()); + } + } +} + +void RenderImage::paint(PaintInfo& paintInfo, int _tx, int _ty) +{ + if (paintInfo.phase == PaintActionOutline && style()->outlineWidth() && style()->visibility() == VISIBLE) + paintOutline(paintInfo.p, _tx + m_x, _ty + m_y, width(), height(), style()); + + if (paintInfo.phase != PaintActionForeground && paintInfo.phase != PaintActionSelection) + return; + + // not visible or not even once layouted? + if (style()->visibility() != VISIBLE || m_y <= -500000) return; + + _tx += m_x; + _ty += m_y; + + if((_ty > paintInfo.r.bottom()) || (_ty + m_height <= paintInfo.r.top())) return; + + if(shouldPaintBackgroundOrBorder()) + paintBoxDecorations(paintInfo, _tx, _ty); + + int cWidth = contentWidth(); + int cHeight = contentHeight(); + int leftBorder = borderLeft(); + int topBorder = borderTop(); + int leftPad = paddingLeft(); + int topPad = paddingTop(); + + if (!canvas()->printImages()) + return; + + CachedImage* i = m_oldImage && m_oldImage->valid_rect().size() == m_oldImage->pixmap_size() && + m_oldImage->pixmap_size().width() == intrinsicWidth() && + m_oldImage->pixmap_size().height() == intrinsicHeight() + ? m_oldImage : m_cachedImage; + + // paint frame around image as long as it is not completely loaded from web. + if (bUnfinishedImageFrame && paintInfo.phase == PaintActionForeground && cWidth > 2 && cHeight > 2 && !complete()) { + static TQPixmap *loadingIcon; + TQColor bg = tdehtml::retrieveBackgroundColor(this); + TQColor fg = tdehtml::hasSufficientContrast(Qt::gray, bg) ? Qt::gray : + (hasSufficientContrast(Qt::white, bg) ? Qt::white : Qt::black); + paintInfo.p->setPen(TQPen(fg, 1)); + paintInfo.p->setBrush( Qt::NoBrush ); + paintInfo.p->drawRect(_tx, _ty, m_width, m_height); + if (!(m_width <= 5 || m_height <= 5)) { + if (!loadingIcon) { + loadingIcon = new TQPixmap(); + loadingIcon->loadFromData(loading_icon_data, loading_icon_len); + } + paintInfo.p->drawPixmap(_tx + 4, _ty + 4, *loadingIcon, 0, 0, m_width - 5, m_height - 5); + } + + } + + //kdDebug( 6040 ) << " contents (" << contentWidth << "/" << contentHeight << ") border=" << borderLeft() << " padding=" << paddingLeft() << endl; + if ( !i || berrorPic) + { + if(cWidth > 2 && cHeight > 2) + { + if ( !berrorPic ) { + //tqDebug("qDrawShadePanel %d/%d/%d/%d", _tx + leftBorder, _ty + topBorder, cWidth, cHeight); + qDrawShadePanel( paintInfo.p, _tx + leftBorder + leftPad, _ty + topBorder + topPad, cWidth, cHeight, + TDEApplication::palette().inactive(), true, 1 ); + } + TQPixmap const* pix = i ? &i->pixmap() : 0; + if(berrorPic && pix && (cWidth >= pix->width()+4) && (cHeight >= pix->height()+4) ) + { + TQRect r(pix->rect()); + r = r.intersect(TQRect(0, 0, cWidth-4, cHeight-4)); + paintInfo.p->drawPixmap( TQPoint( _tx + leftBorder + leftPad+2, _ty + topBorder + topPad+2), *pix, r ); + } + if(!alt.isEmpty()) { + TQString text = alt.string(); + paintInfo.p->setFont(style()->font()); + paintInfo.p->setPen( style()->color() ); + int ax = _tx + leftBorder + leftPad + 2; + int ay = _ty + topBorder + topPad + 2; + const TQFontMetrics &fm = style()->fontMetrics(); + if (cWidth>5 && cHeight>=fm.height()) + paintInfo.p->drawText(ax, ay+1, cWidth - 4, cHeight - 4, TQt::WordBreak, text ); + } + } + } + else if (i && !i->isTransparent()) + { + paintInfo.p->setPen( Qt::black ); // used for bitmaps + const TQPixmap& pix = i->pixmap(); + if ( (cWidth != intrinsicWidth() || cHeight != intrinsicHeight()) && + pix.width() > 0 && pix.height() > 0 && i->valid_rect().isValid()) + { + if (resizeCache.isNull() && cWidth && cHeight && intrinsicWidth() && intrinsicHeight()) + { + TQRect scaledrect(i->valid_rect()); +// kdDebug(6040) << "time elapsed: " << dt->elapsed() << endl; +// kdDebug( 6040 ) << "have to scale: " << endl; +// tqDebug("cw=%d ch=%d pw=%d ph=%d rcw=%d, rch=%d", +// cWidth, cHeight, intrinsicWidth(), intrinsicHeight(), resizeCache.width(), resizeCache.height()); + TQWMatrix matrix; + matrix.scale( (float)(cWidth)/intrinsicWidth(), + (float)(cHeight)/intrinsicHeight() ); + resizeCache = pix.xForm( matrix ); + scaledrect.setWidth( ( cWidth*scaledrect.width() ) / intrinsicWidth() ); + scaledrect.setHeight( ( cHeight*scaledrect.height() ) / intrinsicHeight() ); +// tqDebug("resizeCache size: %d/%d", resizeCache.width(), resizeCache.height()); +// tqDebug("valid: %d/%d, scaled: %d/%d", +// i->valid_rect().width(), i->valid_rect().height(), +// scaledrect.width(), scaledrect.height()); + + // sometimes scaledrect.width/height are off by one because + // of rounding errors. if the i is fully loaded, we + // make sure that we don't do unnecessary resizes during painting + TQSize s(scaledrect.size()); + if(i->valid_rect().size() == TQSize( intrinsicWidth(), intrinsicHeight() )) // fully loaded + s = TQSize(cWidth, cHeight); + if(kAbs(s.width() - cWidth) < 2) // rounding errors + s.setWidth(cWidth); + if(resizeCache.size() != s) + resizeCache.resize(s); + + paintInfo.p->drawPixmap( TQPoint( _tx + leftBorder + leftPad, _ty + topBorder + topPad), + resizeCache, scaledrect ); + } + else + paintInfo.p->drawPixmap( TQPoint( _tx + leftBorder + leftPad, _ty + topBorder + topPad), resizeCache ); + } + else + { + // we might be just about switching images + TQRect rect(i->valid_rect().isValid() ? i->valid_rect() + : TQRect(0, 0, intrinsicWidth(), intrinsicHeight())); + + TQPoint offs( _tx + leftBorder + leftPad, _ty + topBorder + topPad); +// tqDebug("normal paint rect %d/%d/%d/%d", rect.x(), rect.y(), rect.width(), rect.height()); +// rect = rect & TQRect( 0 , y - offs.y() - 10, w, 10 + y + h - offs.y()); + +// tqDebug("normal paint rect after %d/%d/%d/%d", rect.x(), rect.y(), rect.width(), rect.height()); +// tqDebug("normal paint: offs.y(): %d, y: %d, diff: %d", offs.y(), y, y - offs.y()); +// tqDebug(""); + +// p->setClipRect(TQRect(x,y,w,h)); + + +// p->drawPixmap( offs.x(), y, pix, rect.x(), rect.y(), rect.width(), rect.height() ); + paintInfo.p->drawPixmap(offs, pix, rect); + + } + } + if (m_selectionState != SelectionNone) { +// kdDebug(6040) << "_tx " << _tx << " _ty " << _ty << " _x " << _x << " _y " << _y << endl; + // Draw in any case if inside selection. For selection borders, the + // offset will decide whether to draw selection or not + bool draw = true; + if (m_selectionState != SelectionInside) { + int startPos, endPos; + selectionStartEnd(startPos, endPos); + if(selectionState() == SelectionStart) + endPos = 1; + else if(selectionState() == SelectionEnd) + startPos = 0; + draw = endPos - startPos > 0; + } + if (draw) { + // setting the brush origin is important for compatibility, + // don't touch it unless you know what you're doing + paintInfo.p->setBrushOrigin(_tx, _ty - paintInfo.r.y()); + paintInfo.p->fillRect(_tx, _ty, width(), height(), + TQBrush(style()->palette().active().highlight(), + Qt::Dense4Pattern)); + } + } +} + +void RenderImage::layout() +{ + KHTMLAssert( needsLayout()); + KHTMLAssert( minMaxKnown() ); + + short oldwidth = m_width; + int oldheight = m_height; + + // minimum height + m_height = m_cachedImage && m_cachedImage->isErrorImage() ? intrinsicHeight() : 0; + + calcWidth(); + calcHeight(); + + // if they are variable width and we calculate a huge height or width, we assume they + // actually wanted the intrinsic width. + if ( m_width > 4096 && !style()->width().isFixed() ) + m_width = intrinsicWidth() + paddingLeft() + paddingRight() + borderLeft() + borderRight(); + if ( m_height > 2048 && !style()->height().isFixed() ) + m_height = intrinsicHeight() + paddingTop() + paddingBottom() + borderTop() + borderBottom(); + + // limit total size to not run out of memory when doing the xform call. + if ( ( m_width * m_height > 4096*2048 ) && + ( contentWidth() > intrinsicWidth() || contentHeight() > intrinsicHeight() ) ) { + float scale = sqrt( m_width*m_height / ( 4096.*2048. ) ); + m_width = (int) (m_width/scale); + m_height = (int) (m_height/scale); + } + + if ( m_width != oldwidth || m_height != oldheight ) + resizeCache = TQPixmap(); + + setNeedsLayout(false); +} + +void RenderImage::notifyFinished(CachedObject *finishedObj) +{ + if ( ( m_cachedImage == finishedObj || m_oldImage == finishedObj ) && m_oldImage ) { + m_oldImage->deref( this ); + m_oldImage = 0; + repaint(); + } + + RenderReplaced::notifyFinished(finishedObj); +} + +bool RenderImage::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inside) +{ + inside |= RenderReplaced::nodeAtPoint(info, _x, _y, _tx, _ty, hitTestAction, inside); + + if (inside && element()) { + int tx = _tx + m_x; + int ty = _ty + m_y; + if (isRelPositioned()) + relativePositionOffset(tx, ty); + + HTMLImageElementImpl* i = element()->id() == ID_IMG ? static_cast<HTMLImageElementImpl*>(element()) : 0; + HTMLMapElementImpl* map; + if (i && i->getDocument()->isHTMLDocument() && + (map = static_cast<HTMLDocumentImpl*>(i->getDocument())->getMap(i->imageMap()))) { + // we're a client side image map + inside = map->mapMouseEvent(_x - tx, _y - ty, contentWidth(), contentHeight(), info); + info.setInnerNonSharedNode(element()); + } + } + + return inside; +} + +void RenderImage::updateImage(CachedImage* new_image) +{ + CachedImage* tempimage = m_oldImage; + m_oldImage = m_cachedImage; + m_cachedImage = new_image; + assert( m_cachedImage != m_oldImage ); + + if ( m_cachedImage ) + m_cachedImage->ref(this); + + if ( tempimage ) + tempimage->deref(this); + + // if the loading finishes we might get an error and then the image is deleted + if ( m_cachedImage ) + berrorPic = m_cachedImage->isErrorImage(); + else + berrorPic = true; +} + +void RenderImage::updateFromElement() +{ + if (element()->id() == ID_INPUT) + alt = static_cast<HTMLInputElementImpl*>(element())->altText(); + else if (element()->id() == ID_IMG) + alt = static_cast<HTMLImageElementImpl*>(element())->altText(); + + DOMString u = element()->id() == ID_OBJECT ? + element()->getAttribute(ATTR_DATA) : element()->getAttribute(ATTR_SRC); + + if (!u.isEmpty() && + ( !m_cachedImage || m_cachedImage->url() != u ) ) { + CachedImage *new_image = element()->getDocument()->docLoader()-> + requestImage(tdehtml::parseURL(u)); + + if(new_image && new_image != m_cachedImage) + updateImage( new_image ); + } +} + +bool RenderImage::complete() const +{ + // "complete" means that the image has been loaded + // but also that its width/height (contentWidth(),contentHeight()) have been calculated. + return m_cachedImage && m_cachedImage->valid_rect().size() == m_cachedImage->pixmap_size() && !needsLayout(); +} + +bool RenderImage::isWidthSpecified() const +{ + switch (style()->width().type()) { + case Fixed: + case Percent: + return true; + default: + return false; + } + assert(false); + return false; +} + +bool RenderImage::isHeightSpecified() const +{ + switch (style()->height().type()) { + case Fixed: + case Percent: + return true; + default: + return false; + } + assert(false); + return false; +} + +short RenderImage::calcAspectRatioWidth() const +{ + if (intrinsicHeight() == 0) + return 0; + if (!m_cachedImage || m_cachedImage->isErrorImage()) + return intrinsicWidth(); // Don't bother scaling. + return RenderReplaced::calcReplacedHeight() * intrinsicWidth() / intrinsicHeight(); +} + +int RenderImage::calcAspectRatioHeight() const +{ + if (intrinsicWidth() == 0) + return 0; + if (!m_cachedImage || m_cachedImage->isErrorImage()) + return intrinsicHeight(); // Don't bother scaling. + return RenderReplaced::calcReplacedWidth() * intrinsicHeight() / intrinsicWidth(); +} + +short RenderImage::calcReplacedWidth() const +{ + int width; + if (isWidthSpecified()) + width = calcReplacedWidthUsing(Width); + else + width = calcAspectRatioWidth(); + int minW = calcReplacedWidthUsing(MinWidth); + int maxW = style()->maxWidth().value() == UNDEFINED ? width : calcReplacedWidthUsing(MaxWidth); + + if (width > maxW) + width = maxW; + + if (width < minW) + width = minW; + + return width; +} + +int RenderImage::calcReplacedHeight() const +{ + int height; + if (isHeightSpecified()) + height = calcReplacedHeightUsing(Height); + else + height = calcAspectRatioHeight(); + + int minH = calcReplacedHeightUsing(MinHeight); + int maxH = style()->maxHeight().value() == UNDEFINED ? height : calcReplacedHeightUsing(MaxHeight); + + if (height > maxH) + height = maxH; + + if (height < minH) + height = minH; + + return height; +} + +#if 0 +void RenderImage::caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height) +{ + RenderReplaced::caretPos(offset, flags, _x, _y, width, height); + +#if 0 // doesn't work reliably + height = intrinsicHeight(); + width = override && offset == 0 ? intrinsicWidth() : 0; + _x = xPos(); + _y = yPos(); + if (offset > 0) _x += intrinsicWidth(); + + RenderObject *cb = containingBlock(); + + int absx, absy; + if (cb && cb != this && cb->absolutePosition(absx,absy)) + { + _x += absx; + _y += absy; + } else { + // we don't know our absolute position, and there is no point returning + // just a relative one + _x = _y = -1; + } +#endif +} +#endif diff --git a/tdehtml/rendering/render_image.h b/tdehtml/rendering/render_image.h new file mode 100644 index 000000000..9bd0bce4c --- /dev/null +++ b/tdehtml/rendering/render_image.h @@ -0,0 +1,105 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_IMAGE_H +#define RENDER_IMAGE_H + +#include "html/dtd.h" +#include "html/html_elementimpl.h" +#include "rendering/render_replaced.h" +#include "dom/dom_string.h" + +#include <tqmap.h> +#include <tqpixmap.h> + +namespace tdehtml { + +class DocLoader; +class CachedObject; + +class RenderImage : public RenderReplaced +{ +public: + RenderImage(DOM::NodeImpl* _element); + virtual ~RenderImage(); + + virtual const char *renderName() const { return "RenderImage"; } + virtual void paint( PaintInfo& i, int tx, int ty ); + + virtual void layout(); + + virtual void setPixmap( const TQPixmap &, const TQRect&, CachedImage *); + + // don't even think about making these methods virtual! + TQPixmap pixmap() const; + DOM::HTMLElementImpl* element() const + { return static_cast<DOM::HTMLElementImpl*>(RenderObject::element()); } + + bool complete() const; + + CachedObject *contentObject() { return m_cachedImage; } + void setContentObject( CachedObject* ); + + // hook to keep RendeObject::m_inline() up to date + virtual void setStyle(RenderStyle *style); + virtual void updateFromElement(); + + virtual void notifyFinished(CachedObject *finishedObj); + virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction hitTestAction, bool inside); + + bool isWidthSpecified() const; + bool isHeightSpecified() const; + + short calcAspectRatioWidth() const; + int calcAspectRatioHeight() const; + + virtual short calcReplacedWidth() const; + virtual int calcReplacedHeight() const; + + virtual SelectionState selectionState() const {return m_selectionState;} + virtual void setSelectionState(SelectionState s) {m_selectionState = s; } +#if 0 + virtual void caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height); +#endif + +private: + void updateImage(CachedImage* new_image); + /* + * Cache for images that need resizing + */ + TQPixmap resizeCache; + + // text to display as long as the image isn't available + DOM::DOMString alt; + + CachedImage *m_cachedImage; + CachedImage *m_oldImage; + + bool berrorPic : 1; + bool bUnfinishedImageFrame :1; + SelectionState m_selectionState : 3; // FIXME: don't forget to enlarge this as the enum grows +}; + + +} //namespace + +#endif diff --git a/tdehtml/rendering/render_inline.cpp b/tdehtml/rendering/render_inline.cpp new file mode 100644 index 000000000..96841eb43 --- /dev/null +++ b/tdehtml/rendering/render_inline.cpp @@ -0,0 +1,935 @@ +/* + * This file is part of the render object implementation for KHTML. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999-2003 Antti Koivisto (koivisto@kde.org) + * (C) 2002-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include <kglobal.h> + +#include "rendering/render_arena.h" +#include "rendering/render_inline.h" +#include "rendering/render_block.h" +#include "xml/dom_docimpl.h" + +#include <tqvaluevector.h> + +using namespace tdehtml; + +void RenderInline::setStyle(RenderStyle* _style) +{ + RenderFlow::setStyle(_style); + setInline(true); + + // Ensure that all of the split inlines pick up the new style. We + // only do this if we're an inline, since we don't want to propagate + // a block's style to the other inlines. + // e.g., <font>foo <h4>goo</h4> moo</font>. The <font> inlines before + // and after the block share the same style, but the block doesn't + // need to pass its style on to anyone else. + RenderFlow* currCont = continuation(); + while (currCont) { + if (currCont->isInline()) { + RenderFlow* nextCont = currCont->continuation(); + currCont->setContinuation(0); + currCont->setStyle(style()); + currCont->setContinuation(nextCont); + } + currCont = currCont->continuation(); + } + + if (attached()) { + // Update replaced content + updateReplacedContent(); + // Update pseudos for ::before and ::after + updatePseudoChildren(); + } +} + +// Attach handles initial setStyle that requires parent nodes +void RenderInline::attach() +{ + RenderFlow::attach(); + + updateReplacedContent(); + updatePseudoChildren(); +} + +bool RenderInline::isInlineContinuation() const +{ + return m_isContinuation; +} + +void RenderInline::addChildToFlow(RenderObject* newChild, RenderObject* beforeChild) +{ + // Make sure we don't append things after :after-generated content if we have it. + if (!beforeChild && lastChild() && lastChild()->style()->styleType() == RenderStyle::AFTER) + beforeChild = lastChild(); + + if (!newChild->isText() && newChild->style()->position() != STATIC) + setOverhangingContents(); + + if (!newChild->isInline() && !newChild->isFloatingOrPositioned() ) + { + // We are placing a block inside an inline. We have to perform a split of this + // inline into continuations. This involves creating an anonymous block box to hold + // |newChild|. We then make that block box a continuation of this inline. We take all of + // the children after |beforeChild| and put them in a clone of this object. + + RenderBlock *newBox = createAnonymousBlock(); + RenderFlow* oldContinuation = continuation(); + setContinuation(newBox); + + splitFlow(beforeChild, newBox, newChild, oldContinuation); + return; + } + + RenderBox::addChild(newChild,beforeChild); + + newChild->setNeedsLayoutAndMinMaxRecalc(); +} + +RenderInline* RenderInline::cloneInline(RenderFlow* src) +{ + RenderInline *o = new (src->renderArena()) RenderInline(src->element()); + o->m_isContinuation = true; + o->setStyle(src->style()); + return o; +} + +void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock, + RenderBlock* middleBlock, + RenderObject* beforeChild, RenderFlow* oldCont) +{ + // Create a clone of this inline. + RenderInline* clone = cloneInline(this); + clone->setContinuation(oldCont); + + // Now take all of the children from beforeChild to the end and remove + // then from |this| and place them in the clone. + RenderObject* o = beforeChild; + while (o) { + RenderObject* tmp = o; + o = tmp->nextSibling(); + clone->addChildToFlow(removeChildNode(tmp), 0); + tmp->setNeedsLayoutAndMinMaxRecalc(); + } + + // Hook |clone| up as the continuation of the middle block. + middleBlock->setContinuation(clone); + + // We have been reparented and are now under the fromBlock. We need + // to walk up our inline parent chain until we hit the containing block. + // Once we hit the containing block we're done. + RenderFlow* curr = static_cast<RenderFlow*>(parent()); + RenderFlow* currChild = this; + while (curr && curr != fromBlock) { + // Create a new clone. + RenderInline* cloneChild = clone; + clone = cloneInline(curr); + + // Insert our child clone as the first child. + clone->addChildToFlow(cloneChild, 0); + + // Hook the clone up as a continuation of |curr|. + RenderFlow* oldCont = curr->continuation(); + curr->setContinuation(clone); + clone->setContinuation(oldCont); + + // Now we need to take all of the children starting from the first child + // *after* currChild and append them all to the clone. + o = currChild->nextSibling(); + while (o) { + RenderObject* tmp = o; + o = tmp->nextSibling(); + clone->appendChildNode(curr->removeChildNode(tmp)); + tmp->setNeedsLayoutAndMinMaxRecalc(); + } + + // Keep walking up the chain. + currChild = curr; + curr = static_cast<RenderFlow*>(curr->parent()); + } + + // Now we are at the block level. We need to put the clone into the toBlock. + toBlock->appendChildNode(clone); + + // Now take all the children after currChild and remove them from the fromBlock + // and put them in the toBlock. + o = currChild->nextSibling(); + while (o) { + RenderObject* tmp = o; + o = tmp->nextSibling(); + toBlock->appendChildNode(fromBlock->removeChildNode(tmp)); + } +} + +void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox, + RenderObject* newChild, RenderFlow* oldCont) +{ + RenderBlock* pre = 0; + RenderBlock* block = containingBlock(); + bool madeNewBeforeBlock = false; + if (block->isAnonymousBlock()) { + // We can reuse this block and make it the preBlock of the next continuation. + pre = block; + block = block->containingBlock(); + } + else { + // No anonymous block available for use. Make one. + pre = block->createAnonymousBlock(); + madeNewBeforeBlock = true; + } + + RenderBlock* post = block->createAnonymousBlock(); + + RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling(); + if (madeNewBeforeBlock) + block->insertChildNode(pre, boxFirst); + block->insertChildNode(newBlockBox, boxFirst); + block->insertChildNode(post, boxFirst); + block->setChildrenInline(false); + + if (madeNewBeforeBlock) { + RenderObject* o = boxFirst; + while (o) + { + RenderObject* no = o; + o = no->nextSibling(); + pre->appendChildNode(block->removeChildNode(no)); + no->setNeedsLayoutAndMinMaxRecalc(); + } + } + + splitInlines(pre, post, newBlockBox, beforeChild, oldCont); + + // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting + // time in makeChildrenNonInline by just setting this explicitly up front. + newBlockBox->setChildrenInline(false); + + // We don't just call addChild, since it would pass things off to the + // continuation, so we call addChildToFlow explicitly instead. We delayed + // adding the newChild until now so that the |newBlockBox| would be fully + // connected, thus allowing newChild access to a renderArena should it need + // to wrap itself in additional boxes (e.g., table construction). + newBlockBox->addChildToFlow(newChild, 0); + + // XXXdwh is any of this even necessary? I don't think it is. + pre->close(); + pre->setPos(0, -500000); + pre->setNeedsLayout(true); + newBlockBox->close(); + newBlockBox->setPos(0, -500000); + newBlockBox->setNeedsLayout(true); + post->close(); + post->setPos(0, -500000); + post->setNeedsLayout(true); + + updatePseudoChildren(); + + block->setNeedsLayoutAndMinMaxRecalc(); +} + +void RenderInline::paint(PaintInfo& i, int _tx, int _ty) +{ + paintLines(i, _tx, _ty); +} + +/** + * Appends the given coordinate-pair to the point-array if it is not + * equal to the last element. + * @param pointArray point-array + * @param pnt point to append + * @return \c true if \c pnt has actually been appended + */ +inline static bool appendIfNew(TQValueVector<TQPoint> &pointArray, const TQPoint &pnt) +{ +// if (!pointArray.isEmpty()) kdDebug(6040) << "appifnew: " << pointArray.back() << " == " << pnt << ": " << (pointArray.back() == pnt) << endl; +// else kdDebug(6040) << "appifnew: " << pnt << " (unconditional)" << endl; + if (!pointArray.isEmpty() && pointArray.back() == pnt) return false; + pointArray.append(pnt); + return true; +} + +/** + * Does spike-reduction on the given point-array's stack-top. + * + * Spikes are path segments of which one goes forward, and the sucessor + * goes backward on the predecessor's segment: + * + * 2 0 1 + * x------x<-----x + * (0 is stack-top in point-array) + * + * This will be reduced to + * 1 0 + * x------x + * + * Preconditions: + * - No other spikes exist in the whole point-array except at most + * one at the end + * - No two succeeding points are ever equal + * - For each two succeeding points either p1.x == p2.x or p1.y == p2.y holds + * true + * - No such spike exists where 2 is situated between 0 and 1. + * + * Postcondition: + * - No spikes exist in the whole point-array + * + * If no spike is found, the point-array is left unchanged. + * @return \c true if an actual reduction was done + */ +inline static bool reduceSpike(TQValueVector<TQPoint> &pointArray) +{ + if (pointArray.size() < 3) return false; + TQValueVector<TQPoint>::Iterator it = pointArray.end(); + TQPoint p0 = *--it; + TQPoint p1 = *--it; + TQPoint p2 = *--it; + + bool elide = false; + + if (p0.x() == p1.x() && p1.x() == p2.x() + && (p1.y() < p0.y() && p0.y() < p2.y() + || p2.y() < p0.y() && p0.y() < p1.y() + || p1.y() < p2.y() && p2.y() < p0.y() + || p0.y() < p2.y() && p2.y() < p1.y() + || (elide = p2.y() == p0.y() && p0.y() < p1.y()) + || (elide = p1.y() < p0.y() && p0.y() == p2.y())) + || p0.y() == p1.y() && p1.y() == p2.y() + && (p1.x() < p0.x() && p0.x() < p2.x() + || p2.x() < p0.x() && p0.x() < p1.x() + || p1.x() < p2.x() && p2.x() < p0.x() + || p0.x() < p2.x() && p2.x() < p1.x() + || (elide = p2.x() == p0.x() && p0.x() < p1.x()) + || (elide = p1.x() < p0.x() && p0.x() == p2.x()))) + { +// kdDebug(6040) << "spikered p2" << (elide ? " (elide)" : "") << ": " << p2 << " p1: " << p1 << " p0: " << p0 << endl; + pointArray.pop_back(); pointArray.pop_back(); + if (!elide) + pointArray.push_back(p0); + return true; + } + return false; +} + +/** + * Reduces segment separators. + * + * A segment separator separates a segment into two segments, thus causing + * two adjacent segment with the same orientation. + * + * 2 1 0 + * x-------x---->x + * (0 means stack-top) + * + * Here, 1 is a segment separator. As segment separators not only make + * the line drawing algorithm inefficient, but also make the spike-reduction + * fail, they must be eliminated: + * + * 1 0 + * x------------>x + * + * Preconditions: + * - No other segment separators exist in the whole point-array except + * at most one at the end + * - No two succeeding points are ever equal + * - For each two succeeding points either p1.x == p2.x or p1.y == p2.y holds + * true + * - No such spike exists where 2 is situated between 0 and 1. + * + * Postcondition: + * - No segment separators exist in the whole point-array + * + * If no segment separator is found at the end of the point-array, it is + * left unchanged. + * @return \c true if a segment separator was actually reduced. + */ +inline static bool reduceSegmentSeparator(TQValueVector<TQPoint> &pointArray) +{ + if (pointArray.size() < 3) return false; + TQValueVector<TQPoint>::Iterator it = pointArray.end(); + TQPoint p0 = *--it; + TQPoint p1 = *--it; + TQPoint p2 = *--it; +// kdDebug(6040) << "checking p2: " << p2 << " p1: " << p1 << " p0: " << p0 << endl; + + if (p0.x() == p1.x() && p1.x() == p2.x() + && (p2.y() < p1.y() && p1.y() < p0.y() + || p0.y() < p1.y() && p1.y() < p2.y()) + || p0.y() == p1.y() && p1.y() == p2.y() + && (p2.x() < p1.x() && p1.x() < p0.x() + || p0.x() < p1.x() && p1.x() < p2.x())) + { +// kdDebug(6040) << "segred p2: " << p2 << " p1: " << p1 << " p0: " << p0 << endl; + pointArray.pop_back(); pointArray.pop_back(); + pointArray.push_back(p0); + return true; + } + return false; +} + +/** + * Appends the given point to the point-array, doing necessary reductions to + * produce a path without spikes and segment separators. + */ +static void appendPoint(TQValueVector<TQPoint> &pointArray, TQPoint &pnt) +{ + if (!appendIfNew(pointArray, pnt)) return; +// kdDebug(6040) << "appendPoint: appended " << pnt << endl; + reduceSegmentSeparator(pointArray) + || reduceSpike(pointArray); +} + +/** + * Traverses the horizontal inline boxes and appends the point coordinates to + * the given array. + * @param box inline box + * @param pointArray array collecting coordinates + * @param bottom \c true, collect bottom coordinates, \c false, collect top + * coordinates. + * @param limit lower limit that an y-coordinate must at least reach. Note + * that limit designates the highest y-coordinate for \c bottom, and + * the lowest for !\c bottom. + */ +static void collectHorizontalBoxCoordinates(InlineBox *box, + TQValueVector<TQPoint> &pointArray, + bool bottom, int offset, int limit = -500000) +{ +// kdDebug(6000) << "collectHorizontalBoxCoordinates: " << endl; + offset = bottom ? offset:-offset; + int y = box->yPos() + bottom*box->height() + offset; + if (limit != -500000 && (bottom ? y < limit : y > limit)) + y = limit; + int x = box->xPos() + bottom*box->width() + offset; + TQPoint newPnt(x, y); + // Add intersection point if point-array not empty. + if (!pointArray.isEmpty()) { + TQPoint lastPnt = pointArray.back(); + TQPoint insPnt(newPnt.x(), lastPnt.y()); + if (offset && ((bottom && lastPnt.y() > y) || (!bottom && lastPnt.y() < y))) { + insPnt.rx() = lastPnt.x(); + insPnt.ry() = y; + } +// kdDebug(6040) << "left: " << lastPnt << " == " << insPnt << ": " << (insPnt == lastPnt) << endl; + appendPoint(pointArray, insPnt); + } + // Insert starting point of box + appendPoint(pointArray, newPnt); + + newPnt.rx() += (bottom ? -box->width() : box->width()) - 2*offset; + + if (box->isInlineFlowBox()) { + InlineFlowBox *flowBox = static_cast<InlineFlowBox *>(box); + for (InlineBox *b = bottom ? flowBox->lastChild() : flowBox->firstChild(); b; b = bottom ? b->prevOnLine() : b->nextOnLine()) { + // Don't let boxes smaller than this flow box' height influence + // the vertical position of the outline if they have a different + // x-coordinate + int l2; + if (b->xPos() != box->xPos() && b->xPos() + b->width() != box->xPos() + box->width()) + l2 = y; + else + l2 = limit; + collectHorizontalBoxCoordinates(b, pointArray, bottom, kAbs(offset), l2); + } + + // Add intersection point if flow box contained any children + if (flowBox->firstChild()) { + TQPoint lastPnt = pointArray.back(); + TQPoint insPnt(lastPnt.x(), newPnt.y()); +// kdDebug(6040) << "right: " << lastPnt << " == " << insPnt << ": " << (insPnt == lastPnt) << endl; + appendPoint(pointArray, insPnt); + } + } + + // Insert ending point of box + appendPoint(pointArray, newPnt); + +// kdDebug(6000) << "collectHorizontalBoxCoordinates: " << "ende" << endl; +} + +/** + * Checks whether the given line box' extents and the following line box' + * extents are disjount (i. e. do not share the same x-coordinate range). + * @param line line box + * @param toBegin \c true, compare with preceding line box, \c false, with + * succeeding + * @return \c true if this and the next box are disjoint + */ +inline static bool lineBoxesDisjoint(InlineRunBox *line, int offset, bool toBegin) +{ + InlineRunBox *next = toBegin ? line->prevLineBox() : line->nextLineBox(); + return !next || next->xPos() + next->width() + 2*offset < line->xPos() + || next->xPos() > line->xPos() + line->width() + 2*offset; +} + +/** + * Traverses the vertical outer borders of the given render flow's line + * boxes and appends the point coordinates to the given point array. + * @param line line box to begin traversal + * @param pointArray point array + * @param left \c true, traverse the left vertical coordinates, + * \c false, traverse the right vertical coordinates. + * @param lastline if not 0, returns the pointer to the last line box traversed + */ +static void collectVerticalBoxCoordinates(InlineRunBox *line, + TQValueVector<TQPoint> &pointArray, + bool left, int offset, InlineRunBox **lastline = 0) +{ + InlineRunBox *last = 0; + offset = left ? -offset:offset; + for (InlineRunBox* curr = line; curr && !last; curr = left ? curr->prevLineBox() : curr->nextLineBox()) { + InlineBox *root = curr; + + bool isLast = lineBoxesDisjoint(curr, kAbs(offset), left); + if (isLast) last = curr; + + if (root != line && !isLast) + while (root->parent()) root = root->parent(); + TQPoint newPnt(curr->xPos() + !left*curr->width() + offset, + (left ? root->topOverflow() : root->bottomOverflow()) + offset); + if (!pointArray.isEmpty()) { + TQPoint lastPnt = pointArray.back(); + if (newPnt.x()>lastPnt.x() && !left) + pointArray.back().setY( kMin(lastPnt.y(), root->topOverflow()-offset) ); + else if (newPnt.x()<lastPnt.x() && left) + pointArray.back().setY( kMax(lastPnt.y(), root->bottomOverflow()+offset) ); + TQPoint insPnt(newPnt.x(), pointArray.back().y()); +// kdDebug(6040) << "left: " << lastPnt << " == " << insPnt << ": " << (insPnt == lastPnt) << endl; + appendPoint(pointArray, insPnt); + } + appendPoint(pointArray, newPnt); + } + if (lastline) *lastline = last; +} + +/** + * Links up the end of the given point-array such that the starting point + * is not a segment separator. + * + * To achieve this, improper points are removed from the beginning of + * the point-array (by changing the array's starting iterator), and + * proper ones appended to the point-array's back. + * + * @param pointArray point-array + * @return actual begin of point array + */ +static TQPoint *linkEndToBegin(TQValueVector<TQPoint> &pointArray) +{ + uint index = 0; + assert(pointArray.size() >= 3); + + // if first and last points match, ignore the last one. + bool linkup = false; TQPoint linkupPnt; + if (pointArray.front() == pointArray.back()) { + linkupPnt = pointArray.back(); + pointArray.pop_back(); + linkup = true; + } + + const TQPoint *it = pointArray.begin() + index; + TQPoint pfirst = *it; + TQPoint pnext = *++it; + TQPoint plast = pointArray.back(); +// kdDebug(6040) << "linkcheck plast: " << plast << " pfirst: " << pfirst << " pnext: " << pnext << endl; + + if (plast.x() == pfirst.x() && pfirst.x() == pnext.x() + || plast.y() == pfirst.y() && pfirst.y() == pnext.y()) { + + ++index; + appendPoint(pointArray, pfirst); + appendPoint(pointArray, pnext); + } else if (linkup) + pointArray.push_back(linkupPnt); + return pointArray.begin() + index; +} + +void RenderInline::paintOutlines(TQPainter *p, int _tx, int _ty) +{ + if (style()->outlineWidth() == 0 || style()->outlineStyle() <= BHIDDEN) + return; + int offset = style()->outlineOffset(); + + // We may have to draw more than one outline path as they may be + // disjoint. + for (InlineRunBox *curr = firstLineBox(); curr; curr = curr->nextLineBox()) { + TQValueVector<TQPoint> path; + + // collect topmost outline + collectHorizontalBoxCoordinates(curr, path, false, offset); + // collect right outline + collectVerticalBoxCoordinates(curr, path, false, offset, &curr); + // collect bottommost outline + collectHorizontalBoxCoordinates(curr, path, true, offset); + // collect left outline + collectVerticalBoxCoordinates(curr, path, true, offset); + + if (path.size() < 3) continue; + + const TQPoint *begin = linkEndToBegin(path); + + // paint the outline + paintOutlinePath(p, _tx, _ty, begin, path.end(), BSLeft, -1, BSTop); + } +} + +template<class T> inline void kSwap(T &a1, T &a2) +{ + T tmp = a2; + a2 = a1; + a1 = tmp; +} + +enum BSOrientation { BSHorizontal, BSVertical }; + +/** + * Returns the orientation of the given border side. + */ +inline BSOrientation bsOrientation(RenderObject::BorderSide bs) +{ + switch (bs) { + case RenderObject::BSTop: + case RenderObject::BSBottom: + return BSHorizontal; + case RenderObject::BSLeft: + case RenderObject::BSRight: + return BSVertical; + } + return BSHorizontal; // make gcc happy (sigh) +} + +/** + * Determines the new border side by evaluating the new direction as determined + * by the given coordinates, the old border side, and the relative direction. + * + * The relative direction specifies whether the old border side meets with the + * straight given by the coordinates from below (negative), or above (positive). + */ +inline RenderObject::BorderSide newBorderSide(RenderObject::BorderSide oldBS, int direction, const TQPoint &last, const TQPoint &cur) +{ + bool below = direction < 0; + if (last.x() == cur.x()) { // new segment is vertical + bool t = oldBS == RenderObject::BSTop; + bool b = oldBS == RenderObject::BSBottom; + if ((t || b) && last.y() != cur.y()) + return (cur.y() < last.y()) ^ (t && below || b && !below) + ? RenderObject::BSLeft : RenderObject::BSRight; + } else /*if (last.y() == cur.y())*/ { // new segment is horizontal + bool l = oldBS == RenderObject::BSLeft; + bool r = oldBS == RenderObject::BSRight; + if ((l || r) && last.x() != cur.x()) + return (cur.x() < last.x()) ^ (l && below || r && !below) + ? RenderObject::BSTop : RenderObject::BSBottom; + } + return oldBS; // same direction +} + +/** + * Draws an outline segment between the given two points. + * @param o render object + * @param p painter + * @param tx absolute x-coordinate of containing block + * @param ty absolute y-coordinate of containing block + * @param p1 starting point + * @param p2 end point + * @param prevBS border side of previous segment + * @param curBS border side of this segment + * @param nextBS border side of next segment + */ +static void paintOutlineSegment(RenderObject *o, TQPainter *p, int tx, int ty, + const TQPoint &p1, const TQPoint &p2, + RenderObject::BorderSide prevBS, + RenderObject::BorderSide curBS, + RenderObject::BorderSide nextBS) +{ + int ow = o->style()->outlineWidth(); + EBorderStyle os = o->style()->outlineStyle(); + TQColor oc = o->style()->outlineColor(); + + int x1 = tx + p1.x(); + int y1 = ty + p1.y(); + int x2 = tx + p2.x(); + int y2 = ty + p2.y(); + if (x1 > x2) { + kSwap(x1, x2); + if (bsOrientation(curBS) == BSHorizontal) kSwap(prevBS, nextBS); + } + if (y1 > y2) { + kSwap(y1, y2); + if (bsOrientation(curBS) == BSVertical) kSwap(prevBS, nextBS); + } + +// kdDebug(6040) << "segment(" << x1 << "," << y1 << ") - (" << x2 << "," << y2 << ")" << endl; +/* p->setPen(Qt::gray); + p->drawLine(x1,y1,x2,y2);*/ + switch (curBS) { + case RenderObject::BSLeft: + case RenderObject::BSRight: +/* p->setPen(TQColor("#ffe4dd")); + p->drawLine( + x1 - (curBS == RenderObject::BSLeft ? ow : 0), + y1 - (prevBS == RenderObject::BSTop ? ow : 0), + x2 + (curBS == RenderObject::BSRight ? ow : 0), + y2 + (nextBS == RenderObject::BSBottom ? ow : 0) + );*/ + o->drawBorder(p, + x1 - (curBS == RenderObject::BSLeft ? ow : 0), + y1 - (prevBS == RenderObject::BSTop ? ow : 0), + x2 + (curBS == RenderObject::BSRight ? ow : 0), + y2 + (nextBS == RenderObject::BSBottom ? ow : 0), + curBS, oc, o->style()->color(), os, + prevBS == RenderObject::BSTop ? ow + : prevBS == RenderObject::BSBottom ? -ow : 0, + nextBS == RenderObject::BSTop ? -ow + : nextBS == RenderObject::BSBottom ? ow : 0, + true); + break; + case RenderObject::BSBottom: + case RenderObject::BSTop: +// kdDebug(6040) << "BSTop/BSBottom: prevBS " << prevBS << " curBS " << curBS << " nextBS " << nextBS << endl; + o->drawBorder(p, + x1 - (prevBS == RenderObject::BSLeft ? ow : 0), + y1 - (curBS == RenderObject::BSTop ? ow : 0), + x2 + (nextBS == RenderObject::BSRight ? ow : 0), + y2 + (curBS == RenderObject::BSBottom ? ow : 0), + curBS, oc, o->style()->color(), os, + prevBS == RenderObject::BSLeft ? ow + : prevBS == RenderObject::BSRight ? -ow : 0, + nextBS == RenderObject::BSLeft ? -ow + : nextBS == RenderObject::BSRight ? ow : 0, + true); + break; + } +} + +void RenderInline::paintOutlinePath(TQPainter *p, int tx, int ty, const TQPoint *begin, const TQPoint *end, BorderSide bs, int direction, BorderSide endingBS) +{ + int ow = style()->outlineWidth(); + if (ow == 0 || m_isContinuation) // Continuations get painted by the original inline. + return; + + TQPoint last = *begin; + BorderSide lastBS = bs; + Q_ASSERT(begin != end); + ++begin; + +// kdDebug(6040) << "last: " << last << endl; + + bs = newBorderSide(bs, direction, last, *begin); +// kdDebug(6040) << "newBorderSide: " << lastBS << " " << direction << "d " << last << " - " << *begin << " => " << bs << endl; + + for (const TQPoint *it = begin; it != end; ++it) { + TQPoint cur = *it; +// kdDebug(6040) << "cur: " << cur << endl; + BorderSide nextBS; + if (it + 1 != end) { + TQPoint diff = cur - last; + direction = diff.x() + diff.y(); + nextBS = newBorderSide(bs, direction, cur, *(it + 1)); +// kdDebug(6040) << "newBorderSide*: " << bs << " " << direction << "d " << cur << " - " << *(it + 1) << " => " << nextBS << endl; + } else + nextBS = endingBS; + + Q_ASSERT(bsOrientation(bs) != bsOrientation(nextBS)); + paintOutlineSegment(this, p, tx, ty, last, cur, + lastBS, bs, nextBS); + lastBS = bs; + last = cur; + bs = nextBS; + } + +} + +void RenderInline::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(RenderInline)::calcMinMaxWidth() this=" << this << endl; +#endif + + // Irrelevant, since some enclosing block will actually measure us and our children. + m_minWidth = 0; + m_maxWidth = 0; + + setMinMaxKnown(); +} + +short RenderInline::width() const +{ + // Return the width of the minimal left side and the maximal right side. + short leftSide = 0; + short rightSide = 0; + for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) { + if (curr == firstLineBox() || curr->xPos() < leftSide) + leftSide = curr->xPos(); + if (curr == firstLineBox() || curr->xPos() + curr->width() > rightSide) + rightSide = curr->xPos() + curr->width(); + } + + return rightSide - leftSide; +} + +int RenderInline::height() const +{ + int h = 0; + if (firstLineBox()) + h = lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos(); + return h; +} + +int RenderInline::offsetLeft() const +{ + int x = RenderFlow::offsetLeft(); + if (firstLineBox()) + x += firstLineBox()->xPos(); + return x; +} + +int RenderInline::offsetTop() const +{ + int y = RenderFlow::offsetTop(); + if (firstLineBox()) + y += firstLineBox()->yPos(); + return y; +} + +const char *RenderInline::renderName() const +{ + if (isRelPositioned()) + return "RenderInline (relative positioned)"; + if (isAnonymous()) + return "RenderInline (anonymous)"; + return "RenderInline"; +} + +bool RenderInline::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inside) +{ +/* + if ( hitTestAction != HitTestSelfOnly ) { + for (RenderObject* child = lastChild(); child; child = child->previousSibling()) + if (!child->layer() && !child->isFloating() && child->nodeAtPoint(info, _x, _y, _tx, _ty, HitTestAll)) + inside = true; + } +*/ + // Check our line boxes if we're still not inside. + if (/*hitTestAction != HitTestChildrenOnly &&*/ !inside && style()->visibility() != HIDDEN) { + // See if we're inside one of our line boxes. + inside = hitTestLines(info, _x, _y, _tx, _ty, hitTestAction); + } + + if (inside && element()) { + if (info.innerNode() && info.innerNode()->renderer() && + !info.innerNode()->renderer()->isInline()) { + // Within the same layer, inlines are ALWAYS fully above blocks. Change inner node. + info.setInnerNode(element()); + + // Clear everything else. + info.setInnerNonSharedNode(0); + info.setURLElement(0); + } + + if (!info.innerNode()) + info.setInnerNode(element()); + + if(!info.innerNonSharedNode()) + info.setInnerNonSharedNode(element()); + } + + return inside; +} + +void RenderInline::caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height) +{ + _x = -1; + + RenderBlock *cb = containingBlock(); + bool rtl = cb->style()->direction() == RTL; + bool outsideEnd = flags & CFOutsideEnd; + // I need to explain that: outsideEnd contains a meaningful value if + // and only if flags & CFOutside is set. If it is not, then randomly + // either the first or the last line box is returned. + // This doesn't matter because the only case this can happen is on an + // empty inline element, whose first and last line boxes are actually + // the same. + InlineFlowBox *line = !outsideEnd ^ rtl ? firstLineBox() : lastLineBox(); + + if (!line) { // umpf, handle "gracefully" + RenderFlow::caretPos(offset, flags, _x, _y, width, height); + return; + } + + _x = line->xPos(); + width = 1; // ### regard CFOverride + + // Place caret outside the border + if (flags & CFOutside) { + RenderStyle *s = element() && element()->parent() + && element()->parent()->renderer() + ? element()->parent()->renderer()->style() + : style(); + const TQFontMetrics &fm = s->fontMetrics(); + _y = line->yPos() + line->baseline() - fm.ascent(); + height = fm.height(); + + if (!outsideEnd ^ rtl) { + _x -= line->marginBorderPaddingLeft(); + } else { + _x += line->width() + line->marginBorderPaddingRight(); + } + + } else { + const TQFontMetrics &fm = style()->fontMetrics(); + _y = line->yPos() + line->baseline() - fm.ascent(); + height = fm.height(); + } + + int absx, absy; + if (cb && cb->absolutePosition(absx,absy)) { + //kdDebug(6040) << "absx=" << absx << " absy=" << absy << endl; + _x += absx; + _y += absy; + } else { + // we don't know our absolute position, and there is no point returning + // just a relative one + _x = _y = -1; + } +} + +inline int minXPos(const RenderInline *o) +{ + int retval=6666666; + if (!o->firstLineBox()) return 0; + for (InlineRunBox* curr = o->firstLineBox(); curr; curr = curr->nextLineBox()) + retval = kMin( retval, int( curr->m_x )); + return retval; +} + +int RenderInline::inlineXPos() const +{ + return minXPos(this); +} + +int RenderInline::inlineYPos() const +{ + return firstLineBox() ? firstLineBox()->yPos() : 0; +} + diff --git a/tdehtml/rendering/render_inline.h b/tdehtml/rendering/render_inline.h new file mode 100644 index 000000000..97392999e --- /dev/null +++ b/tdehtml/rendering/render_inline.h @@ -0,0 +1,94 @@ +/* + * This file is part of the render object implementation for KHTML. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999-2003 Antti Koivisto (koivisto@kde.org) + * (C) 2002-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#ifndef RENDER_INLINE_H +#define RENDER_INLINE_H + +#include "render_flow.h" + +namespace tdehtml { + +class RenderInline : public RenderFlow +{ +public: + RenderInline(DOM::NodeImpl* node) : RenderFlow( node ), m_isContinuation( false ) {} + + virtual const char *renderName() const; + + virtual bool isRenderInline() const { return true; } + virtual bool isInlineFlow() const { return true; } + virtual bool childrenInline() const { return true; } + + virtual bool isInlineContinuation() const; + + virtual void addChildToFlow(RenderObject* newChild, RenderObject* beforeChild); + + void splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock, + RenderObject* beforeChild, RenderFlow* oldCont); + + void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox, + RenderObject* newChild, RenderFlow* oldCont); + + virtual void setStyle(RenderStyle* _style); + virtual void attach(); + + virtual void layout() {} // Do nothing for layout() + + virtual void paint(PaintInfo&, int tx, int ty); + + virtual bool nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inside); + + virtual void calcMinMaxWidth(); + + // overrides RenderObject + virtual bool requiresLayer() const { return isRelPositioned(); } + + virtual short width() const; + virtual int height() const; + + virtual int inlineXPos() const; + virtual int inlineYPos() const; + + // used to calculate offsetWidth/Height. Overridden by inlines (render_flow) to return + // the remaining width on a given line (and the height of a single line). + virtual int offsetLeft() const; + virtual int offsetTop() const; + + virtual void caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height); + void paintOutlines(TQPainter *p, int tx, int ty); + +protected: + static RenderInline* cloneInline(RenderFlow* src); + void paintOutlinePath(TQPainter *p, int tx, int ty, const TQPoint *begin, const TQPoint *end, BorderSide startingBS, int initialDirection, BorderSide endingBS); + +private: + bool m_isContinuation : 1; // Whether or not we're a continuation of an inline. + +}; + +} // namespace + +#endif // RENDER_BLOCK_H + diff --git a/tdehtml/rendering/render_layer.cpp b/tdehtml/rendering/render_layer.cpp new file mode 100644 index 000000000..2b6bbf027 --- /dev/null +++ b/tdehtml/rendering/render_layer.cpp @@ -0,0 +1,1830 @@ +/* + * Copyright (C) 2003 Apple Computer, Inc. + * (C) 2006 Germain Garand <germain@ebooksfrance.org> + * (C) 2006 Allan Sandfeld Jense <kde@carewolf.com> + * + * Portions are Copyright (C) 1998 Netscape Communications Corporation. + * + * Other contributors: + * Robert O'Callahan <roc+@cs.cmu.edu> + * David Baron <dbaron@fas.harvard.edu> + * Christian Biesinger <cbiesinger@web.de> + * Randall Jesup <rjesup@wgate.com> + * Roland Mainz <roland.mainz@informatik.med.uni-giessen.de> + * Josh Soref <timeless@mac.com> + * Boris Zbarsky <bzbarsky@mit.edu> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Alternatively, the contents of this file may be used under the terms + * of either the Mozilla Public License Version 1.1, found at + * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public + * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html + * (the "GPL"), in which case the provisions of the MPL or the GPL are + * applicable instead of those above. If you wish to allow use of your + * version of this file only under the terms of one of those two + * licenses (the MPL or the GPL) and not to allow others to use your + * version of this file under the LGPL, indicate your decision by + * deletingthe provisions above and replace them with the notice and + * other provisions required by the MPL or the GPL, as the case may be. + * If you do not delete the provisions above, a recipient may use your + * version of this file under any of the LGPL, the MPL or the GPL. + */ + +//#define BOX_DEBUG + +#include "render_layer.h" +#include <kdebug.h> +#include <assert.h> +#include "tdehtmlview.h" +#include "render_canvas.h" +#include "render_arena.h" +#include "render_replaced.h" +#include "xml/dom_docimpl.h" +#include "xml/dom2_eventsimpl.h" +#include "misc/htmltags.h" +#include "html/html_blockimpl.h" +#include "xml/dom_restyler.h" + +#include <tqscrollbar.h> +#include <tqptrvector.h> +#include <tqstyle.h> + +using namespace DOM; +using namespace tdehtml; + +#ifdef APPLE_CHANGES +TQScrollBar* RenderLayer::gScrollBar = 0; +#endif + +#ifndef NDEBUG +static bool inRenderLayerDetach; +#endif + +void +RenderScrollMediator::slotValueChanged() +{ + m_layer->updateScrollPositionFromScrollbars(); +} + +RenderLayer::RenderLayer(RenderObject* object) +: m_object( object ), +m_parent( 0 ), +m_previous( 0 ), +m_next( 0 ), +m_first( 0 ), +m_last( 0 ), +m_x( 0 ), +m_y( 0 ), +m_scrollX( 0 ), +m_scrollY( 0 ), +m_scrollWidth( 0 ), +m_scrollHeight( 0 ), +m_hBar( 0 ), +m_vBar( 0 ), +m_scrollMediator( 0 ), +m_posZOrderList( 0 ), +m_negZOrderList( 0 ), +m_overflowList(0), +m_zOrderListsDirty( true ), +m_overflowListDirty(true), +m_isOverflowOnly( shouldBeOverflowOnly() ), +m_markedForRepaint( false ), +m_hasOverlaidWidgets( false ), +m_marquee( 0 ) +{ +} + +RenderLayer::~RenderLayer() +{ + // Child layers will be deleted by their corresponding render objects, so + // our destructor doesn't have to do anything. + delete m_hBar; + delete m_vBar; + delete m_scrollMediator; + delete m_posZOrderList; + delete m_negZOrderList; + delete m_overflowList; + delete m_marquee; +} + +void RenderLayer::updateLayerPosition() +{ + + // The canvas is sized to the docWidth/Height over in RenderCanvas::layout, so we + // don't need to ever update our layer position here. + if (renderer()->isCanvas()) + return; + + int x = m_object->xPos(); + int y = m_object->yPos() - m_object->borderTopExtra(); + + if (!m_object->isPositioned()) { + // We must adjust our position by walking up the render tree looking for the + // nearest enclosing object with a layer. + RenderObject* curr = m_object->parent(); + while (curr && !curr->layer()) { + x += curr->xPos(); + y += curr->yPos(); + curr = curr->parent(); + } + if (curr) + y += curr->borderTopExtra(); + } + + if (m_object->isRelPositioned()) + static_cast<RenderBox*>(m_object)->relativePositionOffset(x, y); + + // Subtract our parent's scroll offset. + if (m_object->isPositioned() && enclosingPositionedAncestor()) { + RenderLayer* positionedParent = enclosingPositionedAncestor(); + + // For positioned layers, we subtract out the enclosing positioned layer's scroll offset. + positionedParent->subtractScrollOffset(x, y); + positionedParent->checkInlineRelOffset(m_object, x, y); + } + else if (parent()) + parent()->subtractScrollOffset(x, y); + + setPos(x,y); +} + +TQRegion RenderLayer::paintedRegion(RenderLayer* rootLayer) +{ + updateZOrderLists(); + TQRegion r; + if (m_negZOrderList) { + uint count = m_negZOrderList->count(); + for (uint i = 0; i < count; i++) { + RenderLayer* child = m_negZOrderList->at(i); + r += child->paintedRegion(rootLayer); + } + } + const RenderStyle *s= renderer()->style(); + if (s->visibility() == VISIBLE) { + int x = 0; int y = 0; + convertToLayerCoords(rootLayer,x,y); + TQRect cr(x,y,width(),height()); + if ( s->backgroundImage() || s->backgroundColor().isValid() || s->hasBorder() || + renderer()->scrollsOverflow() || renderer()->isReplaced() ) { + r += cr; + } else { + r += renderer()->visibleFlowRegion(x, y); + } + } + + if (m_posZOrderList) { + uint count = m_posZOrderList->count(); + for (uint i = 0; i < count; i++) { + RenderLayer* child = m_posZOrderList->at(i); + r += child->paintedRegion(rootLayer); + } + } + return r; +} + +void RenderLayer::repaint( Priority p, bool markForRepaint ) +{ + if (markForRepaint && m_markedForRepaint) + return; + for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) + child->repaint( p, markForRepaint ); + TQRect layerBounds, damageRect, fgrect; + calculateRects(renderer()->canvas()->layer(), renderer()->viewRect(), layerBounds, damageRect, fgrect); + m_visibleRect = damageRect.intersect( layerBounds ); + if (m_visibleRect.isValid()) + renderer()->canvas()->repaintViewRectangle( m_visibleRect.x(), m_visibleRect.y(), m_visibleRect.width(), m_visibleRect.height(), (p > NormalPriority) ); + if (markForRepaint) + m_markedForRepaint = true; +} + +void RenderLayer::updateLayerPositions(RenderLayer* rootLayer, bool doFullRepaint, bool checkForRepaint) +{ + if (doFullRepaint) { + m_object->repaint(); + checkForRepaint = doFullRepaint = false; + } + + updateLayerPosition(); // For relpositioned layers or non-positioned layers, + // we need to keep in sync, since we may have shifted relative + // to our parent layer. + + if (m_hBar || m_vBar) { + // Need to position the scrollbars. + int x = 0; + int y = 0; + convertToLayerCoords(rootLayer, x, y); + TQRect layerBounds = TQRect(x,y,width(),height()); + positionScrollbars(layerBounds); + } + +#ifdef APPLE_CHANGES + // FIXME: Child object could override visibility. + if (checkForRepaint && (m_object->style()->visibility() == VISIBLE)) + m_object->repaintAfterLayoutIfNeeded(m_repaintRect, m_fullRepaintRect); +#else + if (checkForRepaint && m_markedForRepaint) { + TQRect layerBounds, damageRect, fgrect; + calculateRects(rootLayer, renderer()->viewRect(), layerBounds, damageRect, fgrect); + TQRect vr = damageRect.intersect( layerBounds ); + if (vr != m_visibleRect && vr.isValid()) { + renderer()->canvas()->repaintViewRectangle( vr.x(), vr.y(), vr.width(), vr.height() ); + m_visibleRect = vr; + } + } + m_markedForRepaint = false; +#endif + + for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) + child->updateLayerPositions(rootLayer, doFullRepaint, checkForRepaint); + + // With all our children positioned, now update our marquee if we need to. + if (m_marquee) + m_marquee->updateMarqueePosition(); +} + +void RenderLayer::updateWidgetMasks(RenderLayer* rootLayer) +{ + if (hasOverlaidWidgets() && !renderer()->canvas()->pagedMode()) { + updateZOrderLists(); + uint count = m_posZOrderList ? m_posZOrderList->count() : 0; + bool needUpdate = (count || !m_region.isNull()); + if (count) { + TQScrollView* sv = m_object->document()->view(); + m_region = TQRect(0,0,sv->contentsWidth(),sv->contentsHeight()); + + for (uint i = 0; i < count; i++) { + RenderLayer* child = m_posZOrderList->at(i); + if (child->zIndex() == 0 && child->renderer()->style()->position() == STATIC) + continue; // we don't know the widget's exact stacking position within flow + m_region -= child->paintedRegion(rootLayer); + } + } else { + m_region = TQRegion(); + } + if (needUpdate) + renderer()->updateWidgetMasks(); + } + for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) + child->updateWidgetMasks(rootLayer); +} + +short RenderLayer::width() const +{ + int w = m_object->width(); + if (!m_object->hasOverflowClip()) + w = kMax(m_object->overflowWidth(), w); + return w; +} + +int RenderLayer::height() const +{ + int h = m_object->height() + m_object->borderTopExtra() + m_object->borderBottomExtra(); + if (!m_object->hasOverflowClip()) + h = kMax(m_object->overflowHeight(), h); + return h; +} + + +RenderLayer *RenderLayer::stackingContext() const +{ + RenderLayer* curr = parent(); + for ( ; curr && !curr->m_object->isCanvas() && + curr->m_object->style()->hasAutoZIndex(); + curr = curr->parent()); + return curr; +} + +RenderLayer* RenderLayer::enclosingPositionedAncestor() const +{ + RenderLayer* curr = parent(); + for ( ; curr && !curr->m_object->isCanvas() && + !curr->m_object->isPositioned() && !curr->m_object->isRelPositioned(); + curr = curr->parent()); + + return curr; +} + +#ifdef APPLE_CHANGES +bool RenderLayer::isTransparent() +{ + return m_object->style()->opacity() < 1.0f; +} + +RenderLayer* RenderLayer::transparentAncestor() +{ + RenderLayer* curr = parent(); + for ( ; curr && curr->m_object->style()->opacity() == 1.0f; curr = curr->parent()); + return curr; +} +#endif + +void* RenderLayer::operator new(size_t sz, RenderArena* renderArena) throw() +{ + return renderArena->allocate(sz); +} + +void RenderLayer::operator delete(void* ptr, size_t sz) +{ + assert(inRenderLayerDetach); + + // Stash size where detach can find it. + *(size_t *)ptr = sz; +} + +void RenderLayer::detach(RenderArena* renderArena) +{ +#ifndef NDEBUG + inRenderLayerDetach = true; +#endif + delete this; +#ifndef NDEBUG + inRenderLayerDetach = false; +#endif + + // Recover the size left there for us by operator delete and free the memory. + renderArena->free(*(size_t *)this, this); +} + +void RenderLayer::addChild(RenderLayer *child, RenderLayer* beforeChild) +{ + RenderLayer* prevSibling = beforeChild ? beforeChild->previousSibling() : lastChild(); + if (prevSibling) { + child->setPreviousSibling(prevSibling); + prevSibling->setNextSibling(child); + } + else + setFirstChild(child); + + if (beforeChild) { + beforeChild->setPreviousSibling(child); + child->setNextSibling(beforeChild); + } + else + setLastChild(child); + + child->setParent(this); + + if (child->isOverflowOnly()) + dirtyOverflowList(); + else { + // Dirty the z-order list in which we are contained. The stackingContext() can be null in the + // case where we're building up generated content layers. This is ok, since the lists will start + // off dirty in that case anyway. + RenderLayer* stackingContext = child->stackingContext(); + if (stackingContext) + stackingContext->dirtyZOrderLists(); + } +} + +RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild) +{ + // remove the child + if (oldChild->previousSibling()) + oldChild->previousSibling()->setNextSibling(oldChild->nextSibling()); + if (oldChild->nextSibling()) + oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling()); + + if (m_first == oldChild) + m_first = oldChild->nextSibling(); + if (m_last == oldChild) + m_last = oldChild->previousSibling(); + + if (oldChild->isOverflowOnly()) + dirtyOverflowList(); + else { + // Dirty the z-order list in which we are contained. When called via the + // reattachment process in removeOnlyThisLayer, the layer may already be disconnected + // from the main layer tree, so we need to null-check the |stackingContext| value. + RenderLayer* stackingContext = oldChild->stackingContext(); + if (stackingContext) + stackingContext->dirtyZOrderLists(); + } + + oldChild->setPreviousSibling(0); + oldChild->setNextSibling(0); + oldChild->setParent(0); + + return oldChild; +} + +void RenderLayer::removeOnlyThisLayer() +{ + if (!m_parent) + return; + + // Remove us from the parent. + RenderLayer* parent = m_parent; + RenderLayer* nextSib = nextSibling(); + parent->removeChild(this); + + // Now walk our kids and reattach them to our parent. + RenderLayer* current = m_first; + while (current) { + RenderLayer* next = current->nextSibling(); + removeChild(current); + parent->addChild(current, nextSib); + current = next; + } + + detach(renderer()->renderArena()); +} + +void RenderLayer::insertOnlyThisLayer() +{ + if (!m_parent && renderer()->parent()) { + // We need to connect ourselves when our renderer() has a parent. + // Find our enclosingLayer and add ourselves. + RenderLayer* parentLayer = renderer()->parent()->enclosingLayer(); + if (parentLayer) + parentLayer->addChild(this, + renderer()->parent()->findNextLayer(parentLayer, renderer())); + } + + // Remove all descendant layers from the hierarchy and add them to the new position. + for (RenderObject* curr = renderer()->firstChild(); curr; curr = curr->nextSibling()) + curr->moveLayers(m_parent, this); +} + +void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const +{ + if (ancestorLayer == this) + return; + + if (m_object->style()->position() == FIXED) { + // Add in the offset of the view. We can obtain this by calling + // absolutePosition() on the RenderCanvas. + int xOff, yOff; + m_object->absolutePosition(xOff, yOff, true); + x += xOff; + y += yOff; + return; + } + + RenderLayer* parentLayer; + if (m_object->style()->position() == ABSOLUTE) + parentLayer = enclosingPositionedAncestor(); + else + parentLayer = parent(); + + if (!parentLayer) return; + + parentLayer->convertToLayerCoords(ancestorLayer, x, y); + + x += xPos(); + y += yPos(); +} + +void RenderLayer::scrollOffset(int& x, int& y) +{ + x += scrollXOffset(); + y += scrollYOffset(); +} + +void RenderLayer::subtractScrollOffset(int& x, int& y) +{ + x -= scrollXOffset(); + y -= scrollYOffset(); +} + +void RenderLayer::checkInlineRelOffset(const RenderObject* o, int& x, int& y) +{ + if(o->style()->position() != ABSOLUTE || !renderer()->isRelPositioned() || !renderer()->isInlineFlow()) + return; + + // Our renderer is an enclosing relpositioned inline, we need to add in the offset of the first line + // box from the rest of the content, but only in the cases where we know our descendant is positioned + // relative to the inline itself. + assert( o->container() == m_object ); + + RenderFlow* flow = static_cast<RenderFlow*>(m_object); + int sx = 0, sy = 0; + if (flow->firstLineBox()) { + if (flow->style()->direction() == LTR) + sx = flow->firstLineBox()->xPos(); + else + sx = flow->lastLineBox()->xPos(); + sy = flow->firstLineBox()->yPos(); + } else { + sx = flow->staticX(); // ### + sy = flow->staticY(); + } + bool isInlineType = o->style()->isOriginalDisplayInlineType(); + + if (!o->hasStaticX()) + x += sx; + + // Despite the positioned child being a block display type inside an inline, we still keep + // its x locked to our left. Arguably the correct behavior would be to go flush left to + // the block that contains us, but that isn't what other browsers do. + if (o->hasStaticX() && !isInlineType) + // Avoid adding in the left border/padding of the containing block twice. Subtract it out. + x += sx - (o->containingBlock()->borderLeft() + o->containingBlock()->paddingLeft()); + + if (!o->hasStaticY()) + y += sy; +} + +void RenderLayer::scrollToOffset(int x, int y, bool updateScrollbars, bool repaint) +{ + if (renderer()->style()->overflowX() != OMARQUEE || !renderer()->hasOverflowClip()) { + if (x < 0) x = 0; + if (y < 0) y = 0; + + // Call the scrollWidth/Height functions so that the dimensions will be computed if they need + // to be (for overflow:hidden blocks). + // ### merge the scrollWidth()/scrollHeight() methods + int maxX = m_scrollWidth - m_object->clientWidth(); + int maxY = m_scrollHeight - m_object->clientHeight(); + + if (x > maxX) x = maxX; + if (y > maxY) y = maxY; + } + + // FIXME: Eventually, we will want to perform a blit. For now never + // blit, since the check for blitting is going to be very + // complicated (since it will involve testing whether our layer + // is either occluded by another layer or clipped by an enclosing + // layer or contains fixed backgrounds, etc.). + m_scrollX = x; + m_scrollY = y; + + // Update the positions of our child layers. + RenderLayer* rootLayer = root(); + for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) + child->updateLayerPositions(rootLayer); + + // Fire the scroll DOM event. + m_object->element()->dispatchHTMLEvent(EventImpl::SCROLL_EVENT, true, false); + + // Just schedule a full repaint of our object. + if (repaint) + m_object->repaint(RealtimePriority); + + if (updateScrollbars) { + if (m_hBar) + m_hBar->setValue(m_scrollX); + if (m_vBar) + m_vBar->setValue(m_scrollY); + } +} + +void RenderLayer::updateScrollPositionFromScrollbars() +{ + bool needUpdate = false; + int newX = m_scrollX; + int newY = m_scrollY; + + if (m_hBar) { + newX = m_hBar->value(); + if (newX != m_scrollX) + needUpdate = true; + } + + if (m_vBar) { + newY = m_vBar->value(); + if (newY != m_scrollY) + needUpdate = true; + } + + if (needUpdate) + scrollToOffset(newX, newY, false); +} + +void +RenderLayer::showScrollbar(Qt::Orientation o, bool show) +{ + TQScrollBar *sb = (o == Qt::Horizontal) ? m_hBar : m_vBar; + + if (show && !sb) { + TQScrollView* scrollView = m_object->document()->view(); + sb = new TQScrollBar(o, scrollView, "__tdehtml"); + scrollView->addChild(sb, 0, -50000); + sb->setBackgroundMode(TQWidget::NoBackground); + sb->show(); + if (!m_scrollMediator) + m_scrollMediator = new RenderScrollMediator(this); + m_scrollMediator->connect(sb, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotValueChanged())); + } + else if (!show && sb) { + delete sb; + sb = 0; + } + + if (o == Qt::Horizontal) + m_hBar = sb; + else + m_vBar = sb; +} + +int RenderLayer::verticalScrollbarWidth() +{ + if (!m_vBar) + return 0; + +#ifdef APPLE_CHANGES + return m_vBar->width(); +#else + return m_vBar->style().pixelMetric(TQStyle::PM_ScrollBarExtent); +#endif + +} + +int RenderLayer::horizontalScrollbarHeight() +{ + if (!m_hBar) + return 0; + +#ifdef APPLE_CHANGES + return m_hBar->height(); +#else + return m_hBar->style().pixelMetric(TQStyle::PM_ScrollBarExtent); +#endif + +} + +void RenderLayer::positionScrollbars(const TQRect& absBounds) +{ +#ifdef APPLE_CHANGES + if (m_vBar) { + scrollView->addChild(m_vBar, absBounds.x()+absBounds.width()-m_object->borderRight()-m_vBar->width(), + absBounds.y()+m_object->borderTop()); + m_vBar->resize(m_vBar->width(), absBounds.height() - + (m_object->borderTop()+m_object->borderBottom()) - + (m_hBar ? m_hBar->height()-1 : 0)); + } + + if (m_hBar) { + scrollView->addChild(m_hBar, absBounds.x()+m_object->borderLeft(), + absBounds.y()+absBounds.height()-m_object->borderBottom()-m_hBar->height()); + m_hBar->resize(absBounds.width() - (m_object->borderLeft()+m_object->borderRight()) - + (m_vBar ? m_vBar->width()-1 : 0), m_hBar->height()); + } +#else + int tx = absBounds.x(); + int ty = absBounds.y(); + int bl = m_object->borderLeft(); + int bt = m_object->borderTop(); + int w = width() - bl - m_object->borderRight(); + int h = height() - bt - m_object->borderBottom(); + + if (w <= 0 || h <= 0 || (!m_vBar && !m_hBar)) + return; + + TQScrollView* scrollView = m_object->document()->view(); + + tx += bl; + ty += bt; + + TQScrollBar *b = m_hBar; + if (!m_hBar) + b = m_vBar; + int sw = b->style().pixelMetric(TQStyle::PM_ScrollBarExtent); + + if (m_vBar) { + TQRect vBarRect = TQRect(tx + w - sw + 1, ty, sw, h - (m_hBar ? sw : 0) + 1); + m_vBar->resize(vBarRect.width(), vBarRect.height()); + scrollView->addChild(m_vBar, vBarRect.x(), vBarRect.y()); + } + + if (m_hBar) { + TQRect hBarRect = TQRect(tx, ty + h - sw + 1, w - (m_vBar ? sw : 0) + 1, sw); + m_hBar->resize(hBarRect.width(), hBarRect.height()); + scrollView->addChild(m_hBar, hBarRect.x(), hBarRect.y()); + } +#endif +} + +#define LINE_STEP 10 +#define PAGE_KEEP 40 + +void RenderLayer::checkScrollbarsAfterLayout() +{ + int rightPos = m_object->rightmostPosition(true); + int bottomPos = m_object->lowestPosition(true); + +/* TODO + m_scrollLeft = m_object->leftmostPosition(true); + m_scrollTop = m_object->highestPosition(true); +*/ + + int clientWidth = m_object->clientWidth(); + int clientHeight = m_object->clientHeight(); + m_scrollWidth = clientWidth; + m_scrollHeight = clientHeight; + + if (rightPos - m_object->borderLeft() > m_scrollWidth) + m_scrollWidth = rightPos - m_object->borderLeft(); + if (bottomPos - m_object->borderTop() > m_scrollHeight) + m_scrollHeight = bottomPos - m_object->borderTop(); + + bool needHorizontalBar = rightPos > width(); + bool needVerticalBar = bottomPos > height(); + + bool haveHorizontalBar = m_hBar && m_hBar->isEnabled(); + bool haveVerticalBar = m_vBar && m_vBar->isEnabled(); + + bool hasOvf = m_object->hasOverflowClip(); + + // overflow:scroll should just enable/disable. + if (hasOvf && m_object->style()->overflowX() == OSCROLL) + m_hBar->setEnabled(needHorizontalBar); + if (hasOvf && m_object->style()->overflowY() == OSCROLL) + m_vBar->setEnabled(needVerticalBar); + + // overflow:auto may need to lay out again if scrollbars got added/removed. + bool scrollbarsChanged = (hasOvf && m_object->style()->overflowX() == OAUTO && haveHorizontalBar != needHorizontalBar) + || (hasOvf && m_object->style()->overflowY() == OAUTO && haveVerticalBar != needVerticalBar); + if (scrollbarsChanged) { + if (m_object->style()->overflowX() == OAUTO) { + showScrollbar(Qt::Horizontal, needHorizontalBar); + if (m_hBar) + m_hBar->setEnabled(true); + } + if (m_object->style()->overflowY() == OAUTO) { + showScrollbar(Qt::Vertical, needVerticalBar); + if (m_vBar) + m_vBar->setEnabled(true); + } + + m_object->setNeedsLayout(true); + if (m_object->isRenderBlock()) + static_cast<RenderBlock*>(m_object)->layoutBlock(true); + else + m_object->layout(); + return; + } + + // Set up the range (and page step/line step). + if (m_hBar) { + int pageStep = (clientWidth-PAGE_KEEP); + if (pageStep < 0) pageStep = clientWidth; + m_hBar->setSteps(LINE_STEP, pageStep); +#ifdef APPLE_CHANGES + m_hBar->setKnobProportion(clientWidth, m_scrollWidth); +#else + m_hBar->setRange(0, needHorizontalBar ? m_scrollWidth-clientWidth : 0); +#endif + } + if (m_vBar) { + int pageStep = (clientHeight-PAGE_KEEP); + if (pageStep < 0) pageStep = clientHeight; + m_vBar->setSteps(LINE_STEP, pageStep); +#ifdef APPLE_CHANGES + m_vBar->setKnobProportion(clientHeight, m_scrollHeight); +#else + m_vBar->setRange(0, needVerticalBar ? m_scrollHeight-clientHeight : 0); +#endif + } +} + +void RenderLayer::paintScrollbars(RenderObject::PaintInfo& pI) +{ +#ifdef APPLE_CHANGES + if (m_hBar) + m_hBar->paint(p, damageRect); + if (m_vBar) + m_vBar->paint(p, damageRect); +#else + if (!m_object->element()) + return; + + TQScrollView* scrollView = m_object->document()->view(); + if (m_hBar) { + int x = m_hBar->x(); + int y = m_hBar->y(); + scrollView->viewportToContents(x, y, x, y); + RenderWidget::paintWidget(pI, m_hBar, x, y); + } + if (m_vBar) { + int x = m_vBar->x(); + int y = m_vBar->y(); + scrollView->viewportToContents(x, y, x, y); + RenderWidget::paintWidget(pI, m_vBar, x, y); + } +#endif +} + +void RenderLayer::paint(TQPainter *p, const TQRect& damageRect, bool selectionOnly) +{ + paintLayer(this, p, damageRect, selectionOnly); +} + +static void setClip(TQPainter* p, const TQRect& paintDirtyRect, const TQRect& clipRect) +{ + if (paintDirtyRect == clipRect) + return; + p->save(); + +#ifdef APPLE_CHANGES + p->addClip(clipRect); +#else + + TQRect clippedRect = p->xForm(clipRect); + TQRegion creg(clippedRect); + TQRegion old = p->clipRegion(); + if (!old.isNull()) + creg = old.intersect(creg); + p->setClipRegion(creg); +#endif + +} + +static void restoreClip(TQPainter* p, const TQRect& paintDirtyRect, const TQRect& clipRect) +{ + if (paintDirtyRect == clipRect) + return; + p->restore(); +} + +void RenderLayer::paintLayer(RenderLayer* rootLayer, TQPainter *p, + const TQRect& paintDirtyRect, bool selectionOnly) +{ + // Calculate the clip rects we should use. + TQRect layerBounds, damageRect, clipRectToApply; + calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply); + int x = layerBounds.x(); + int y = layerBounds.y(); + + // Ensure our lists are up-to-date. + updateZOrderLists(); + updateOverflowList(); + +#ifdef APPLE_CHANGES + // Set our transparency if we need to. + if (isTransparent()) + p->beginTransparencyLayer(renderer()->style()->opacity()); +#endif + + // We want to paint our layer, but only if we intersect the damage rect. + bool shouldPaint = intersectsDamageRect(layerBounds, damageRect); + if (shouldPaint && !selectionOnly) { + // Paint our background first, before painting any child layers. + if (!damageRect.isEmpty()) { + // Establish the clip used to paint our background. + setClip(p, paintDirtyRect, damageRect); + + // Paint the background. + RenderObject::PaintInfo paintInfo(p, damageRect, PaintActionElementBackground); + renderer()->paint(paintInfo, + x - renderer()->xPos(), y - renderer()->yPos() + renderer()->borderTopExtra()); + + // Position our scrollbars. + positionScrollbars(layerBounds); + + // Our scrollbar widgets paint exactly when we tell them to, so that they work properly with + // z-index. We paint after we painted the background/border, so that the scrollbars will + // sit above the background/border. + paintScrollbars(paintInfo); + + // Restore the clip. + restoreClip(p, paintDirtyRect, damageRect); + } + } + + // Now walk the sorted list of children with negative z-indices. + if (m_negZOrderList) { + uint count = m_negZOrderList->count(); + for (uint i = 0; i < count; i++) { + RenderLayer* child = m_negZOrderList->at(i); + child->paintLayer(rootLayer, p, paintDirtyRect, selectionOnly); + } + } + + // Now establish the appropriate clip and paint our child RenderObjects. + if (shouldPaint && !clipRectToApply.isEmpty()) { + // Set up the clip used when painting our children. + setClip(p, paintDirtyRect, clipRectToApply); + + RenderObject::PaintInfo paintInfo(p, clipRectToApply, PaintActionSelection); + + int tx = x - renderer()->xPos(); + int ty = y - renderer()->yPos() + renderer()->borderTopExtra(); + + if (selectionOnly) + renderer()->paint(paintInfo, tx, ty); + else { + paintInfo.phase = PaintActionChildBackgrounds; + renderer()->paint(paintInfo, tx, ty); + paintInfo.phase = PaintActionFloat; + renderer()->paint(paintInfo, tx, ty); + paintInfo.phase = PaintActionForeground; + renderer()->paint(paintInfo, tx, ty); + RenderCanvas *rc = static_cast<RenderCanvas*>(renderer()->document()->renderer()); + if (rc->maximalOutlineSize()) { + paintInfo.phase = PaintActionOutline; + renderer()->paint(paintInfo, tx, ty); + } + if (rc->selectionStart() && rc->selectionEnd()) { + paintInfo.phase = PaintActionSelection; + renderer()->paint(paintInfo, tx, ty); + } + } + + // Now restore our clip. + restoreClip(p, paintDirtyRect, clipRectToApply); + } + + // Paint any child layers that have overflow. + if (m_overflowList) + for (TQValueList<RenderLayer*>::iterator it = m_overflowList->begin(); it != m_overflowList->end(); ++it) + (*it)->paintLayer(rootLayer, p, paintDirtyRect, selectionOnly); + + // Now walk the sorted list of children with positive z-indices. + if (m_posZOrderList) { + uint count = m_posZOrderList->count(); + for (uint i = 0; i < count; i++) { + RenderLayer* child = m_posZOrderList->at(i); + child->paintLayer(rootLayer, p, paintDirtyRect, selectionOnly); + } + } + +#ifdef BOX_DEBUG + { + int ax=0; + int ay=0; + renderer()->absolutePosition( ax, ay ); + p->setPen(TQPen(TQColor("yellow"), 1, Qt::DotLine)); + p->setBrush( Qt::NoBrush ); + p->drawRect(ax, ay, width(), height()); + } +#endif + +#ifdef APPLE_CHANGES + // End our transparency layer + if (isTransparent()) + p->endTransparencyLayer(); +#endif +} + +bool RenderLayer::nodeAtPoint(RenderObject::NodeInfo& info, int x, int y) +{ +#ifdef APPLE_CHANGES + // Clear our our scrollbar variable + RenderLayer::gScrollBar = 0; +#endif + + int stx = m_x; + int sty = m_y; + +#ifdef __GNUC__ +#warning HACK +#endif + if (renderer()->isCanvas()) { + stx += static_cast<RenderCanvas*>(renderer())->view()->contentsX(); + sty += static_cast<RenderCanvas*>(renderer())->view()->contentsY(); + } + + TQRect damageRect(stx,sty, width(), height()); + RenderLayer* insideLayer = nodeAtPointForLayer(this, info, x, y, damageRect); + + // Now determine if the result is inside an anchor. + DOM::NodeImpl* node = info.innerNode(); + while (node) { + if (node->hasAnchor() && !info.URLElement()) + info.setURLElement(node); + node = node->parentNode(); + } + + // Next set up the correct :hover/:active state along the new chain. + updateHoverActiveState(info); + + // Now return whether we were inside this layer (this will always be true for the root + // layer). + return insideLayer; +} + +RenderLayer* RenderLayer::nodeAtPointForLayer(RenderLayer* rootLayer, RenderObject::NodeInfo& info, + int xMousePos, int yMousePos, const TQRect& hitTestRect) +{ + // Calculate the clip rects we should use. + TQRect layerBounds, bgRect, fgRect; + calculateRects(rootLayer, hitTestRect, layerBounds, bgRect, fgRect); + + // Ensure our lists are up-to-date. + updateZOrderLists(); + updateOverflowList(); + + // This variable tracks which layer the mouse ends up being inside. The minute we find an insideLayer, + // we are done and can return it. + RenderLayer* insideLayer = 0; + + // Begin by walking our list of positive layers from highest z-index down to the lowest + // z-index. + if (m_posZOrderList) { + uint count = m_posZOrderList->count(); + for (int i = count-1; i >= 0; i--) { + RenderLayer* child = m_posZOrderList->at(i); + insideLayer = child->nodeAtPointForLayer(rootLayer, info, xMousePos, yMousePos, hitTestRect); + if (insideLayer) + return insideLayer; + } + } + + // Now check our overflow objects. + if (m_overflowList) { + TQValueList<RenderLayer*>::iterator it = m_overflowList->end(); + for (--it; it != m_overflowList->end(); --it) { + insideLayer = (*it)->nodeAtPointForLayer(rootLayer, info, xMousePos, yMousePos, hitTestRect); + if (insideLayer) + return insideLayer; + } + } + + // Next we want to see if the mouse pos is inside the child RenderObjects of the layer. + if (containsPoint(xMousePos, yMousePos, fgRect) && + renderer()->nodeAtPoint(info, xMousePos, yMousePos, + layerBounds.x() - renderer()->xPos(), + layerBounds.y() - renderer()->yPos() + m_object->borderTopExtra(), + HitTestChildrenOnly)) { + if (info.innerNode() != m_object->element()) + return this; + } + + // Now check our negative z-index children. + if (m_negZOrderList) { + uint count = m_negZOrderList->count(); + for (int i = count-1; i >= 0; i--) { + RenderLayer* child = m_negZOrderList->at(i); + insideLayer = child->nodeAtPointForLayer(rootLayer, info, xMousePos, yMousePos, hitTestRect); + if (insideLayer) + return insideLayer; + } + } + + // Next we want to see if the mouse pos is inside this layer but not any of its children. + if (containsPoint(xMousePos, yMousePos, bgRect) && + renderer()->nodeAtPoint(info, xMousePos, yMousePos, + layerBounds.x() - renderer()->xPos(), + layerBounds.y() - renderer()->yPos() + m_object->borderTopExtra(), + HitTestSelfOnly)) + return this; + + // No luck. + return 0; +} + +void RenderLayer::calculateClipRects(const RenderLayer* rootLayer, TQRect& overflowClipRect, + TQRect& posClipRect, TQRect& fixedClipRect) +{ + if (parent()) + parent()->calculateClipRects(rootLayer, overflowClipRect, posClipRect, fixedClipRect); + + switch (m_object->style()->position()) { + // A fixed object is essentially the root of its containing block hierarchy, so when + // we encounter such an object, we reset our clip rects to the fixedClipRect. + case FIXED: + posClipRect = fixedClipRect; + overflowClipRect = fixedClipRect; + break; + case ABSOLUTE: + overflowClipRect = posClipRect; + break; + case RELATIVE: + posClipRect = overflowClipRect; + break; + default: + break; + } + + // Update the clip rects that will be passed to child layers. + if (m_object->hasOverflowClip() || m_object->hasClip()) { + // This layer establishes a clip of some kind. + int x = 0; + int y = 0; + convertToLayerCoords(rootLayer, x, y); + + if (m_object->hasOverflowClip()) { + TQRect newOverflowClip = m_object->getOverflowClipRect(x,y); + overflowClipRect = newOverflowClip.intersect(overflowClipRect); + if (m_object->isPositioned() || m_object->isRelPositioned()) + posClipRect = newOverflowClip.intersect(posClipRect); + } + if (m_object->hasClip()) { + TQRect newPosClip = m_object->getClipRect(x,y); + posClipRect = posClipRect.intersect(newPosClip); + overflowClipRect = overflowClipRect.intersect(newPosClip); + fixedClipRect = fixedClipRect.intersect(newPosClip); + } + } +} + +void RenderLayer::calculateRects(const RenderLayer* rootLayer, const TQRect& paintDirtyRect, TQRect& layerBounds, + TQRect& backgroundRect, TQRect& foregroundRect) +{ + TQRect overflowClipRect = paintDirtyRect; + TQRect posClipRect = paintDirtyRect; + TQRect fixedClipRect = paintDirtyRect; + if (parent()) + parent()->calculateClipRects(rootLayer, overflowClipRect, posClipRect, fixedClipRect); + + int x = 0; + int y = 0; + convertToLayerCoords(rootLayer, x, y); + layerBounds = TQRect(x,y,width(),height()); + + backgroundRect = m_object->style()->position() == FIXED ? fixedClipRect : + (m_object->isPositioned() ? posClipRect : overflowClipRect); + foregroundRect = backgroundRect; + + // Update the clip rects that will be passed to child layers. + if (m_object->hasOverflowClip() || m_object->hasClip()) { + // This layer establishes a clip of some kind. + if (m_object->hasOverflowClip()) + foregroundRect = foregroundRect.intersect(m_object->getOverflowClipRect(x,y)); + + if (m_object->hasClip()) { + // Clip applies to *us* as well, so go ahead and update the damageRect. + TQRect newPosClip = m_object->getClipRect(x,y); + backgroundRect = backgroundRect.intersect(newPosClip); + foregroundRect = foregroundRect.intersect(newPosClip); + } + + // If we establish a clip at all, then go ahead and make sure our background + // rect is intersected with our layer's bounds. + backgroundRect = backgroundRect.intersect(layerBounds); + } +} + +bool RenderLayer::intersectsDamageRect(const TQRect& layerBounds, const TQRect& damageRect) const +{ + return (renderer()->isCanvas() || renderer()->isRoot() || renderer()->isBody() || + (renderer()->hasOverhangingFloats() && !renderer()->hasOverflowClip()) || + (renderer()->isInline() && !renderer()->isReplaced()) || + layerBounds.intersects(damageRect)); +} + +bool RenderLayer::containsPoint(int x, int y, const TQRect& damageRect) const +{ + return (renderer()->isCanvas() || renderer()->isRoot() || renderer()->isBody() || + renderer()->hasOverhangingFloats() || + (renderer()->isInline() && !renderer()->isReplaced()) || + damageRect.contains(x, y)); +} + +// This code has been written to anticipate the addition of CSS3-::outside and ::inside generated +// content (and perhaps XBL). That's why it uses the render tree and not the DOM tree. +static RenderObject* hoverAncestor(RenderObject* obj) +{ + return (!obj->isInline() && obj->continuation()) ? obj->continuation() : obj->parent(); +} + +static RenderObject* commonAncestor(RenderObject* obj1, RenderObject* obj2) +{ + if (!obj1 || !obj2) + return 0; + + for (RenderObject* currObj1 = obj1; currObj1; currObj1 = hoverAncestor(currObj1)) + for (RenderObject* currObj2 = obj2; currObj2; currObj2 = hoverAncestor(currObj2)) + if (currObj1 == currObj2) + return currObj1; + + return 0; +} + + +void RenderLayer::updateHoverActiveState(RenderObject::NodeInfo& info) +{ + // We don't update :hover/:active state when the info is marked as readonly. + if (info.readonly()) + return; + + DOM::NodeImpl *e = m_object->element(); + DOM::DocumentImpl *doc = e ? e->getDocument() : 0; + if (!doc) return; + + // Check to see if the hovered node has changed. If not, then we don't need to + // do anything. + DOM::NodeImpl* oldHoverNode = doc->hoverNode(); + DOM::NodeImpl* newHoverNode = info.innerNode(); + + if (oldHoverNode == newHoverNode && (!oldHoverNode || oldHoverNode->active() == info.active())) + return; + + // Update our current hover node. + doc->setHoverNode(newHoverNode); + if (info.active()) + doc->setActiveNode(newHoverNode); + else + doc->setActiveNode(0); + + // We have two different objects. Fetch their renderers. + RenderObject* oldHoverObj = oldHoverNode ? oldHoverNode->renderer() : 0; + RenderObject* newHoverObj = newHoverNode ? newHoverNode->renderer() : 0; + + // Locate the common ancestor render object for the two renderers. + RenderObject* ancestor = commonAncestor(oldHoverObj, newHoverObj); + + // The old hover path only needs to be cleared up to (and not including) the common ancestor; + for (RenderObject* curr = oldHoverObj; curr && curr != ancestor; curr = hoverAncestor(curr)) { + curr->setMouseInside(false); + if (curr->element()) { + curr->element()->setActive(false); + curr->element()->setHovered(false); + } + } + + // Now set the hover state for our new object up to the root. + for (RenderObject* curr = newHoverObj; curr; curr = hoverAncestor(curr)) { + curr->setMouseInside(true); + if (curr->element()) { + curr->element()->setActive(info.active()); + curr->element()->setHovered(true); + } + } +} + +// Sort the buffer from lowest z-index to highest. The common scenario will have +// most z-indices equal, so we optimize for that case (i.e., the list will be mostly +// sorted already). +static void sortByZOrder(TQPtrVector<RenderLayer>* buffer, + TQPtrVector<RenderLayer>* mergeBuffer, + uint start, uint end) +{ + if (start >= end) + return; // Sanity check. + + if (end - start <= 6) { + // Apply a bubble sort for smaller lists. + for (uint i = end-1; i > start; i--) { + bool sorted = true; + for (uint j = start; j < i; j++) { + RenderLayer* elt = buffer->at(j); + RenderLayer* elt2 = buffer->at(j+1); + if (elt->zIndex() > elt2->zIndex()) { + sorted = false; + buffer->insert(j, elt2); + buffer->insert(j+1, elt); + } + } + if (sorted) + return; + } + } + else { + // Peform a merge sort for larger lists. + uint mid = (start+end)/2; + sortByZOrder(buffer, mergeBuffer, start, mid); + sortByZOrder(buffer, mergeBuffer, mid, end); + + RenderLayer* elt = buffer->at(mid-1); + RenderLayer* elt2 = buffer->at(mid); + + // Handle the fast common case (of equal z-indices). The list may already + // be completely sorted. + if (elt->zIndex() <= elt2->zIndex()) + return; + + // We have to merge sort. Ensure our merge buffer is big enough to hold + // all the items. + mergeBuffer->resize(end - start); + uint i1 = start; + uint i2 = mid; + + elt = buffer->at(i1); + elt2 = buffer->at(i2); + + while (i1 < mid || i2 < end) { + if (i1 < mid && (i2 == end || elt->zIndex() <= elt2->zIndex())) { + mergeBuffer->insert(mergeBuffer->count(), elt); + i1++; + if (i1 < mid) + elt = buffer->at(i1); + } + else { + mergeBuffer->insert(mergeBuffer->count(), elt2); + i2++; + if (i2 < end) + elt2 = buffer->at(i2); + } + } + + for (uint i = start; i < end; i++) + buffer->insert(i, mergeBuffer->at(i-start)); + + mergeBuffer->clear(); + } +} + +void RenderLayer::dirtyZOrderLists() +{ + if (m_posZOrderList) + m_posZOrderList->clear(); + if (m_negZOrderList) + m_negZOrderList->clear(); + m_zOrderListsDirty = true; +} + +void RenderLayer::dirtyOverflowList() +{ + if (m_overflowList) + m_overflowList->clear(); + m_overflowListDirty = true; +} + +void RenderLayer::updateZOrderLists() +{ + if (!isStackingContext() || !m_zOrderListsDirty) + return; + + for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) + child->collectLayers(m_posZOrderList, m_negZOrderList); + + // Sort the two lists. + if (m_posZOrderList) { + TQPtrVector<RenderLayer> mergeBuffer; + sortByZOrder(m_posZOrderList, &mergeBuffer, 0, m_posZOrderList->count()); + } + if (m_negZOrderList) { + TQPtrVector<RenderLayer> mergeBuffer; + sortByZOrder(m_negZOrderList, &mergeBuffer, 0, m_negZOrderList->count()); + } + + m_zOrderListsDirty = false; +} + +void RenderLayer::updateOverflowList() +{ + if (!m_overflowListDirty) + return; + + for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) { + if (child->isOverflowOnly()) { + if (!m_overflowList) + m_overflowList = new TQValueList<RenderLayer*>; + m_overflowList->append(child); + } + } + + m_overflowListDirty = false; +} + +void RenderLayer::collectLayers(TQPtrVector<RenderLayer>*& posBuffer, TQPtrVector<RenderLayer>*& negBuffer) +{ + // FIXME: A child render object or layer could override visibility. Don't remove this + // optimization though until RenderObject's nodeAtPoint is patched to understand what to do + // when visibility is overridden by a child. + if (renderer()->style()->visibility() != VISIBLE) + return; + + // Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists. + if (!isOverflowOnly()) { + + // Determine which buffer the child should be in. + TQPtrVector<RenderLayer>*& buffer = (zIndex() >= 0) ? posBuffer : negBuffer; + + // Create the buffer if it doesn't exist yet. + if (!buffer) + buffer = new TQPtrVector<RenderLayer>(); + + // Resize by a power of 2 when our buffer fills up. + if (buffer->count() == buffer->size()) + buffer->resize(2*(buffer->size()+1)); + + // Append ourselves at the end of the appropriate buffer. + buffer->insert(buffer->count(), this); + } + + // Recur into our children to collect more layers, but only if we don't establish + // a stacking context. + if (!isStackingContext()) { + for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) + child->collectLayers(posBuffer, negBuffer); + } +} + +#ifdef ENABLE_DUMP +#ifndef KDE_USE_FINAL +static TQTextStream &operator<<(TQTextStream &ts, const TQRect &r) +{ + return ts << "at (" << r.x() << "," << r.y() << ") size " << r.width() << "x" << r.height(); +} +#endif + +static void write(TQTextStream &ts, RenderObject& o, const TQString& indent ) +{ + o.dump(ts, indent); + + for (RenderObject *child = o.firstChild(); child; child = child->nextSibling()) { + if (child->layer()) continue; + write( ts, *child, indent + " " ); + } +} + +static void write(TQTextStream &ts, const RenderLayer &l, + const TQRect& layerBounds, const TQRect& backgroundClipRect, const TQRect& clipRect, + int layerType = 0, const TQString& indent = TQString::null) + +{ + ts << indent << "layer"; + + ts << " at (" << l.xPos() << "," << l.yPos() << ") size " << l.width() << "x" << l.height(); + + if (layerBounds != layerBounds.intersect(backgroundClipRect)) { + ts << " backgroundClip " << backgroundClipRect; + } + if (layerBounds != layerBounds.intersect(clipRect)) { + ts << " clip " << clipRect; + } + + if (layerType == -1) + ts << " layerType: background only"; + else if (layerType == 1) + ts << " layerType: foreground only"; + + ts << "\n"; + + if (layerType != -1) + write( ts, *l.renderer(), indent + " " ); + + ts << "\n"; +} + +static void writeLayers(TQTextStream &ts, const RenderLayer* rootLayer, RenderLayer* l, + const TQRect& paintDirtyRect, const TQString& indent) +{ + // Calculate the clip rects we should use. + TQRect layerBounds, damageRect, clipRectToApply; + l->calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply); + + // Ensure our lists are up-to-date. + l->updateZOrderLists(); + l->updateOverflowList(); + + bool shouldPaint = l->intersectsDamageRect(layerBounds, damageRect); + TQPtrVector<RenderLayer>* negList = l->negZOrderList(); + TQValueList<RenderLayer*>* ovfList = l->overflowList(); + if (shouldPaint && negList && negList->count() > 0) + write(ts, *l, layerBounds, damageRect, clipRectToApply, -1, indent); + + if (negList) { + for (unsigned i = 0; i != negList->count(); ++i) + writeLayers(ts, rootLayer, negList->at(i), paintDirtyRect, indent ); + } + + if (shouldPaint) + write(ts, *l, layerBounds, damageRect, clipRectToApply, negList && negList->count() > 0, indent); + + if (ovfList) { + for (TQValueList<RenderLayer*>::iterator it = ovfList->begin(); it != ovfList->end(); ++it) + writeLayers(ts, rootLayer, *it, paintDirtyRect, indent); + } + + TQPtrVector<RenderLayer>* posList = l->posZOrderList(); + if (posList) { + for (unsigned i = 0; i != posList->count(); ++i) + writeLayers(ts, rootLayer, posList->at(i), paintDirtyRect, indent); + } +} + + +void RenderLayer::dump(TQTextStream &ts, const TQString &ind) +{ + assert( renderer()->isCanvas() ); + + writeLayers(ts, this, this, TQRect(xPos(), yPos(), width(), height()), ind); +} + + +#endif + +bool RenderLayer::shouldBeOverflowOnly() const +{ + return renderer()->style() && renderer()->hasOverflowClip() && + !renderer()->isPositioned() && !renderer()->isRelPositioned(); + /* && !isTransparent(); */ +} + +void RenderLayer::styleChanged() +{ + bool isOverflowOnly = shouldBeOverflowOnly(); + if (isOverflowOnly != m_isOverflowOnly) { + m_isOverflowOnly = isOverflowOnly; + RenderLayer* p = parent(); + RenderLayer* sc = stackingContext(); + if (p) + p->dirtyOverflowList(); + if (sc) + sc->dirtyZOrderLists(); + } + + if (m_object->hasOverflowClip() && + m_object->style()->overflowX() == OMARQUEE && m_object->style()->marqueeBehavior() != MNONE) { + if (!m_marquee) + m_marquee = new Marquee(this); + m_marquee->updateMarqueeStyle(); + } + else if (m_marquee) { + delete m_marquee; + m_marquee = 0; + } +} + +void RenderLayer::suspendMarquees() +{ + if (m_marquee) + m_marquee->suspend(); + + for (RenderLayer* curr = firstChild(); curr; curr = curr->nextSibling()) + curr->suspendMarquees(); +} + +// -------------------------------------------------------------------------- +// Marquee implementation + +Marquee::Marquee(RenderLayer* l) +:m_layer(l), m_currentLoop(0), m_totalLoops(0), m_timerId(0), m_start(0), m_end(0), m_speed(0), m_unfurlPos(0), m_reset(false), + m_suspended(false), m_stopped(false), m_whiteSpace(NORMAL), m_direction(MAUTO) +{ +} + +int Marquee::marqueeSpeed() const +{ + int result = m_layer->renderer()->style()->marqueeSpeed(); + DOM::NodeImpl* elt = m_layer->renderer()->element(); + if (elt && elt->id() == ID_MARQUEE) { + HTMLMarqueeElementImpl* marqueeElt = static_cast<HTMLMarqueeElementImpl*>(elt); + result = kMax(result, marqueeElt->minimumDelay()); + } + return result; +} + +EMarqueeDirection Marquee::direction() const +{ + // FIXME: Support the CSS3 "auto" value for determining the direction of the marquee. + // For now just map MAUTO to MBACKWARD + EMarqueeDirection result = m_layer->renderer()->style()->marqueeDirection(); + EDirection dir = m_layer->renderer()->style()->direction(); + if (result == MAUTO) + result = MBACKWARD; + if (result == MFORWARD) + result = (dir == LTR) ? MRIGHT : MLEFT; + if (result == MBACKWARD) + result = (dir == LTR) ? MLEFT : MRIGHT; + + // Now we have the real direction. Next we check to see if the increment is negative. + // If so, then we reverse the direction. + Length increment = m_layer->renderer()->style()->marqueeIncrement(); + if (increment.value() < 0) + result = static_cast<EMarqueeDirection>(-result); + + return result; +} + +bool Marquee::isHorizontal() const +{ + return direction() == MLEFT || direction() == MRIGHT; +} + +bool Marquee::isUnfurlMarquee() const +{ + EMarqueeBehavior behavior = m_layer->renderer()->style()->marqueeBehavior(); + return (behavior == MUNFURL); +} + +int Marquee::computePosition(EMarqueeDirection dir, bool stopAtContentEdge) +{ + RenderObject* o = m_layer->renderer(); + RenderStyle* s = o->style(); + if (isHorizontal()) { + bool ltr = s->direction() == LTR; + int clientWidth = o->clientWidth(); + int contentWidth = ltr ? o->rightmostPosition(true, false) : o->leftmostPosition(true, false); + if (ltr) + contentWidth += (o->paddingRight() - o->borderLeft()); + else { + contentWidth = o->width() - contentWidth; + contentWidth += (o->paddingLeft() - o->borderRight()); + } + if (dir == MRIGHT) { + if (stopAtContentEdge) + return kMax(0, ltr ? (contentWidth - clientWidth) : (clientWidth - contentWidth)); + else + return ltr ? contentWidth : clientWidth; + } + else { + if (stopAtContentEdge) + return kMin(0, ltr ? (contentWidth - clientWidth) : (clientWidth - contentWidth)); + else + return ltr ? -clientWidth : -contentWidth; + } + } + else { + int contentHeight = m_layer->renderer()->lowestPosition(true, false) - + m_layer->renderer()->borderTop() + m_layer->renderer()->paddingBottom(); + int clientHeight = m_layer->renderer()->clientHeight(); + if (dir == MUP) { + if (stopAtContentEdge) + return kMin(contentHeight - clientHeight, 0); + else + return -clientHeight; + } + else { + if (stopAtContentEdge) + return kMax(contentHeight - clientHeight, 0); + else + return contentHeight; + } + } +} + +void Marquee::start() +{ + if (m_timerId || m_layer->renderer()->style()->marqueeIncrement().value() == 0) + return; + + if (!m_suspended && !m_stopped) { + if (isUnfurlMarquee()) { + bool forward = direction() == MDOWN || direction() == MRIGHT; + bool isReversed = (forward && m_currentLoop % 2) || (!forward && !(m_currentLoop % 2)); + m_unfurlPos = isReversed ? m_end : m_start; + m_layer->renderer()->setChildNeedsLayout(true); + } + else { + if (isHorizontal()) + m_layer->scrollToOffset(m_start, 0, false, false); + else + m_layer->scrollToOffset(0, m_start, false, false); + } + } + else + m_suspended = false; + + m_stopped = false; + m_timerId = startTimer(speed()); +} + +void Marquee::suspend() +{ + if (m_timerId) { + killTimer(m_timerId); + m_timerId = 0; + } + + m_suspended = true; +} + +void Marquee::stop() +{ + if (m_timerId) { + killTimer(m_timerId); + m_timerId = 0; + } + + m_stopped = true; +} + +void Marquee::updateMarqueePosition() +{ + bool activate = (m_totalLoops <= 0 || m_currentLoop < m_totalLoops); + if (activate) { + if (isUnfurlMarquee()) { + if (m_unfurlPos < m_start) { + m_unfurlPos = m_start; + m_layer->renderer()->setChildNeedsLayout(true); + } + else if (m_unfurlPos > m_end) { + m_unfurlPos = m_end; + m_layer->renderer()->setChildNeedsLayout(true); + } + } + else { + EMarqueeBehavior behavior = m_layer->renderer()->style()->marqueeBehavior(); + m_start = computePosition(direction(), behavior == MALTERNATE); + m_end = computePosition(reverseDirection(), behavior == MALTERNATE || behavior == MSLIDE); + } + if (!m_stopped) start(); + } +} + +void Marquee::updateMarqueeStyle() +{ + RenderStyle* s = m_layer->renderer()->style(); + + if (m_direction != s->marqueeDirection() || (m_totalLoops != s->marqueeLoopCount() && m_currentLoop >= m_totalLoops)) + m_currentLoop = 0; // When direction changes or our loopCount is a smaller number than our current loop, reset our loop. + + m_totalLoops = s->marqueeLoopCount(); + m_direction = s->marqueeDirection(); + m_whiteSpace = s->whiteSpace(); + + if (m_layer->renderer()->isHTMLMarquee()) { + // Hack for WinIE. In WinIE, a value of 0 or lower for the loop count for SLIDE means to only do + // one loop. + if (m_totalLoops <= 0 && (s->marqueeBehavior() == MSLIDE || s->marqueeBehavior() == MUNFURL)) + m_totalLoops = 1; + + // Hack alert: Set the white-space value to nowrap for horizontal marquees with inline children, thus ensuring + // all the text ends up on one line by default. Limit this hack to the <marquee> element to emulate + // WinIE's behavior. Someone using CSS3 can use white-space: nowrap on their own to get this effect. + // Second hack alert: Set the text-align back to auto. WinIE completely ignores text-align on the + // marquee element. + // FIXME: Bring these up with the CSS WG. + if (isHorizontal() && m_layer->renderer()->childrenInline()) { + s->setWhiteSpace(NOWRAP); + s->setTextAlign(TAAUTO); + } + } + + if (speed() != marqueeSpeed()) { + m_speed = marqueeSpeed(); + if (m_timerId) { + killTimer(m_timerId); + m_timerId = startTimer(speed()); + } + } + + // Check the loop count to see if we should now stop. + bool activate = (m_totalLoops <= 0 || m_currentLoop < m_totalLoops); + if (activate && !m_timerId) + m_layer->renderer()->setNeedsLayout(true); + else if (!activate && m_timerId) { + // Destroy the timer. + killTimer(m_timerId); + m_timerId = 0; + } +} + +void Marquee::timerEvent(TQTimerEvent* /*evt*/) +{ + if (m_layer->renderer()->needsLayout()) + return; + + if (m_reset) { + m_reset = false; + if (isHorizontal()) + m_layer->scrollToXOffset(m_start); + else + m_layer->scrollToYOffset(m_start); + return; + } + + RenderStyle* s = m_layer->renderer()->style(); + + int endPoint = m_end; + int range = m_end - m_start; + int newPos; + if (range == 0) + newPos = m_end; + else { + bool addIncrement = direction() == MUP || direction() == MLEFT; + bool isReversed = s->marqueeBehavior() == MALTERNATE && m_currentLoop % 2; + if (isUnfurlMarquee()) { + isReversed = (!addIncrement && m_currentLoop % 2) || (addIncrement && !(m_currentLoop % 2)); + addIncrement = !isReversed; + } + if (isReversed) { + // We're going in the reverse direction. + endPoint = m_start; + range = -range; + if (!isUnfurlMarquee()) + addIncrement = !addIncrement; + } + bool positive = range > 0; + int clientSize = isUnfurlMarquee() ? abs(range) : + (isHorizontal() ? m_layer->renderer()->clientWidth() : m_layer->renderer()->clientHeight()); + int increment = kMax(1, abs(m_layer->renderer()->style()->marqueeIncrement().width(clientSize))); + int currentPos = isUnfurlMarquee() ? m_unfurlPos : + (isHorizontal() ? m_layer->scrollXOffset() : m_layer->scrollYOffset()); + newPos = currentPos + (addIncrement ? increment : -increment); + if (positive) + newPos = kMin(newPos, endPoint); + else + newPos = kMax(newPos, endPoint); + } + + if (newPos == endPoint) { + m_currentLoop++; + if (m_totalLoops > 0 && m_currentLoop >= m_totalLoops) { + killTimer(m_timerId); + m_timerId = 0; + } + else if (s->marqueeBehavior() != MALTERNATE && s->marqueeBehavior() != MUNFURL) + m_reset = true; + } + + if (isUnfurlMarquee()) { + m_unfurlPos = newPos; + m_layer->renderer()->setChildNeedsLayout(true); + } + else { + if (isHorizontal()) + m_layer->scrollToXOffset(newPos); + else + m_layer->scrollToYOffset(newPos); + } +} + +#include "render_layer.moc" diff --git a/tdehtml/rendering/render_layer.h b/tdehtml/rendering/render_layer.h new file mode 100644 index 000000000..ae5ddff65 --- /dev/null +++ b/tdehtml/rendering/render_layer.h @@ -0,0 +1,342 @@ +/* + * Copyright (C) 2003 Apple Computer, Inc. + * + * Portions are Copyright (C) 1998 Netscape Communications Corporation. + * + * Other contributors: + * Robert O'Callahan <roc+@cs.cmu.edu> + * David Baron <dbaron@fas.harvard.edu> + * Christian Biesinger <cbiesinger@web.de> + * Randall Jesup <rjesup@wgate.com> + * Roland Mainz <roland.mainz@informatik.med.uni-giessen.de> + * Josh Soref <timeless@mac.com> + * Boris Zbarsky <bzbarsky@mit.edu> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Alternatively, the contents of this file may be used under the terms + * of either the Mozilla Public License Version 1.1, found at + * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public + * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html + * (the "GPL"), in which case the provisions of the MPL or the GPL are + * applicable instead of those above. If you wish to allow use of your + * version of this file only under the terms of one of those two + * licenses (the MPL or the GPL) and not to allow others to use your + * version of this file under the LGPL, indicate your decision by + * deletingthe provisions above and replace them with the notice and + * other provisions required by the MPL or the GPL, as the case may be. + * If you do not delete the provisions above, a recipient may use your + * version of this file under any of the LGPL, the MPL or the GPL. + */ + +#ifndef render_layer_h +#define render_layer_h + +#include <tqcolor.h> +#include <tqrect.h> +#include <assert.h> + +#include "render_object.h" + +class TQScrollBar; +template <class T> class TQPtrVector; + +namespace tdehtml { + class RenderStyle; + class RenderTable; + class CachedObject; + class RenderCanvas; + class RenderText; + class RenderFrameSet; + class RenderObject; + class RenderScrollMediator; + +class RenderScrollMediator: public TQObject +{ + Q_OBJECT +public: + RenderScrollMediator(RenderLayer* layer) + :m_layer(layer) {} + +public slots: + void slotValueChanged(); + +private: + RenderLayer* m_layer; +}; + +// This class handles the auto-scrolling of layers with overflow: marquee. +class Marquee: public TQObject +{ + Q_OBJECT + +public: + Marquee(RenderLayer* l); + + void timerEvent(TQTimerEvent*); + + int speed() const { return m_speed; } + int marqueeSpeed() const; + EMarqueeDirection direction() const; + EMarqueeDirection reverseDirection() const { return static_cast<EMarqueeDirection>(-direction()); } + bool isHorizontal() const; + bool isUnfurlMarquee() const; + int unfurlPos() const { return m_unfurlPos; } + + EWhiteSpace whiteSpace() { return m_whiteSpace; } + + int computePosition(EMarqueeDirection dir, bool stopAtClientEdge); + + void setEnd(int end) { m_end = end; } + + void start(); + void suspend(); + void stop(); + + void updateMarqueeStyle(); + void updateMarqueePosition(); + +private: + RenderLayer* m_layer; + int m_currentLoop; + int m_totalLoops; + int m_timerId; + int m_start; + int m_end; + int m_speed; + int m_unfurlPos; + bool m_reset:1; + bool m_suspended:1; + bool m_stopped:1; + EWhiteSpace m_whiteSpace : 3; + EMarqueeDirection m_direction : 4; +}; + +class RenderLayer +{ +public: +#ifdef APPLE_CHANGES + static TQScrollBar* gScrollBar; +#endif + + RenderLayer(RenderObject* object); + ~RenderLayer(); + + RenderObject* renderer() const { return m_object; } + RenderLayer *parent() const { return m_parent; } + RenderLayer *previousSibling() const { return m_previous; } + RenderLayer *nextSibling() const { return m_next; } + + RenderLayer *firstChild() const { return m_first; } + RenderLayer *lastChild() const { return m_last; } + + void addChild(RenderLayer *newChild, RenderLayer* beforeChild = 0); + RenderLayer* removeChild(RenderLayer *oldChild); + + void removeOnlyThisLayer(); + void insertOnlyThisLayer(); + + void styleChanged(); + + Marquee* marquee() const { return m_marquee; } + void suspendMarquees(); + + bool isOverflowOnly() const { return m_isOverflowOnly; } + +#ifdef APPLE_CHANGES + bool isTransparent(); + RenderLayer* transparentAncestor(); +#endif + + RenderLayer* root() { + RenderLayer* curr = this; + while (curr->parent()) curr = curr->parent(); + return curr; + } + + int xPos() const { return m_x; } + int yPos() const { return m_y; } + + short width() const; + int height() const; + + short scrollWidth() const { return m_scrollWidth; } + int scrollHeight() const { return m_scrollHeight; } + + void resize( int w, int h ) { + m_scrollWidth = w; m_scrollHeight = h; + } + + void setPos( int xPos, int yPos ) { + m_x = xPos; + m_y = yPos; + } + + // Scrolling methods for layers that can scroll their overflow. + void scrollOffset(int& x, int& y); + void subtractScrollOffset(int& x, int& y); + void checkInlineRelOffset(const RenderObject* o, int& x, int& y); + short scrollXOffset() { return m_scrollX; } + int scrollYOffset() { return m_scrollY; } + void scrollToOffset(int x, int y, bool updateScrollbars = true, bool repaint = true); + void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY); } + void scrollToYOffset(int y) { scrollToOffset(m_scrollX, y); } + void showScrollbar(Qt::Orientation, bool); + TQScrollBar* horizontalScrollbar() { return m_hBar; } + TQScrollBar* verticalScrollbar() { return m_vBar; } + int verticalScrollbarWidth(); + int horizontalScrollbarHeight(); + void positionScrollbars(const TQRect &damageRect); + void paintScrollbars(RenderObject::PaintInfo& pI); + void checkScrollbarsAfterLayout(); + void slotValueChanged(int); + void repaint(Priority p=NormalPriority, bool markForRepaint = false); + void updateScrollPositionFromScrollbars(); + + void updateLayerPosition(); + void updateLayerPositions( RenderLayer* rootLayer, bool doFullRepaint = false, bool checkForRepaint = false); + + // Get the enclosing stacking context for this layer. A stacking context is a layer + // that has a non-auto z-index. + RenderLayer* stackingContext() const; + bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isCanvas(); } + + void dirtyZOrderLists(); + void updateZOrderLists(); + TQPtrVector<RenderLayer>* posZOrderList() const { return m_posZOrderList; } + TQPtrVector<RenderLayer>* negZOrderList() const { return m_negZOrderList; } + + void dirtyOverflowList(); + void updateOverflowList(); + TQValueList<RenderLayer*>* overflowList() const { return m_overflowList; } + + void setHasOverlaidWidgets(bool b=true) { m_hasOverlaidWidgets = b; } + bool hasOverlaidWidgets() const { return m_hasOverlaidWidgets; } + TQRegion getMask() const { return m_region; } + TQRegion paintedRegion(RenderLayer* rootLayer); + void updateWidgetMasks(RenderLayer* rootLayer); + + // Gets the nearest enclosing positioned ancestor layer (also includes + // the <html> layer and the root layer). + RenderLayer* enclosingPositionedAncestor() const; + + void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const; + + bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); } + int zIndex() const { return renderer()->style()->zIndex(); } + + // The two main functions that use the layer system. The paint method + // paints the layers that intersect the damage rect from back to + // front. The nodeAtPoint method looks for mouse events by walking + // layers that intersect the point from front to back. + KDE_EXPORT void paint(TQPainter *p, const TQRect& damageRect, bool selectionOnly=false); + bool nodeAtPoint(RenderObject::NodeInfo& info, int x, int y); + + // This method figures out our layerBounds in coordinates relative to + // |rootLayer}. It also computes our background and foreground clip rects + // for painting/event handling. + void calculateRects(const RenderLayer* rootLayer, const TQRect& paintDirtyRect, TQRect& layerBounds, + TQRect& backgroundRect, TQRect& foregroundRect); + void calculateClipRects(const RenderLayer* rootLayer, TQRect& overflowClipRect, + TQRect& posClipRect, TQRect& fixedClipRect); + + bool intersectsDamageRect(const TQRect& layerBounds, const TQRect& damageRect) const; + bool containsPoint(int x, int y, const TQRect& damageRect) const; + + void updateHoverActiveState(RenderObject::NodeInfo& info); + + void detach(RenderArena* renderArena); + +#ifdef ENABLE_DUMP + KDE_EXPORT void dump(TQTextStream &stream, const TQString &ind = TQString::null); +#endif + + // Overloaded new operator. Derived classes must override operator new + // in order to allocate out of the RenderArena. + void* operator new(size_t sz, RenderArena* renderArena) throw(); + + // Overridden to prevent the normal delete from being called. + void operator delete(void* ptr, size_t sz); + +private: + // The normal operator new is disallowed on all render objects. + void* operator new(size_t sz) throw(); + +private: + void setNextSibling(RenderLayer* next) { m_next = next; } + void setPreviousSibling(RenderLayer* prev) { m_previous = prev; } + void setParent(RenderLayer* parent) { m_parent = parent; } + void setFirstChild(RenderLayer* first) { m_first = first; } + void setLastChild(RenderLayer* last) { m_last = last; } + + void collectLayers(TQPtrVector<RenderLayer>*&, TQPtrVector<RenderLayer>*&); + + KDE_EXPORT void paintLayer(RenderLayer* rootLayer, TQPainter *p, const TQRect& paintDirtyRect, bool selectionOnly=false); + RenderLayer* nodeAtPointForLayer(RenderLayer* rootLayer, RenderObject::NodeInfo& info, + int x, int y, const TQRect& hitTestRect); + bool shouldBeOverflowOnly() const; + +protected: + RenderObject* m_object; + + RenderLayer* m_parent; + RenderLayer* m_previous; + RenderLayer* m_next; + + RenderLayer* m_first; + RenderLayer* m_last; + + // Our (x,y) coordinates are in our parent layer's coordinate space. + short m_x; + int m_y; + + // Our scroll offsets if the view is scrolled. + short m_scrollX; + int m_scrollY; + + // The width/height of our scrolled area. + short m_scrollWidth; + int m_scrollHeight; + + // For layers with overflow, we have a pair of scrollbars. + TQScrollBar* m_hBar; + TQScrollBar* m_vBar; + RenderScrollMediator* m_scrollMediator; + + // For layers that establish stacking contexts, m_posZOrderList holds a sorted list of all the + // descendant layers within the stacking context that have z-indices of 0 or greater + // (auto will count as 0). m_negZOrderList holds descendants within our stacking context with negative + // z-indices. + TQPtrVector<RenderLayer>* m_posZOrderList; + TQPtrVector<RenderLayer>* m_negZOrderList; + + // This list contains our overflow child layers. + TQValueList<RenderLayer*>* m_overflowList; + + bool m_zOrderListsDirty: 1; + bool m_overflowListDirty: 1; + bool m_isOverflowOnly: 1; + bool m_markedForRepaint: 1; + bool m_hasOverlaidWidgets: 1; + + TQRect m_visibleRect; + + TQRegion m_region; // used by overlaid (non z-order aware) widgets + + Marquee* m_marquee; // Used by layers with overflow:marquee +}; + +} // namespace +#endif diff --git a/tdehtml/rendering/render_line.cpp b/tdehtml/rendering/render_line.cpp new file mode 100644 index 000000000..b518d3a43 --- /dev/null +++ b/tdehtml/rendering/render_line.cpp @@ -0,0 +1,996 @@ +/** +* This file is part of the html renderer for KDE. + * + * Copyright (C) 2003-2006 Apple Computer, Inc. + * (C) 2006 Germain Garand (germain@ebooksfrance.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ +// ------------------------------------------------------------------------- + +#include <kdebug.h> +#include <assert.h> +#include <tqpainter.h> +#include <kglobal.h> + +#include "rendering/render_flow.h" +#include "rendering/render_text.h" +#include "rendering/render_table.h" +#include "rendering/render_inline.h" +#include "rendering/render_block.h" +#include "rendering/render_arena.h" +#include "rendering/render_line.h" +#include "xml/dom_nodeimpl.h" +#include "xml/dom_docimpl.h" +#include "html/html_formimpl.h" +#include "misc/htmltags.h" +#include "tdehtmlview.h" + +using namespace DOM; +using namespace tdehtml; + +#ifndef NDEBUG +static bool inInlineBoxDetach; +#endif + +class tdehtml::EllipsisBox : public InlineBox +{ +public: + EllipsisBox(RenderObject* obj, const DOM::DOMString& ellipsisStr, InlineFlowBox* p, + int w, int y, int h, int b, bool firstLine, InlineBox* markupBox) + :InlineBox(obj), m_str(ellipsisStr) { + m_parent = p; + m_width = w; + m_y = y; + m_height = h; + m_baseline = b; + m_firstLine = firstLine; + m_constructed = true; + m_markupBox = markupBox; + } + + void paint(RenderObject::PaintInfo& i, int _tx, int _ty); + bool nodeAtPoint(RenderObject::NodeInfo& info, int _x, int _y, int _tx, int _ty); + +private: + DOM::DOMString m_str; + InlineBox* m_markupBox; +}; + +void InlineBox::detach(RenderArena* renderArena) +{ + if (m_parent) + m_parent->removeFromLine(this); +#ifndef NDEBUG + inInlineBoxDetach = true; +#endif + delete this; +#ifndef NDEBUG + inInlineBoxDetach = false; +#endif + + // Recover the size left there for us by operator delete and free the memory. + renderArena->free(*(size_t *)this, this); +} + +void* InlineBox::operator new(size_t sz, RenderArena* renderArena) throw() +{ + return renderArena->allocate(sz); +} + +void InlineBox::operator delete(void* ptr, size_t sz) +{ + assert(inInlineBoxDetach); + + // Stash size where detach can find it. + *(size_t *)ptr = sz; +} + +static bool needsOutlinePhaseRepaint(RenderObject* o, RenderObject::PaintInfo& i, int tx, int ty) { + if (o->style()->outlineWidth() <= 0) + return false; + TQRect r(tx+o->xPos(),ty+o->yPos(),o->width(),o->height()); + if (r.intersects(i.r)) + return false; + r.addCoords(-o->style()->outlineSize(), + -o->style()->outlineSize(), + o->style()->outlineSize(), + o->style()->outlineSize()); + if (!r.intersects(i.r)) + return false; + return true; +} + +void InlineBox::paint(RenderObject::PaintInfo& i, int tx, int ty) +{ + if ( i.phase == PaintActionOutline && !needsOutlinePhaseRepaint(object(), i, tx, ty) ) + return; + + // Paint all phases of replaced elements atomically, as though the replaced element established its + // own stacking context. (See Appendix E.2, section 6.4 on inline block/table elements in the CSS2.1 + // specification.) + bool paintSelectionOnly = i.phase == PaintActionSelection; + RenderObject::PaintInfo info(i.p, i.r, paintSelectionOnly ? i.phase : PaintActionElementBackground); + object()->paint(info, tx, ty); + if (!paintSelectionOnly) { + info.phase = PaintActionChildBackgrounds; + object()->paint(info, tx, ty); + info.phase = PaintActionFloat; + object()->paint(info, tx, ty); + info.phase = PaintActionForeground; + object()->paint(info, tx, ty); + info.phase = PaintActionOutline; + object()->paint(info, tx, ty); + } +} + +bool InlineBox::nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty) +{ + // Hit test all phases of replaced elements atomically, as though the replaced element established its + // own stacking context. (See Appendix E.2, section 6.4 on inline block/table elements in the CSS2.1 + // specification.) + bool inside = false; + return object()->nodeAtPoint(i, x, y, tx, ty, HitTestAll, inside); // ### port hitTest +} + +RootInlineBox* InlineBox::root() +{ + if (m_parent) + return m_parent->root(); + return static_cast<RootInlineBox*>(this); +} + +InlineFlowBox::~InlineFlowBox() +{ + /* If we're destroyed, set the children free, and break their links */ + while (m_firstChild) + removeFromLine(m_firstChild); +} + +void InlineFlowBox::removeFromLine(InlineBox *child) +{ + if (child == m_firstChild) { + m_firstChild = child->nextOnLine(); + } + if (child == m_lastChild) { + m_lastChild = child->prevOnLine(); + } + if (child->nextOnLine()) { + child->nextOnLine()->m_prev = child->prevOnLine(); + } + if (child->prevOnLine()) { + child->prevOnLine()->m_next = child->nextOnLine(); + } + + child->setParent(0); +} + +bool InlineBox::canAccommodateEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth) +{ + // Non-replaced elements can always accommodate an ellipsis. + if (!m_object || !m_object->isReplaced()) + return true; + + TQRect boxRect(m_x, 0, m_width, 10); + TQRect ellipsisRect(ltr ? blockEdge - ellipsisWidth : blockEdge, 0, ellipsisWidth, 10); + return !(boxRect.intersects(ellipsisRect)); +} + +int InlineBox::placeEllipsisBox(bool /*ltr*/, int /*blockEdge*/, int /*ellipsisWidth*/, bool&) +{ + // Use -1 to mean "we didn't set the position." + return -1; +} + +int InlineFlowBox::marginLeft() const +{ + if (!includeLeftEdge()) + return 0; + + RenderStyle* cstyle = object()->style(); + Length margin = cstyle->marginLeft(); + if (!margin.isVariable()) + return (margin.isFixed() ? margin.value() : object()->marginLeft()); + return 0; +} + +int InlineFlowBox::marginRight() const +{ + if (!includeRightEdge()) + return 0; + + RenderStyle* cstyle = object()->style(); + Length margin = cstyle->marginRight(); + if (!margin.isVariable()) + return (margin.isFixed() ? margin.value() : object()->marginRight()); + return 0; +} + +int InlineFlowBox::marginBorderPaddingLeft() const +{ + return marginLeft() + borderLeft() + paddingLeft(); +} + +int InlineFlowBox::marginBorderPaddingRight() const +{ + return marginRight() + borderRight() + paddingRight(); +} + +int InlineFlowBox::getFlowSpacingWidth() const +{ + int totWidth = marginBorderPaddingLeft() + marginBorderPaddingRight(); + for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) { + if (curr->isInlineFlowBox()) + totWidth += static_cast<InlineFlowBox*>(curr)->getFlowSpacingWidth(); + } + return totWidth; +} + +bool InlineFlowBox::nextOnLineExists() +{ + if (!parent()) + return false; + + if (nextOnLine()) + return true; + + return parent()->nextOnLineExists(); +} + +bool InlineFlowBox::prevOnLineExists() +{ + if (!parent()) + return false; + + if (prevOnLine()) + return true; + + return parent()->prevOnLineExists(); +} + +bool InlineFlowBox::onEndChain(RenderObject* endObject) +{ + if (!endObject) + return false; + + if (endObject == object()) + return true; + + RenderObject* curr = endObject; + RenderObject* parent = curr->parent(); + while (parent && !parent->isRenderBlock()) { + if (parent->lastChild() != curr || parent == object()) + return false; + + curr = parent; + parent = curr->parent(); + } + + return true; +} + +void InlineFlowBox::determineSpacingForFlowBoxes(bool lastLine, RenderObject* endObject) +{ + // All boxes start off open. They will not apply any margins/border/padding on + // any side. + bool includeLeftEdge = false; + bool includeRightEdge = false; + + RenderFlow* flow = static_cast<RenderFlow*>(object()); + + if (!flow->firstChild()) + includeLeftEdge = includeRightEdge = true; // Empty inlines never split across lines. + else if (parent()) { // The root inline box never has borders/margins/padding. + bool ltr = flow->style()->direction() == LTR; + + // Check to see if all initial lines are unconstructed. If so, then + // we know the inline began on this line. + if (!flow->firstLineBox()->isConstructed()) { + if (ltr && flow->firstLineBox() == this) + includeLeftEdge = true; + else if (!ltr && flow->lastLineBox() == this) + includeRightEdge = true; + } + + // In order to determine if the inline ends on this line, we check three things: + // (1) If we are the last line and we don't have a continuation(), then we can + // close up. + // (2) If the last line box for the flow has an object following it on the line (ltr, + // reverse for rtl), then the inline has closed. + // (3) The line may end on the inline. If we are the last child (climbing up + // the end object's chain), then we just closed as well. + if (!flow->lastLineBox()->isConstructed()) { + if (ltr) { + if (!nextLineBox() && + ((lastLine && !object()->continuation()) || nextOnLineExists() + || onEndChain(endObject))) + includeRightEdge = true; + } + else { + if ((!prevLineBox() || !prevLineBox()->isConstructed()) && + ((lastLine && !object()->continuation()) || + prevOnLineExists() || onEndChain(endObject))) + includeLeftEdge = true; + } + + } + } + + setEdges(includeLeftEdge, includeRightEdge); + + // Recur into our children. + for (InlineBox* currChild = firstChild(); currChild; currChild = currChild->nextOnLine()) { + if (currChild->isInlineFlowBox()) { + InlineFlowBox* currFlow = static_cast<InlineFlowBox*>(currChild); + currFlow->determineSpacingForFlowBoxes(lastLine, endObject); + } + } +} + +int InlineFlowBox::placeBoxesHorizontally(int x) +{ + // Set our x position. + setXPos(x); + + int startX = x; + x += borderLeft() + paddingLeft(); + + for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) { + if (curr->object()->isText()) { + InlineTextBox* text = static_cast<InlineTextBox*>(curr); + text->setXPos(x); + x += curr->width(); + } + else { + if (curr->object()->isPositioned()) { + if (curr->object()->parent()->style()->direction() == LTR) + curr->setXPos(x); + else { + // Our offset that we cache needs to be from the edge of the right border box and + // not the left border box. We have to subtract |x| from the width of the block + // (which can be obtained by walking up to the root line box). + InlineBox* root = this; + while (!root->isRootInlineBox()) + root = root->parent(); + curr->setXPos(root->object()->width()-x); + } + continue; // The positioned object has no effect on the width. + } + if (curr->object()->isInlineFlow()) { + InlineFlowBox* flow = static_cast<InlineFlowBox*>(curr); + x += flow->marginLeft(); + x = flow->placeBoxesHorizontally(x); + x += flow->marginRight(); + } + else { + x += curr->object()->marginLeft(); + curr->setXPos(x); + x += curr->width() + curr->object()->marginRight(); + } + } + } + + x += borderRight() + paddingRight(); + setWidth(x-startX); + return x; +} + +void InlineFlowBox::verticallyAlignBoxes(int& heightOfBlock) +{ + int maxPositionTop = 0; + int maxPositionBottom = 0; + int maxAscent = 0; + int maxDescent = 0; + + // Figure out if we're in strict mode. + RenderObject* curr = object(); + while (curr && !curr->element()) + curr = curr->container(); + bool strictMode = (curr && curr->element()->getDocument()->inStrictMode()); + + computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode); + + if (maxAscent + maxDescent < kMax(maxPositionTop, maxPositionBottom)) + adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom); + + int maxHeight = maxAscent + maxDescent; + int topPosition = heightOfBlock; + int bottomPosition = heightOfBlock; + placeBoxesVertically(heightOfBlock, maxHeight, maxAscent, strictMode, topPosition, bottomPosition); + + setOverflowPositions(topPosition, bottomPosition); + + // Shrink boxes with no text children in quirks and almost strict mode. + if (!strictMode) + shrinkBoxesWithNoTextChildren(topPosition, bottomPosition); + + heightOfBlock += maxHeight; +} + +void InlineFlowBox::adjustMaxAscentAndDescent(int& maxAscent, int& maxDescent, + int maxPositionTop, int maxPositionBottom) +{ + for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) { + // The computed lineheight needs to be extended for the + // positioned elements + // see tdehtmltests/rendering/html_align.html + + if (curr->object()->isPositioned()) + continue; // Positioned placeholders don't affect calculations. + if (curr->yPos() == PositionTop || curr->yPos() == PositionBottom) { + if (curr->yPos() == PositionTop) { + if (maxAscent + maxDescent < curr->height()) + maxDescent = curr->height() - maxAscent; + } + else { + if (maxAscent + maxDescent < curr->height()) + maxAscent = curr->height() - maxDescent; + } + + if ( maxAscent + maxDescent >= kMax( maxPositionTop, maxPositionBottom ) ) + break; + } + + if (curr->isInlineFlowBox()) + static_cast<InlineFlowBox*>(curr)->adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom); + } +} + +void InlineFlowBox::computeLogicalBoxHeights(int& maxPositionTop, int& maxPositionBottom, + int& maxAscent, int& maxDescent, bool strictMode) +{ + if (isRootInlineBox()) { + // Examine our root box. + setHeight(object()->lineHeight(m_firstLine)); + bool isTableCell = object()->isTableCell(); + if (isTableCell) { + RenderTableCell* tableCell = static_cast<RenderTableCell*>(object()); + setBaseline(tableCell->RenderBlock::baselinePosition(m_firstLine)); + } + else + setBaseline(object()->baselinePosition(m_firstLine)); + if (hasTextChildren() || strictMode) { + int ascent = baseline(); + int descent = height() - ascent; + if (maxAscent < ascent) + maxAscent = ascent; + if (maxDescent < descent) + maxDescent = descent; + } + } + + for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) { + if (curr->object()->isPositioned()) + continue; // Positioned placeholders don't affect calculations. + + curr->setHeight(curr->object()->lineHeight(m_firstLine)); + curr->setBaseline(curr->object()->baselinePosition(m_firstLine)); + curr->setYPos(curr->object()->verticalPositionHint(m_firstLine)); + if (curr->yPos() == PositionTop) { + if (maxPositionTop < curr->height()) + maxPositionTop = curr->height(); + } + else if (curr->yPos() == PositionBottom) { + if (maxPositionBottom < curr->height()) + maxPositionBottom = curr->height(); + } + else if (curr->hasTextChildren() || strictMode) { + int ascent = curr->baseline() - curr->yPos(); + int descent = curr->height() - ascent; + if (maxAscent < ascent) + maxAscent = ascent; + if (maxDescent < descent) + maxDescent = descent; + } + + if (curr->isInlineFlowBox()) + static_cast<InlineFlowBox*>(curr)->computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode); + } +} + +void InlineFlowBox::placeBoxesVertically(int y, int maxHeight, int maxAscent, bool strictMode, + int& topPosition, int& bottomPosition) +{ + if (isRootInlineBox()) { + setYPos(y + maxAscent - baseline());// Place our root box. + // CSS2: 10.8.1 - line-height on the block level element specifies the *minimum* + // height of the generated line box + if (hasTextChildren() && maxHeight < object()->lineHeight(m_firstLine)) + maxHeight = object()->lineHeight(m_firstLine); + } + + for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) { + if (curr->object()->isPositioned()) + continue; // Positioned placeholders don't affect calculations. + + // Adjust boxes to use their real box y/height and not the logical height (as dictated by + // line-height). + if (curr->isInlineFlowBox()) + static_cast<InlineFlowBox*>(curr)->placeBoxesVertically(y, maxHeight, maxAscent, strictMode, + topPosition, bottomPosition); + + bool childAffectsTopBottomPos = true; + + if (curr->yPos() == PositionTop) + curr->setYPos(y); + else if (curr->yPos() == PositionBottom) + curr->setYPos(y + maxHeight - curr->height()); + else { + if (!strictMode && !curr->hasTextDescendant()) + childAffectsTopBottomPos = false; + curr->setYPos(curr->yPos() + y + maxAscent - curr->baseline()); + } + int newY = curr->yPos(); + int newHeight = curr->height(); + int newBaseline = curr->baseline(); + int overflowTop = 0; + int overflowBottom = 0; + if (curr->isInlineTextBox() || curr->isInlineFlowBox()) { + const TQFontMetrics &fm = curr->object()->fontMetrics( m_firstLine ); +#ifdef APPLE_CHANGES + newBaseline = fm.ascent(); + newY += curr->baseline() - newBaseline; + newHeight = newBaseline+fm.descent(); +#else + // only adjust if the leading delta is superior to the font's natural leading + if ( kAbs(fm.ascent() - curr->baseline()) > fm.leading()/2 ) { + int ascent = fm.ascent()+fm.leading()/2; + newBaseline = ascent; + newY += curr->baseline() - newBaseline; + newHeight = fm.lineSpacing(); + } +#endif + for (ShadowData* shadow = curr->object()->style()->textShadow(); shadow; shadow = shadow->next) { + overflowTop = kMin(overflowTop, shadow->y - shadow->blur); + overflowBottom = kMax(overflowBottom, shadow->y + shadow->blur); + } + if (curr->isInlineFlowBox()) { + newHeight += curr->object()->borderTop() + curr->object()->paddingTop() + + curr->object()->borderBottom() + curr->object()->paddingBottom(); + newY -= curr->object()->borderTop() + curr->object()->paddingTop(); + newBaseline += curr->object()->borderTop() + curr->object()->paddingTop(); + } + } else { + newY += curr->object()->marginTop(); + newHeight = curr->height() - (curr->object()->marginTop() + curr->object()->marginBottom()); + overflowTop = curr->object()->overflowTop(); + overflowBottom = curr->object()->overflowHeight() - newHeight; + } + curr->setYPos(newY); + curr->setHeight(newHeight); + curr->setBaseline(newBaseline); + + if (childAffectsTopBottomPos) { + topPosition = kMin(topPosition, newY + overflowTop); + bottomPosition = kMax(bottomPosition, newY + newHeight + overflowBottom); + } + } + + if (isRootInlineBox()) { + const TQFontMetrics &fm = object()->fontMetrics( m_firstLine ); +#ifdef APPLE_CHANGES + setHeight(fm.ascent()+fm.descent()); + setYPos(yPos() + baseline() - fm.ascent()); + setBaseline(fm.ascent()); +#else + if ( kAbs(fm.ascent() - baseline()) > fm.leading()/2 ) { + int ascent = fm.ascent()+fm.leading()/2; + setHeight(fm.lineSpacing()); + setYPos(yPos() + baseline() - ascent); + setBaseline(ascent); + } +#endif + if (hasTextDescendant() || strictMode) { + if (yPos() < topPosition) + topPosition = yPos(); + if (yPos() + height() > bottomPosition) + bottomPosition = yPos() + height(); + } + } +} + +void InlineFlowBox::shrinkBoxesWithNoTextChildren(int topPos, int bottomPos) +{ + // First shrink our kids. + for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) { + if (curr->object()->isPositioned()) + continue; // Positioned placeholders don't affect calculations. + + if (curr->isInlineFlowBox()) + static_cast<InlineFlowBox*>(curr)->shrinkBoxesWithNoTextChildren(topPos, bottomPos); + } + + // See if we have text children. If not, then we need to shrink ourselves to fit on the line. + if (!hasTextDescendant()) { + if (yPos() < topPos) + setYPos(topPos); + if (yPos() + height() > bottomPos) + setHeight(bottomPos - yPos()); + if (baseline() > height()) + setBaseline(height()); + } +} + +bool InlineFlowBox::nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty) +{ + // Check children first. + for (InlineBox* curr = lastChild(); curr; curr = curr->prevOnLine()) { + if (!curr->object()->layer() && curr->nodeAtPoint(i, x, y, tx, ty)) { + object()->setInnerNode(i); + return true; + } + } + + // Now check ourselves. + TQRect rect(tx + m_x, ty + m_y, m_width, m_height); + if (object()->style()->visibility() == VISIBLE && rect.contains(x, y)) { + object()->setInnerNode(i); + return true; + } + + return false; +} + + +void InlineFlowBox::paint(RenderObject::PaintInfo& i, int tx, int ty) +{ + bool intersectsDamageRect = true; + int xPos = tx + m_x - object()->maximalOutlineSize(i.phase); + int w = width() + 2 * object()->maximalOutlineSize(i.phase); + if ((xPos >= i.r.x() + i.r.width()) || (xPos + w <= i.r.x())) + intersectsDamageRect = false; + + if (intersectsDamageRect) { + if (i.phase == PaintActionOutline) { + // Add ourselves to the paint info struct's list of inlines that need to paint their + // outlines. + if (object()->style()->visibility() == VISIBLE && object()->style()->outlineWidth() > 0 && + !object()->isInlineContinuation() && !isRootInlineBox()) { + if (!i.outlineObjects) + i.outlineObjects = new TQValueList<RenderFlow*>; + i.outlineObjects->append(static_cast<RenderFlow*>(object())); + } + } + else { + // 1. Paint our background and border. + paintBackgroundAndBorder(i, tx, ty); + + // 2. Paint our underline and overline. + paintDecorations(i, tx, ty, false); + } + } + + // 3. Paint our children. + for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) { + if (!curr->object()->layer()) + curr->paint(i, tx, ty); + } + + // 4. Paint our strike-through + if (intersectsDamageRect && i.phase != PaintActionOutline) + paintDecorations(i, tx, ty, true); +} + + +void InlineFlowBox::paintBackgrounds(TQPainter* p, const TQColor& c, const BackgroundLayer* bgLayer, + int my, int mh, int _tx, int _ty, int w, int h) +{ + if (!bgLayer) + return; + paintBackgrounds(p, c, bgLayer->next(), my, mh, _tx, _ty, w, h); + paintBackground(p, c, bgLayer, my, mh, _tx, _ty, w, h); +} + +void InlineFlowBox::paintBackground(TQPainter* p, const TQColor& c, const BackgroundLayer* bgLayer, + int my, int mh, int _tx, int _ty, int w, int h) +{ + CachedImage* bg = bgLayer->backgroundImage(); + bool hasBackgroundImage = bg && (bg->pixmap_size() == bg->valid_rect().size()) && + !bg->isTransparent() && !bg->isErrorImage(); + if (!hasBackgroundImage || (!prevLineBox() && !nextLineBox()) || !parent()) + object()->paintBackgroundExtended(p, c, bgLayer, my, mh, _tx, _ty, w, h, borderLeft(), borderRight(), paddingLeft(), paddingRight()); + else { + // We have a background image that spans multiple lines. + // We need to adjust _tx and _ty by the width of all previous lines. + // Think of background painting on inlines as though you had one long line, a single continuous + // strip. Even though that strip has been broken up across multiple lines, you still paint it + // as though you had one single line. This means each line has to pick up the background where + // the previous line left off. + // FIXME: What the heck do we do with RTL here? The math we're using is obviously not right, + // but it isn't even clear how this should work at all. + int xOffsetOnLine = 0; + for (InlineRunBox* curr = prevLineBox(); curr; curr = curr->prevLineBox()) + xOffsetOnLine += curr->width(); + int startX = _tx - xOffsetOnLine; + int totalWidth = xOffsetOnLine; + for (InlineRunBox* curr = this; curr; curr = curr->nextLineBox()) + totalWidth += curr->width(); + p->save(); + p->setClipRect(TQRect(_tx, _ty, width(), height()), TQPainter::CoordPainter); + object()->paintBackgroundExtended(p, c, bgLayer, my, mh, startX, _ty, + totalWidth, h, borderLeft(), borderRight(), paddingLeft(), paddingRight()); + p->restore(); + } +} + +void InlineFlowBox::paintBackgroundAndBorder(RenderObject::PaintInfo& pI, int _tx, int _ty) +{ + if (object()->style()->visibility() != VISIBLE || pI.phase != PaintActionForeground) + return; + + // Move x/y to our coordinates. + _tx += m_x; + _ty += m_y; + + int w = width(); + int h = height(); + + int my = kMax(_ty, pI.r.y()); + int mh; + if (_ty<pI.r.y()) + mh= kMax(0,h-(pI.r.y()-_ty)); + else + mh = kMin(pI.r.height(),h); + + // You can use p::first-line to specify a background. If so, the root line boxes for + // a line may actually have to paint a background. + RenderStyle* styleToUse = object()->style(m_firstLine); + if ((!parent() && m_firstLine && styleToUse != object()->style()) || + (parent() && object()->shouldPaintBackgroundOrBorder())) { + TQColor c = styleToUse->backgroundColor(); + paintBackgrounds(pI.p, c, styleToUse->backgroundLayers(), my, mh, _tx, _ty, w, h); + + // :first-line cannot be used to put borders on a line. Always paint borders with our + // non-first-line style. + if (parent() && object()->style()->hasBorder()) + object()->paintBorder(pI.p, _tx, _ty, w, h, object()->style(), includeLeftEdge(), includeRightEdge()); + } +} + +static bool shouldDrawDecoration(RenderObject* obj) +{ + bool shouldDraw = false; + for (RenderObject* curr = obj->firstChild(); + curr; curr = curr->nextSibling()) { + if (curr->isInlineFlow()) { + shouldDraw = true; + break; + } + else if (curr->isText() && !curr->isBR() && (curr->style()->preserveWS() || + !curr->element() || !curr->element()->containsOnlyWhitespace())) { + shouldDraw = true; + break; + } + } + return shouldDraw; +} + +void InlineFlowBox::paintDecorations(RenderObject::PaintInfo& pI, int _tx, int _ty, bool paintedChildren) +{ + // Now paint our text decorations. We only do this if we aren't in quirks mode (i.e., in + // almost-strict mode or strict mode). + if (object()->style()->htmlHacks() || object()->style()->visibility() != VISIBLE) + return; + + _tx += m_x; + _ty += m_y; + RenderStyle* styleToUse = object()->style(m_firstLine); + int deco = parent() ? styleToUse->textDecoration() : styleToUse->textDecorationsInEffect(); + if (deco != TDNONE && + ((!paintedChildren && ((deco & UNDERLINE) || (deco & OVERLINE))) || (paintedChildren && (deco & LINE_THROUGH))) && + shouldDrawDecoration(object())) { + // We must have child boxes and have decorations defined. + _tx += borderLeft() + paddingLeft(); + int w = m_width - (borderLeft() + paddingLeft() + borderRight() + paddingRight()); + if ( !w ) + return; + const TQFontMetrics &fm = object()->fontMetrics( m_firstLine ); + // thick lines on small fonts look ugly + int thickness = fm.height() > 20 ? fm.lineWidth() : 1; + TQColor underline, overline, linethrough; + underline = overline = linethrough = styleToUse->color(); + if (!parent()) + object()->getTextDecorationColors(deco, underline, overline, linethrough); + + if (styleToUse->font() != pI.p->font()) + pI.p->setFont(styleToUse->font()); + + if (deco & UNDERLINE && !paintedChildren) { + int underlineOffset = ( fm.height() + m_baseline ) / 2; + if (underlineOffset <= m_baseline) underlineOffset = m_baseline+1; + + pI.p->fillRect(_tx, _ty + underlineOffset, w, thickness, underline ); + } + if (deco & OVERLINE && !paintedChildren) { + pI.p->fillRect(_tx, _ty, w, thickness, overline ); + } + if (deco & LINE_THROUGH && paintedChildren) { + pI.p->fillRect(_tx, _ty + 2*m_baseline/3, w, thickness, linethrough ); + } + } +} + +bool InlineFlowBox::canAccommodateEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth) +{ + for (InlineBox *box = firstChild(); box; box = box->nextOnLine()) { + if (!box->canAccommodateEllipsisBox(ltr, blockEdge, ellipsisWidth)) + return false; + } + return true; +} + +int InlineFlowBox::placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool& foundBox) +{ + int result = -1; + for (InlineBox *box = firstChild(); box; box = box->nextOnLine()) { + int currResult = box->placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox); + if (currResult != -1 && result == -1) + result = currResult; + } + return result; +} + +void InlineFlowBox::clearTruncation() +{ + for (InlineBox *box = firstChild(); box; box = box->nextOnLine()) + box->clearTruncation(); +} + +void EllipsisBox::paint(RenderObject::PaintInfo& i, int _tx, int _ty) +{ + TQPainter* p = i.p; + RenderStyle* _style = m_firstLine ? m_object->style(true) : m_object->style(); + if (_style->font() != p->font()) + p->setFont(_style->font()); + + const Font* font = &_style->htmlFont(); + TQColor textColor = _style->color(); + if (textColor != p->pen().color()) + p->setPen(textColor); + /* + bool setShadow = false; + if (_style->textShadow()) { + p->setShadow(_style->textShadow()->x, _style->textShadow()->y, + _style->textShadow()->blur, _style->textShadow()->color); + setShadow = true; + }*/ + + const DOMString& str = m_str.string(); + font->drawText(p, m_x + _tx, + m_y + _ty + m_baseline, + (str.implementation())->s, + str.length(), 0, str.length(), + 0, + TQPainter::LTR, _style->visuallyOrdered()); + + /* + if (setShadow) + p->clearShadow(); + */ + + if (m_markupBox) { + // Paint the markup box + _tx += m_x + m_width - m_markupBox->xPos(); + _ty += m_y + m_baseline - (m_markupBox->yPos() + m_markupBox->baseline()); + m_markupBox->object()->paint(i, _tx, _ty); + } +} + +bool EllipsisBox::nodeAtPoint(RenderObject::NodeInfo& info, int _x, int _y, int _tx, int _ty) +{ + // Hit test the markup box. + if (m_markupBox) { + _tx += m_x + m_width - m_markupBox->xPos(); + _ty += m_y + m_baseline - (m_markupBox->yPos() + m_markupBox->baseline()); + if (m_markupBox->nodeAtPoint(info, _x, _y, _tx, _ty)) { + object()->setInnerNode(info); + return true; + } + } + + TQRect rect(_tx + m_x, _ty + m_y, m_width, m_height); + if (object()->style()->visibility() == VISIBLE && rect.contains(_x, _y)) { + object()->setInnerNode(info); + return true; + } + return false; +} + +void RootInlineBox::detach(RenderArena* arena) +{ + detachEllipsisBox(arena); + InlineFlowBox::detach(arena); +} + +void RootInlineBox::detachEllipsisBox(RenderArena* arena) +{ + if (m_ellipsisBox) { + m_ellipsisBox->detach(arena); + m_ellipsisBox = 0; + } +} + +void RootInlineBox::clearTruncation() +{ + if (m_ellipsisBox) { + detachEllipsisBox(m_object->renderArena()); + InlineFlowBox::clearTruncation(); + } +} + +bool RootInlineBox::canAccommodateEllipsis(bool ltr, int blockEdge, int lineBoxEdge, int ellipsisWidth) +{ + // First sanity-check the unoverflowed width of the whole line to see if there is sufficient room. + int delta = ltr ? lineBoxEdge - blockEdge : blockEdge - lineBoxEdge; + if (width() - delta < ellipsisWidth) + return false; + + // Next iterate over all the line boxes on the line. If we find a replaced element that intersects + // then we refuse to accommodate the ellipsis. Otherwise we're ok. + return InlineFlowBox::canAccommodateEllipsisBox(ltr, blockEdge, ellipsisWidth); +} + +void RootInlineBox::placeEllipsis(const DOMString& ellipsisStr, bool ltr, int blockEdge, int ellipsisWidth, InlineBox* markupBox) +{ + // Create an ellipsis box. + m_ellipsisBox = new (m_object->renderArena()) EllipsisBox(m_object, ellipsisStr, this, + ellipsisWidth - (markupBox ? markupBox->width() : 0), + yPos(), height(), baseline(), !prevRootBox(), + markupBox); + + if (ltr && (xPos() + width() + ellipsisWidth) <= blockEdge) { + m_ellipsisBox->m_x = xPos() + width(); + return; + } + + // Now attempt to find the nearest glyph horizontally and place just to the right (or left in RTL) + // of that glyph. Mark all of the objects that intersect the ellipsis box as not painting (as being + // truncated). + bool foundBox = false; + m_ellipsisBox->m_x = placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox); +} + +int RootInlineBox::placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool& foundBox) +{ + int result = InlineFlowBox::placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox); + if (result == -1) + result = ltr ? blockEdge - ellipsisWidth : blockEdge; + return result; +} + +void RootInlineBox::paintEllipsisBox(RenderObject::PaintInfo& i, int _tx, int _ty) const +{ + if (m_ellipsisBox) + m_ellipsisBox->paint(i, _tx, _ty); +} + +void RootInlineBox::paint(RenderObject::PaintInfo& i, int tx, int ty) +{ + InlineFlowBox::paint(i, tx, ty); + paintEllipsisBox(i, tx, ty); +} + +bool RootInlineBox::nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty) +{ + if (m_ellipsisBox && object()->style()->visibility() == VISIBLE) { + if (m_ellipsisBox->nodeAtPoint(i, x, y, tx, ty)) { + object()->setInnerNode(i); + return true; + } + } + return InlineFlowBox::nodeAtPoint(i, x, y, tx, ty); +} + diff --git a/tdehtml/rendering/render_line.h b/tdehtml/rendering/render_line.h new file mode 100644 index 000000000..3dc066e10 --- /dev/null +++ b/tdehtml/rendering/render_line.h @@ -0,0 +1,310 @@ +/* + * This file is part of the line box implementation for KDE. + * + * Copyright (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_LINE_H +#define RENDER_LINE_H + +namespace tdehtml { + +class EllipsisBox; +class InlineFlowBox; +class RootInlineBox; + +// InlineBox represents a rectangle that occurs on a line. It corresponds to +// some RenderObject (i.e., it represents a portion of that RenderObject). +class InlineBox +{ +public: + InlineBox(RenderObject* obj) + :m_object(obj), m_x(0), m_width(0), m_y(0), m_height(0), m_baseline(0), + m_firstLine(false), m_constructed(false) + { + m_next = 0; + m_prev = 0; + m_parent = 0; + } + + virtual ~InlineBox() {} + + void detach(RenderArena* renderArena); + + virtual void paint(RenderObject::PaintInfo& i, int _tx, int _ty); + virtual bool nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty); + + // Overloaded new operator. + void* operator new(size_t sz, RenderArena* renderArena) throw(); + + // Overridden to prevent the normal delete from being called. + void operator delete(void* ptr, size_t sz); + +private: + // The normal operator new is disallowed. + void* operator new(size_t sz) throw(); + +public: + virtual bool isInlineBox() const { return false; } + virtual bool isInlineFlowBox() const { return false; } + virtual bool isContainer() const { return false; } + virtual bool isInlineTextBox() const { return false; } + virtual bool isRootInlineBox() const { return false; } + + bool isConstructed() const { return m_constructed; } + virtual void setConstructed() { + m_constructed = true; + if (m_next) + m_next->setConstructed(); + } + + void setFirstLineStyleBit(bool f) { m_firstLine = f; } + + InlineBox* nextOnLine() { return m_next; } + InlineBox* prevOnLine() { return m_prev; } + RenderObject* object() const { return m_object; } + + InlineFlowBox* parent() { return m_parent; } + void setParent(InlineFlowBox* par) { m_parent = par; } + + RootInlineBox* root(); + + void setWidth(short w) { m_width = w; } + short width() const { return m_width; } + + void setXPos(short x) { m_x = x; } + short xPos() const { return m_x; } + + void setYPos(int y) { m_y = y; } + int yPos() const { return m_y; } + + void setHeight(int h) { m_height = h; } + int height() const { return m_height; } + + void setBaseline(int b) { m_baseline = b; } + int baseline() const { return m_baseline; } + + virtual bool hasTextChildren() const { return true; } + virtual bool hasTextDescendant() const { return true; } + + virtual int topOverflow() const { return yPos(); } + virtual int bottomOverflow() const { return yPos()+height(); } + + virtual long minOffset() const { return 0; } + virtual long maxOffset() const { return 0; } + + virtual void clearTruncation() {}; + + virtual bool canAccommodateEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth); + virtual int placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool&); + +public: // FIXME: Would like to make this protected, but methods are accessing these + // members over in the part. + RenderObject* m_object; + + short m_x; + short m_width; + int m_y; + int m_height; + int m_baseline; + + bool m_firstLine : 1; + bool m_constructed : 1; + + InlineBox* m_next; // The next element on the same line as us. + InlineBox* m_prev; // The previous element on the same line as us. + + InlineFlowBox* m_parent; // The box that contains us. +}; + +class InlineRunBox : public InlineBox +{ +public: + InlineRunBox(RenderObject* obj) + :InlineBox(obj) + { + m_prevLine = 0; + m_nextLine = 0; + } + + InlineRunBox* prevLineBox() { return m_prevLine; } + InlineRunBox* nextLineBox() { return m_nextLine; } + void setNextLineBox(InlineRunBox* n) { m_nextLine = n; } + void setPreviousLineBox(InlineRunBox* p) { m_prevLine = p; } + + virtual void paintBackgroundAndBorder(RenderObject::PaintInfo&, int /*_tx*/, int /*_ty*/) {} + virtual void paintDecorations(RenderObject::PaintInfo&, int /*_tx*/, int /*_ty*/, bool /*paintedChildren*/ = false) {} + +protected: + InlineRunBox* m_prevLine; // The previous box that also uses our RenderObject + InlineRunBox* m_nextLine; // The next box that also uses our RenderObject +}; + +class InlineFlowBox : public InlineRunBox +{ +public: + InlineFlowBox(RenderObject* obj) + :InlineRunBox(obj) + { + m_firstChild = 0; + m_lastChild = 0; + m_includeLeftEdge = m_includeRightEdge = false; + m_hasTextChildren = false; + m_hasTextDescendant = false; + m_afterPageBreak = false; + } + + ~InlineFlowBox(); + + virtual bool isInlineFlowBox() const { return true; } + + InlineFlowBox* prevFlowBox() const { return static_cast<InlineFlowBox*>(m_prevLine); } + InlineFlowBox* nextFlowBox() const { return static_cast<InlineFlowBox*>(m_nextLine); } + + InlineBox* firstChild() const { return m_firstChild; } + InlineBox* lastChild() const { return m_lastChild; } + + virtual void setConstructed() { + InlineBox::setConstructed(); + if (m_firstChild) + m_firstChild->setConstructed(); + } + void addToLine(InlineBox* child) { + if (!m_firstChild) + m_firstChild = m_lastChild = child; + else { + m_lastChild->m_next = child; + child->m_prev = m_lastChild; + m_lastChild = child; + } + child->setFirstLineStyleBit(m_firstLine); + child->setParent(this); + if (!m_hasTextChildren && child->isInlineTextBox()) { + m_hasTextDescendant = m_hasTextChildren = true; + for (InlineFlowBox* p = m_parent; p && !p->hasTextDescendant(); p = p->parent()) + p->m_hasTextDescendant = true; + } + } + + virtual void clearTruncation(); + + void removeFromLine(InlineBox* child); + virtual void paintBackgroundAndBorder(RenderObject::PaintInfo&, int _tx, int _ty); + void paintBackgrounds(TQPainter* p, const TQColor& c, const BackgroundLayer* bgLayer, + int my, int mh, int _tx, int _ty, int w, int h); + void paintBackground(TQPainter* p, const TQColor& c, const BackgroundLayer* bgLayer, + int my, int mh, int _tx, int _ty, int w, int h); + virtual void paint(RenderObject::PaintInfo& i, int _tx, int _ty); + virtual void paintDecorations(RenderObject::PaintInfo&, int _tx, int _ty, bool paintedChildren = false); + virtual bool nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty); + + int marginBorderPaddingLeft() const; + int marginBorderPaddingRight() const; + int marginLeft() const; + int marginRight( )const; + int borderLeft() const { if (includeLeftEdge()) return object()->borderLeft(); return 0; } + int borderRight() const { if (includeRightEdge()) return object()->borderRight(); return 0; } + int paddingLeft() const { if (includeLeftEdge()) return object()->paddingLeft(); return 0; } + int paddingRight() const { if (includeRightEdge()) return object()->paddingRight(); return 0; } + + bool includeLeftEdge() const { return m_includeLeftEdge; } + bool includeRightEdge() const { return m_includeRightEdge; } + void setEdges(bool includeLeft, bool includeRight) { + m_includeLeftEdge = includeLeft; + m_includeRightEdge = includeRight; + } + virtual bool hasTextChildren() const { return m_hasTextChildren; } + bool hasTextDescendant() const { return m_hasTextDescendant; } + + // Helper functions used during line construction and placement. + void determineSpacingForFlowBoxes(bool lastLine, RenderObject* endObject); + int getFlowSpacingWidth() const; + bool nextOnLineExists(); + bool prevOnLineExists(); + bool onEndChain(RenderObject* endObject); + int placeBoxesHorizontally(int x); + void verticallyAlignBoxes(int& heightOfBlock); + void computeLogicalBoxHeights(int& maxPositionTop, int& maxPositionBottom, + int& maxAscent, int& maxDescent, bool strictMode); + void adjustMaxAscentAndDescent(int& maxAscent, int& maxDescent, + int maxPositionTop, int maxPositionBottom); + void placeBoxesVertically(int y, int maxHeight, int maxAscent, bool strictMode, + int& topPosition, int& bottomPosition); + void shrinkBoxesWithNoTextChildren(int topPosition, int bottomPosition); + + virtual void setOverflowPositions(int /*top*/, int /*bottom*/) {} + + void setAfterPageBreak(bool b = true) { m_afterPageBreak = b; } + bool afterPageBreak() const { return m_afterPageBreak; } + + virtual bool canAccommodateEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth); + virtual int placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool&); + +protected: + InlineBox* m_firstChild; + InlineBox* m_lastChild; + bool m_includeLeftEdge : 1; + bool m_includeRightEdge : 1; + bool m_hasTextChildren : 1; + bool m_hasTextDescendant : 1; + bool m_afterPageBreak : 1; +}; + +class RootInlineBox : public InlineFlowBox +{ +public: + RootInlineBox(RenderObject* obj) : InlineFlowBox(obj), m_ellipsisBox(0) + { + m_topOverflow = m_bottomOverflow = 0; + } + + virtual void detach(RenderArena* renderArena); + void detachEllipsisBox(RenderArena* renderArena); + + RootInlineBox* nextRootBox() { return static_cast<RootInlineBox*>(m_nextLine); } + RootInlineBox* prevRootBox() { return static_cast<RootInlineBox*>(m_prevLine); } + + virtual bool isRootInlineBox() const { return true; } + virtual int topOverflow() const { return m_topOverflow; } + virtual int bottomOverflow() const { return m_bottomOverflow; } + virtual void setOverflowPositions(int top, int bottom) { m_topOverflow = top; m_bottomOverflow = bottom; } + + bool canAccommodateEllipsis(bool ltr, int blockEdge, int lineBoxEdge, int ellipsisWidth); + void placeEllipsis(const DOM::DOMString& ellipsisStr, bool ltr, int blockEdge, int ellipsisWidth, InlineBox* markupBox = 0); + virtual int placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool&); + + EllipsisBox* ellipsisBox() const { return m_ellipsisBox; } + void paintEllipsisBox(RenderObject::PaintInfo& i, int _tx, int _ty) const; + bool hitTestEllipsisBox(RenderObject::NodeInfo& info, int _x, int _y, int _tx, int _ty); + + virtual void clearTruncation(); + + virtual void paint(RenderObject::PaintInfo& i, int _tx, int _ty); + virtual bool nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty); + +protected: + int m_topOverflow; + int m_bottomOverflow; + + // An inline text box that represents our text truncation string. + EllipsisBox* m_ellipsisBox; +}; + +} //namespace + +#endif diff --git a/tdehtml/rendering/render_list.cpp b/tdehtml/rendering/render_list.cpp new file mode 100644 index 000000000..08ee1a88b --- /dev/null +++ b/tdehtml/rendering/render_list.cpp @@ -0,0 +1,586 @@ +/** + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2000-2002 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "rendering/render_list.h" +#include "rendering/render_canvas.h" +#include "rendering/enumerate.h" +#include "rendering/counter_tree.h" +#include "html/html_listimpl.h" +#include "misc/helper.h" +#include "misc/htmltags.h" +#include "misc/loader.h" +#include "xml/dom_docimpl.h" + +#include <kdebug.h> +#include <kglobal.h> +#include <tqvaluelist.h> + +//#define BOX_DEBUG + +using namespace tdehtml; +using namespace Enumerate; + +const int cMarkerPadding = 7; + +// ------------------------------------------------------------------------- + +RenderListItem::RenderListItem(DOM::NodeImpl* node) + : RenderBlock(node) +{ + // init RenderObject attributes + setInline(false); // our object is not Inline + + predefVal = -1; + m_marker = 0; + m_counter = 0; + m_insideList = false; + m_deleteMarker = false; +} + +void RenderListItem::setStyle(RenderStyle *_style) +{ + RenderBlock::setStyle(_style); + + RenderStyle *newStyle = new RenderStyle(); + newStyle->ref(); + + newStyle->inheritFrom(style()); + + if(!m_marker && style()->listStyleType() != LNONE) { + m_marker = new (renderArena()) RenderListMarker(element()); + m_marker->setIsAnonymous( true ); + m_marker->setStyle(newStyle); + m_marker->setListItem( this ); + m_deleteMarker = true; + } else if ( m_marker && style()->listStyleType() == LNONE) { + m_marker->detach(); + m_marker = 0; + } + else if ( m_marker ) { + m_marker->setStyle(newStyle); + } + + newStyle->deref(); +} + +void RenderListItem::detach() +{ + if ( m_marker && m_deleteMarker ) + m_marker->detach(); + RenderBlock::detach(); +} + +static RenderObject* getParentOfFirstLineBox(RenderObject* curr, RenderObject* marker) +{ + RenderObject* firstChild = curr->firstChild(); + if (!firstChild) + return 0; + + for (RenderObject* currChild = firstChild; + currChild; currChild = currChild->nextSibling()) { + if (currChild == marker) + continue; + + if (currChild->isInline()) + return curr; + + if (currChild->isFloating() || currChild->isPositioned()) + continue; + + if (currChild->isTable() || !currChild->isRenderBlock()) + break; + + if (currChild->style()->htmlHacks() && currChild->element() && + (currChild->element()->id() == ID_UL || currChild->element()->id() == ID_OL)) + break; + + RenderObject* lineBox = getParentOfFirstLineBox(currChild, marker); + if (lineBox) + return lineBox; + } + + return 0; +} + + +void RenderListItem::updateMarkerLocation() +{ + // Sanity check the location of our marker. + if (m_marker) { + RenderObject* markerPar = m_marker->parent(); + RenderObject* lineBoxParent = getParentOfFirstLineBox(this, m_marker); + if (!lineBoxParent) { + // If the marker is currently contained inside an anonymous box, + // then we are the only item in that anonymous box (since no line box + // parent was found). It's ok to just leave the marker where it is + // in this case. + if (markerPar && markerPar->isAnonymousBlock()) + lineBoxParent = markerPar; + else + lineBoxParent = this; + } + if (markerPar != lineBoxParent) + { + if (markerPar) + markerPar->removeChild(m_marker); + if (!lineBoxParent) + lineBoxParent = this; + lineBoxParent->addChild(m_marker, lineBoxParent->firstChild()); + m_deleteMarker = false; + if (!m_marker->minMaxKnown()) + m_marker->calcMinMaxWidth(); + recalcMinMaxWidths(); + } + } +} + +void RenderListItem::calcMinMaxWidth() +{ + // Make sure our marker is in the correct location. + updateMarkerLocation(); + if (!minMaxKnown()) + RenderBlock::calcMinMaxWidth(); +} +/* +short RenderListItem::marginLeft() const +{ + if (m_insideList) + return RenderBlock::marginLeft(); + else + return kMax(m_marker->markerWidth(), RenderBlock::marginLeft()); +} + +short RenderListItem::marginRight() const +{ + return RenderBlock::marginRight(); +}*/ + +void RenderListItem::layout( ) +{ + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + + updateMarkerLocation(); + RenderBlock::layout(); +} + +// ----------------------------------------------------------- + +RenderListMarker::RenderListMarker(DOM::NodeImpl* node) + : RenderBox(node), m_listImage(0), m_markerWidth(0) +{ + // init RenderObject attributes + setInline(true); // our object is Inline + setReplaced(true); // pretend to be replaced + // val = -1; + // m_listImage = 0; +} + +RenderListMarker::~RenderListMarker() +{ + if(m_listImage) + m_listImage->deref(this); + if (m_listItem) + m_listItem->resetListMarker(); +} + +void RenderListMarker::setStyle(RenderStyle *s) +{ + if ( s && style() && s->listStylePosition() != style()->listStylePosition() ) + setNeedsLayoutAndMinMaxRecalc(); + + RenderBox::setStyle(s); + + if ( m_listImage != style()->listStyleImage() ) { + if(m_listImage) m_listImage->deref(this); + m_listImage = style()->listStyleImage(); + if(m_listImage) m_listImage->ref(this); + } +} + + +void RenderListMarker::paint(PaintInfo& paintInfo, int _tx, int _ty) +{ + if (paintInfo.phase != PaintActionForeground) + return; + + if (style()->visibility() != VISIBLE) return; + + _tx += m_x; + _ty += m_y; + + if((_ty > paintInfo.r.bottom()) || (_ty + m_height <= paintInfo.r.top())) + return; + + if(shouldPaintBackgroundOrBorder()) + paintBoxDecorations(paintInfo, _tx, _ty); + + TQPainter* p = paintInfo.p; +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << nodeName().string() << "(ListMarker)::paintObject(" << _tx << ", " << _ty << ")" << endl; +#endif + p->setFont(style()->font()); + const TQFontMetrics fm = p->fontMetrics(); + + + // The marker needs to adjust its tx, for the case where it's an outside marker. + RenderObject* listItem = 0; + int leftLineOffset = 0; + int rightLineOffset = 0; + if (!listPositionInside()) { + listItem = this; + int yOffset = 0; + int xOffset = 0; + while (listItem && listItem != m_listItem) { + yOffset += listItem->yPos(); + xOffset += listItem->xPos(); + listItem = listItem->parent(); + } + + // Now that we have our xoffset within the listbox, we need to adjust ourselves by the delta + // between our current xoffset and our desired position (which is just outside the border box + // of the list item). + if (style()->direction() == LTR) { + leftLineOffset = m_listItem->leftRelOffset(yOffset, m_listItem->leftOffset(yOffset)); + _tx -= (xOffset - leftLineOffset) + m_listItem->paddingLeft() + m_listItem->borderLeft(); + } + else { + rightLineOffset = m_listItem->rightRelOffset(yOffset, m_listItem->rightOffset(yOffset)); + _tx += (rightLineOffset-xOffset) + m_listItem->paddingRight() + m_listItem->borderRight(); + } + } + + int offset = fm.ascent()*2/3; + bool haveImage = m_listImage && !m_listImage->isErrorImage(); + if (haveImage) + offset = m_listImage->pixmap().width(); + + int xoff = 0; + int yoff = fm.ascent() - offset; + + int bulletWidth = offset/2; + if (offset%2) + bulletWidth++; + if (!listPositionInside()) { + if (listItem && listItem->style()->direction() == LTR) + xoff = -cMarkerPadding - offset; + else + xoff = cMarkerPadding + (haveImage ? 0 : (offset - bulletWidth)); + } + else if (style()->direction() == RTL) + xoff += haveImage ? cMarkerPadding : (m_width - bulletWidth); + + if ( m_listImage && !m_listImage->isErrorImage()) { + p->drawPixmap( TQPoint( _tx + xoff, _ty ), m_listImage->pixmap()); + return; + } + +#ifdef BOX_DEBUG + p->setPen( Qt::red ); + p->drawRect( _tx + xoff, _ty + yoff, offset, offset ); +#endif + + const TQColor color( style()->color() ); + p->setPen( color ); + + switch(style()->listStyleType()) { + case LDISC: + p->setBrush( color ); + p->drawEllipse( _tx + xoff, _ty + (3 * yoff)/2, (offset>>1)+1, (offset>>1)+1 ); + return; + case LCIRCLE: + p->setBrush( Qt::NoBrush ); + p->drawEllipse( _tx + xoff, _ty + (3 * yoff)/2, (offset>>1)+1, (offset>>1)+1 ); + return; + case LSQUARE: + p->setBrush( color ); + p->drawRect( _tx + xoff, _ty + (3 * yoff)/2, (offset>>1)+1, (offset>>1)+1 ); + return; + case LBOX: + p->setBrush( Qt::NoBrush ); + p->drawRect( _tx + xoff, _ty + (3 * yoff)/2, (offset>>1)+1, (offset>>1)+1 ); + return; + case LDIAMOND: { + static TQPointArray diamond(4); + int x = _tx + xoff; + int y = _ty + (3 * yoff)/2 - 1; + int s = (offset>>2)+1; + diamond[0] = TQPoint(x+s, y); + diamond[1] = TQPoint(x+2*s, y+s); + diamond[2] = TQPoint(x+s, y+2*s); + diamond[3] = TQPoint(x, y+s); + p->setBrush( color ); + p->drawConvexPolygon( diamond, 0, 4 ); + return; + } + case LNONE: + return; + default: + if (!m_item.isEmpty()) { + if(listPositionInside()) { + if( style()->direction() == LTR) { + p->drawText(_tx, _ty, 0, 0, Qt::AlignLeft|TQt::DontClip, m_item); + p->drawText(_tx + fm.width(m_item), _ty, 0, 0, Qt::AlignLeft|TQt::DontClip, + TQString::fromLatin1(". ")); + } + else { + const TQString& punct(TQString::fromLatin1(" .")); + p->drawText(_tx, _ty, 0, 0, Qt::AlignLeft|TQt::DontClip, punct); + p->drawText(_tx + fm.width(punct), _ty, 0, 0, Qt::AlignLeft|TQt::DontClip, m_item); + } + } else { + if (style()->direction() == LTR) { + const TQString& punct(TQString::fromLatin1(". ")); + p->drawText(_tx-offset/2, _ty, 0, 0, Qt::AlignRight|TQt::DontClip, punct); + p->drawText(_tx-offset/2-fm.width(punct), _ty, 0, 0, Qt::AlignRight|TQt::DontClip, m_item); + } + else { + const TQString& punct(TQString::fromLatin1(" .")); + p->drawText(_tx+offset/2, _ty, 0, 0, Qt::AlignLeft|TQt::DontClip, punct); + p->drawText(_tx+offset/2+fm.width(punct), _ty, 0, 0, Qt::AlignLeft|TQt::DontClip, m_item); + } + } + } + } +} + +void RenderListMarker::layout() +{ + KHTMLAssert( needsLayout() ); + + if ( !minMaxKnown() ) + calcMinMaxWidth(); + + setNeedsLayout(false); +} + +void RenderListMarker::setPixmap( const TQPixmap &p, const TQRect& r, CachedImage *o) +{ + if(o != m_listImage) { + RenderBox::setPixmap(p, r, o); + return; + } + + if(m_width != m_listImage->pixmap_size().width() || m_height != m_listImage->pixmap_size().height()) + setNeedsLayoutAndMinMaxRecalc(); + else + repaintRectangle(0, 0, m_width, m_height); +} + +void RenderListMarker::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + m_markerWidth = m_width = 0; + + if(m_listImage && !m_listImage->isErrorImage()) { + m_markerWidth = m_listImage->pixmap().width() + cMarkerPadding; + if (listPositionInside()) + m_width = m_markerWidth; + m_height = m_listImage->pixmap().height(); + m_minWidth = m_maxWidth = m_width; + setMinMaxKnown(); + return; + } + + const TQFontMetrics &fm = style()->fontMetrics(); + m_height = fm.ascent(); + + // Skip uncounted elements + switch(style()->listStyleType()) { + // Glyphs: + case LDISC: + case LCIRCLE: + case LSQUARE: + case LBOX: + case LDIAMOND: + m_markerWidth = fm.ascent(); + goto end; + default: + break; + } + + { // variable scope + CounterNode *counter = m_listItem->m_counter; + if (!counter) { + counter = m_listItem->getCounter("list-item", true); + counter->setRenderer(this); + m_listItem->m_counter = counter; + } + + + assert(counter); + int value = counter->count(); + if (counter->isReset()) value = counter->value(); + int total = value; + if (counter->parent()) total = counter->parent()->total(); + + switch(style()->listStyleType()) + { +// Numeric: + case LDECIMAL: + m_item.setNum ( value ); + break; + case DECIMAL_LEADING_ZERO: { + int decimals = 2; + int t = total/100; + while (t>0) { + t = t/10; + decimals++; + } + decimals = kMax(decimals, 2); + TQString num = TQString::number(value); + m_item.fill('0',decimals-num.length()); + m_item.append(num); + break; + } + case ARABIC_INDIC: + m_item = toArabicIndic( value ); + break; + case LAO: + m_item = toLao( value ); + break; + case PERSIAN: + case URDU: + m_item = toPersianUrdu( value ); + break; + case THAI: + m_item = toThai( value ); + break; + case TIBETAN: + m_item = toTibetan( value ); + break; +// Algoritmic: + case LOWER_ROMAN: + m_item = toRoman( value, false ); + break; + case UPPER_ROMAN: + m_item = toRoman( value, true ); + break; + case HEBREW: + m_item = toHebrew( value ); + break; + case ARMENIAN: + m_item = toArmenian( value ); + break; + case GEORGIAN: + m_item = toGeorgian( value ); + break; +// Alphabetic: + case LOWER_ALPHA: + case LOWER_LATIN: + m_item = toLowerLatin( value ); + break; + case UPPER_ALPHA: + case UPPER_LATIN: + m_item = toUpperLatin( value ); + break; + case LOWER_GREEK: + m_item = toLowerGreek( value ); + break; + case UPPER_GREEK: + m_item = toUpperGreek( value ); + break; + case HIRAGANA: + m_item = toHiragana( value ); + break; + case HIRAGANA_IROHA: + m_item = toHiraganaIroha( value ); + break; + case KATAKANA: + m_item = toKatakana( value ); + break; + case KATAKANA_IROHA: + m_item = toKatakanaIroha( value ); + break; +// Ideographic: + case JAPANESE_FORMAL: + m_item = toJapaneseFormal( value ); + break; + case JAPANESE_INFORMAL: + m_item = toJapaneseInformal( value ); + break; + case SIMP_CHINESE_FORMAL: + m_item = toSimpChineseFormal( value ); + break; + case SIMP_CHINESE_INFORMAL: + m_item = toSimpChineseInformal( value ); + break; + case TRAD_CHINESE_FORMAL: + m_item = toTradChineseFormal( value ); + break; + case CJK_IDEOGRAPHIC: + // CSS 3 List says treat as trad-chinese-informal + case TRAD_CHINESE_INFORMAL: + m_item = toTradChineseInformal( value ); + break; +// special: + case LNONE: + break; + default: + KHTMLAssert(false); + } + m_markerWidth = fm.width(m_item) + fm.width(TQString::fromLatin1(". ")); + } + +end: + if(listPositionInside()) + m_width = m_markerWidth; + + m_minWidth = m_width; + m_maxWidth = m_width; + + setMinMaxKnown(); +} + +short RenderListMarker::lineHeight(bool /*b*/) const +{ + return height(); +} + +short RenderListMarker::baselinePosition(bool /*b*/) const +{ + return height(); +} + +void RenderListMarker::calcWidth() +{ + RenderBox::calcWidth(); +} + +/* +int CounterListItem::recount() const +{ + static_cast<RenderListItem*>(m_renderer)->m_marker->setNeedsLayoutAndMinMaxRecalc(); +} + +void CounterListItem::setSelfDirty() +{ + +}*/ + + +#undef BOX_DEBUG diff --git a/tdehtml/rendering/render_list.h b/tdehtml/rendering/render_list.h new file mode 100644 index 000000000..9797d5114 --- /dev/null +++ b/tdehtml/rendering/render_list.h @@ -0,0 +1,140 @@ +/* + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_LIST_H +#define RENDER_LIST_H + +#include "rendering/render_block.h" + +// ### list-style-position, list-style-image is still missing + +namespace DOM +{ + class DocumentImpl; +} + +namespace tdehtml +{ + +class RenderListItem; +class RenderListMarker; +class CounterNode; + +// ----------------------------------------------------------------------------- + +class RenderListItem : public RenderBlock +{ + friend class RenderListMarker; +// friend class CounterListItem; + +public: + RenderListItem(DOM::NodeImpl*); + + virtual const char *renderName() const { return "RenderListItem"; } + + virtual void setStyle(RenderStyle *style); + + virtual bool isListItem() const { return true; } + + void setValue( long v ) { predefVal = v; } + + virtual void layout( ); + virtual void detach( ); + virtual void calcMinMaxWidth(); + //virtual short marginLeft() const; + //virtual short marginRight() const; + + void setInsideList(bool b ) { m_insideList = b; } + +protected: + + void updateMarkerLocation(); + void resetListMarker() { m_marker = 0; } + + RenderListMarker *m_marker; + CounterNode *m_counter; + signed long predefVal : 30; + bool m_insideList : 1; + bool m_deleteMarker: 1; +}; + +// ----------------------------------------------------------------------------- + +class RenderListMarker : public RenderBox +{ +public: + RenderListMarker(DOM::NodeImpl* node); + ~RenderListMarker(); + + virtual void setStyle(RenderStyle *style); + + virtual const char *renderName() const { return "RenderListMarker"; } + // so the marker gets to layout itself. Only needed for + // list-style-position: inside + + virtual void paint(PaintInfo& i, int xoff, int yoff); + virtual void layout( ); + virtual void calcMinMaxWidth(); + + virtual short lineHeight( bool firstLine ) const; + virtual short baselinePosition( bool firstLine ) const; + + virtual void setPixmap( const TQPixmap &, const TQRect&, CachedImage *); + + virtual void calcWidth(); + + virtual bool isListMarker() const { return true; } + + virtual short markerWidth() const { return m_markerWidth; } + + RenderListItem* listItem() const { return m_listItem; } + void setListItem(RenderListItem* listItem) { m_listItem = listItem; } + + bool listPositionInside() const + { return !m_listItem->m_insideList || style()->listStylePosition() == INSIDE; } + +protected: + friend class RenderListItem; + + TQString m_item; + CachedImage *m_listImage; + short m_markerWidth; + RenderListItem* m_listItem; +}; + +// Implementation of list-item counter +// ### should replace most list-item specific code in renderObject::getCounter +/* +class CounterListItem : public CounterNode +{ +public: + int count() const; + + virtual void recount( bool first = false ); + virtual void setSelfDirty(); + +}; */ + +} //namespace + +#endif diff --git a/tdehtml/rendering/render_object.cpp b/tdehtml/rendering/render_object.cpp new file mode 100644 index 000000000..a3eb1565e --- /dev/null +++ b/tdehtml/rendering/render_object.cpp @@ -0,0 +1,2330 @@ +/** + * This file is part of the html renderer for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * (C) 2002-2006 Apple Computer, Inc. + * (C) 2006 Germain Garand <germain@ebooksfrance.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "rendering/render_object.h" +#include "rendering/render_table.h" +#include "rendering/render_list.h" +#include "rendering/render_canvas.h" +#include "rendering/render_block.h" +#include "rendering/render_arena.h" +#include "rendering/render_layer.h" +#include "rendering/render_line.h" +#include "rendering/render_inline.h" +#include "rendering/render_text.h" +#include "rendering/render_replaced.h" +#include "rendering/render_generated.h" +#include "rendering/counter_tree.h" + +#include "xml/dom_elementimpl.h" +#include "xml/dom_docimpl.h" +#include "dom/dom_doc.h" +#include "misc/htmlhashes.h" +#include "misc/loader.h" + +#include <kdebug.h> +#include <kglobal.h> +#include <tqpainter.h> +#include "tdehtmlview.h" +#include <tdehtml_part.h> + +#include <assert.h> +using namespace DOM; +using namespace tdehtml; + +#define RED_LUMINOSITY 30 +#define GREEN_LUMINOSITY 59 +#define BLUE_LUMINOSITY 11 +#define INTENSITY_FACTOR 25 +#define LIGHT_FACTOR 0 +#define LUMINOSITY_FACTOR 75 + +#define MAX_COLOR 255 +#define COLOR_DARK_THRESHOLD 51 +#define COLOR_LIGHT_THRESHOLD 204 + +#define COLOR_LITE_BS_FACTOR 45 +#define COLOR_LITE_TS_FACTOR 70 + +#define COLOR_DARK_BS_FACTOR 30 +#define COLOR_DARK_TS_FACTOR 50 + +#define LIGHT_GRAY tqRgb(192, 192, 192) +#define DARK_GRAY tqRgb(96, 96, 96) + +#ifndef NDEBUG +static void *baseOfRenderObjectBeingDeleted; +#endif + +//#define MASK_DEBUG + +void* RenderObject::operator new(size_t sz, RenderArena* renderArena) throw() +{ + return renderArena->allocate(sz); +} + +void RenderObject::operator delete(void* ptr, size_t sz) +{ + assert(baseOfRenderObjectBeingDeleted == ptr); + + // Stash size where detach can find it. + *(size_t *)ptr = sz; +} + +RenderObject *RenderObject::createObject(DOM::NodeImpl* node, RenderStyle* style) +{ + RenderObject *o = 0; + tdehtml::RenderArena* arena = node->getDocument()->renderArena(); + switch(style->display()) + { + case NONE: + break; + case INLINE: + o = new (arena) RenderInline(node); + break; + case BLOCK: + o = new (arena) RenderBlock(node); + break; + case INLINE_BLOCK: + o = new (arena) RenderBlock(node); + break; + case LIST_ITEM: + o = new (arena) RenderListItem(node); + break; + case RUN_IN: + case COMPACT: + o = new (arena) RenderBlock(node); + break; + case TABLE: + case INLINE_TABLE: + style->setFlowAroundFloats(true); + o = new (arena) RenderTable(node); + break; + case TABLE_ROW_GROUP: + case TABLE_HEADER_GROUP: + case TABLE_FOOTER_GROUP: + o = new (arena) RenderTableSection(node); + break; + case TABLE_ROW: + o = new (arena) RenderTableRow(node); + break; + case TABLE_COLUMN_GROUP: + case TABLE_COLUMN: + o = new (arena) RenderTableCol(node); + break; + case TABLE_CELL: + o = new (arena) RenderTableCell(node); + break; + case TABLE_CAPTION: + o = new (arena) RenderBlock(node); + break; + } + return o; +} + + +RenderObject::RenderObject(DOM::NodeImpl* node) + : CachedObjectClient(), + m_style( 0 ), + m_node( node ), + m_parent( 0 ), + m_previous( 0 ), + m_next( 0 ), + m_verticalPosition( PositionUndefined ), + m_needsLayout( false ), + m_normalChildNeedsLayout( false ), + m_markedForRepaint( false ), + m_posChildNeedsLayout( false ), + m_minMaxKnown( false ), + m_floating( false ), + + m_positioned( false ), + m_overhangingContents( false ), + m_relPositioned( false ), + m_paintBackground( false ), + + m_isAnonymous( node->isDocumentNode() ), + m_recalcMinMax( false ), + m_isText( false ), + m_inline( true ), + m_attached( false ), + + m_replaced( false ), + m_mouseInside( false ), + m_hasFirstLine( false ), + m_isSelectionBorder( false ), + m_isRoot( false ), + m_afterPageBreak( false ), + m_needsPageClear( false ), + m_containsPageBreak( false ), + m_hasOverflowClip( false ), + m_doNotDelete( false ) +{ + assert( node ); + if (node->getDocument()->documentElement() == node) setIsRoot(true); +} + +RenderObject::~RenderObject() +{ + const BackgroundLayer* bgLayer = m_style->backgroundLayers(); + while (bgLayer) { + if(bgLayer->backgroundImage()) + bgLayer->backgroundImage()->deref(this); + bgLayer = bgLayer->next(); + } + + if (m_style) + m_style->deref(); +} + + + +RenderObject* RenderObject::objectBelow() const +{ + RenderObject* obj = firstChild(); + if ( !obj ) { + obj = nextSibling(); + if ( !obj ) + { + obj = parent(); + while (obj && !obj->nextSibling()) + obj = obj->parent(); + if (obj) + obj = obj->nextSibling(); + } + } + return obj; +} + +RenderObject* RenderObject::objectAbove() const +{ + RenderObject* obj = previousSibling(); + if ( !obj ) + return parent(); + + RenderObject* last = obj->lastChild(); + while ( last ) + { + obj = last; + last = last->lastChild(); + } + return obj; +} +/* +bool RenderObject::isRoot() const +{ + return !isAnonymous() && + element()->getDocument()->documentElement() == element(); +}*/ + +bool RenderObject::isHR() const +{ + return element() && element()->id() == ID_HR; +} + +bool RenderObject::isWordBreak() const +{ + return element() && element()->id() == ID_WBR; +} + +bool RenderObject::isHTMLMarquee() const +{ + return element() && element()->renderer() == this && element()->id() == ID_MARQUEE; +} + +void RenderObject::addChild(RenderObject* , RenderObject *) +{ + KHTMLAssert(0); +} + +RenderObject* RenderObject::removeChildNode(RenderObject* ) +{ + KHTMLAssert(0); + return 0; +} + +void RenderObject::removeChild(RenderObject *o ) +{ + setNeedsLayout(true); + removeChildNode( o ); +} + +void RenderObject::appendChildNode(RenderObject*) +{ + KHTMLAssert(0); +} + +void RenderObject::insertChildNode(RenderObject*, RenderObject*) +{ + KHTMLAssert(0); +} + +RenderObject *RenderObject::nextRenderer() const +{ + if (firstChild()) + return firstChild(); + else if (nextSibling()) + return nextSibling(); + else { + const RenderObject *r = this; + while (r && !r->nextSibling()) + r = r->parent(); + if (r) + return r->nextSibling(); + } + return 0; +} + +RenderObject *RenderObject::previousRenderer() const +{ + if (previousSibling()) { + RenderObject *r = previousSibling(); + while (r->lastChild()) + r = r->lastChild(); + return r; + } + else if (parent()) { + return parent(); + } + else { + return 0; + } +} + +static void addLayers(RenderObject* obj, RenderLayer* parentLayer, RenderObject*& newObject, + RenderLayer*& beforeChild) +{ + if (obj->layer()) { + if (!beforeChild && newObject) { + // We need to figure out the layer that follows newObject. We only do + // this the first time we find a child layer, and then we update the + // pointer values for newObject and beforeChild used by everyone else. + beforeChild = newObject->parent()->findNextLayer(parentLayer, newObject); + newObject = 0; + } + parentLayer->addChild(obj->layer(), beforeChild); + return; + } + + for (RenderObject* curr = obj->firstChild(); curr; curr = curr->nextSibling()) + addLayers(curr, parentLayer, newObject, beforeChild); +} + +void RenderObject::addLayers(RenderLayer* parentLayer, RenderObject* newObject) +{ + if (!parentLayer) + return; + + RenderObject* object = newObject; + RenderLayer* beforeChild = 0; + ::addLayers(this, parentLayer, object, beforeChild); +} + +void RenderObject::removeLayers(RenderLayer* parentLayer) +{ + if (!parentLayer) + return; + + if (layer()) { + parentLayer->removeChild(layer()); + return; + } + + for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) + curr->removeLayers(parentLayer); +} + +void RenderObject::moveLayers(RenderLayer* oldParent, RenderLayer* newParent) +{ + if (!newParent) + return; + + if (layer()) { + if (oldParent) + oldParent->removeChild(layer()); + newParent->addChild(layer()); + return; + } + + for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) + curr->moveLayers(oldParent, newParent); +} + +RenderLayer* RenderObject::findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint, + bool checkParent) +{ + // Error check the parent layer passed in. If it's null, we can't find anything. + if (!parentLayer) + return 0; + + // Step 1: If our layer is a child of the desired parent, then return our layer. + RenderLayer* ourLayer = layer(); + if (ourLayer && ourLayer->parent() == parentLayer) + return ourLayer; + + // Step 2: If we don't have a layer, or our layer is the desired parent, then descend + // into our siblings trying to find the next layer whose parent is the desired parent. + if (!ourLayer || ourLayer == parentLayer) { + for (RenderObject* curr = startPoint ? startPoint->nextSibling() : firstChild(); + curr; curr = curr->nextSibling()) { + RenderLayer* nextLayer = curr->findNextLayer(parentLayer, 0, false); + if (nextLayer) + return nextLayer; + } + } + + // Step 3: If our layer is the desired parent layer, then we're finished. We didn't + // find anything. + if (parentLayer == ourLayer) + return 0; + + // Step 4: If |checkParent| is set, climb up to our parent and check its siblings that + // follow us to see if we can locate a layer. + if (checkParent && parent()) + return parent()->findNextLayer(parentLayer, this, true); + + return 0; +} + +RenderLayer* RenderObject::enclosingLayer() const +{ + const RenderObject* curr = this; + while (curr) { + RenderLayer *layer = curr->layer(); + if (layer) + return layer; + curr = curr->parent(); + } + return 0; +} + +RenderLayer* RenderObject::enclosingStackingContext() const +{ + RenderLayer* l = enclosingLayer(); + while (l && !l->isStackingContext()) + l = l->parent(); + return l; +} + +int RenderObject::offsetLeft() const +{ + if ( isPositioned() ) + return xPos(); + + if ( isBody() && style()->htmlHacks() ) + return 0; + + int x = xPos(); + if (isRelPositioned()) { + int y = 0; + static_cast<const RenderBox*>(this)->relativePositionOffset(x, y); + } + + RenderObject* offsetPar = offsetParent(); + for( RenderObject* curr = parent(); + curr && curr != offsetPar; + curr = curr->parent() ) + x += curr->xPos(); + + if ( offsetPar && offsetPar->isBody() && style()->htmlHacks() ) + x += offsetPar->xPos(); + + return x; +} + +int RenderObject::offsetTop() const +{ + if ( isPositioned() ) + return yPos(); + + if ( isBody() && style()->htmlHacks() ) + return 0; + + int y = yPos(); + if (isRelPositioned()) { + int x = 0; + static_cast<const RenderBox*>(this)->relativePositionOffset(x, y); + } + RenderObject* offsetPar = offsetParent(); + for( RenderObject* curr = parent(); + curr && curr != offsetPar; + curr = curr->parent() ) + y += curr->yPos(); + + if ( offsetPar && offsetPar->isBody() && style()->htmlHacks() ) + y += offsetPar->yPos(); + + return y; +} + +RenderObject* RenderObject::offsetParent() const +{ + if (isBody()) + return 0; + + // can't really use containing blocks here (#113280) + bool skipTables = isPositioned() || isRelPositioned(); + bool strict = !style()->htmlHacks(); + RenderObject* curr = parent(); + while (curr && (!curr->element() || + (!curr->isPositioned() && !curr->isRelPositioned() && + !(strict && skipTables ? curr->isRoot() : curr->isBody())))) { + if (!skipTables && curr->element() && (curr->isTableCell() || curr->isTable())) + break; + curr = curr->parent(); + } + return curr; +} + +// IE extensions. +// clientWidth and clientHeight represent the interior of an object +short RenderObject::clientWidth() const +{ + return width() - borderLeft() - borderRight() - + (layer() ? layer()->verticalScrollbarWidth() : 0); +} + +int RenderObject::clientHeight() const +{ + return height() - borderTop() - borderBottom() - + (layer() ? layer()->horizontalScrollbarHeight() : 0); +} + +// scrollWidth/scrollHeight is the size including the overflow area +short RenderObject::scrollWidth() const +{ + return (hasOverflowClip() && layer()) ? layer()->scrollWidth() : overflowWidth() - overflowLeft(); +} + +int RenderObject::scrollHeight() const +{ + return (hasOverflowClip() && layer()) ? layer()->scrollHeight() : overflowHeight() - overflowTop(); +} + +bool RenderObject::hasStaticX() const +{ + return (style()->left().isVariable() && style()->right().isVariable()); +} + +bool RenderObject::hasStaticY() const +{ + return (style()->top().isVariable() && style()->bottom().isVariable()); +} + +void RenderObject::setPixmap(const TQPixmap&, const TQRect& /*r*/, CachedImage* image) +{ + //repaint bg when it finished loading + if(image && parent() && style() && style()->backgroundLayers()->containsImage(image)) { + isBody() ? canvas()->repaint() : repaint(); + } +} + +void RenderObject::setNeedsLayout(bool b, bool markParents) +{ + bool alreadyNeededLayout = m_needsLayout; + m_needsLayout = b; + if (b) { + if (!alreadyNeededLayout && markParents && m_parent) { + dirtyFormattingContext( false ); + markContainingBlocksForLayout(); + } + } + else { + m_posChildNeedsLayout = false; + m_normalChildNeedsLayout = false; + } +} + +void RenderObject::setChildNeedsLayout(bool b, bool markParents) +{ + bool alreadyNeededLayout = m_normalChildNeedsLayout; + m_normalChildNeedsLayout = b; + if (b) { + if (!alreadyNeededLayout && markParents) + markContainingBlocksForLayout(); + } + else { + m_posChildNeedsLayout = false; + m_normalChildNeedsLayout = false; + } +} + +void RenderObject::markContainingBlocksForLayout() +{ + RenderObject *o = container(); + RenderObject *last = this; + + while (o) { + if (!last->isText() && (last->style()->position() == FIXED || last->style()->position() == ABSOLUTE)) { + if (o->m_posChildNeedsLayout) + return; + o->m_posChildNeedsLayout = true; + } + else { + if (o->m_normalChildNeedsLayout) + return; + o->m_normalChildNeedsLayout = true; + } + + last = o; + o = o->container(); + } + + last->scheduleRelayout(); +} + +RenderBlock *RenderObject::containingBlock() const +{ + if(isTableCell()) + return static_cast<RenderBlock*>( parent()->parent()->parent() ); + if (isCanvas()) + return const_cast<RenderBlock*>( static_cast<const RenderBlock*>(this) ); + + RenderObject *o = parent(); + if(m_style->position() == FIXED) { + while ( o && !o->isCanvas() ) + o = o->parent(); + } + else if(m_style->position() == ABSOLUTE) { + while (o && + ( o->style()->position() == STATIC || ( o->isInline() && !o->isReplaced() ) ) && !o->isCanvas()) { + // for relpos inlines, return the nearest block - it will host the positioned objects list + if (o->isInline() && !o->isReplaced() && o->style()->position() == RELATIVE) + return o->containingBlock(); + o = o->parent(); + } + } else { + while(o && ( ( o->isInline() && !o->isReplaced() ) || o->isTableRow() || o->isTableSection() || + o->isTableCol() || o->isFrameSet() ) ) + o = o->parent(); + } + // this is just to make sure we return a valid element. + // the case below should never happen... + if(!o || !o->isRenderBlock()) { + if(!isCanvas()) { +#ifndef NDEBUG + kdDebug( 6040 ) << this << ": " << renderName() << "(RenderObject): No containingBlock!" << endl; + kdDebug( 6040 ) << kdBacktrace() << endl; + const RenderObject* p = this; + while (p->parent()) p = p->parent(); + p->printTree(); +#endif + } + return 0L; + } + + return static_cast<RenderBlock*>( o ); +} + +short RenderObject::containingBlockWidth() const +{ + // ### + return containingBlock()->contentWidth(); +} + +int RenderObject::containingBlockHeight() const +{ + // ### + return containingBlock()->contentHeight(); +} + +bool RenderObject::sizesToMaxWidth() const +{ + // Marquees in WinIE are like a mixture of blocks and inline-blocks. They size as though they're blocks, + // but they allow text to sit on the same line as the marquee. + if (isFloating() || isCompact() || + (isInlineBlockOrInlineTable() && !isHTMLMarquee()) || + (element() && (element()->id() == ID_BUTTON || element()->id() == ID_LEGEND))) + return true; + + // Children of a horizontal marquee do not fill the container by default. + // FIXME: Need to deal with MAUTO value properly. It could be vertical. + if (parent()->style()->overflowX() == OMARQUEE) { + EMarqueeDirection dir = parent()->style()->marqueeDirection(); + if (dir == MAUTO || dir == MFORWARD || dir == MBACKWARD || dir == MLEFT || dir == MRIGHT) + return true; + } + +#ifdef APPLE_CHANGES // ### what the heck is a flexbox? + // Flexible horizontal boxes lay out children at their maxwidths. Also vertical boxes + // that don't stretch their kids lay out their children at their maxwidths. + if (parent()->isFlexibleBox() && + (parent()->style()->boxOrient() == HORIZONTAL || parent()->style()->boxAlign() != BSTRETCH)) + return true; +#endif + + return false; +} + +// from Mozilla's nsCSSColorUtils.cpp +static int brightness(int red, int green, int blue) +{ + + int intensity = (red + green + blue) / 3; + + int luminosity = + ((RED_LUMINOSITY * red) / 100) + + ((GREEN_LUMINOSITY * green) / 100) + + ((BLUE_LUMINOSITY * blue) / 100); + + return ((intensity * INTENSITY_FACTOR) + + (luminosity * LUMINOSITY_FACTOR)) / 100; +} + +static void calc3DColor(TQColor &color, bool darken) +{ + int rb = color.red(); + int gb = color.green(); + int bb = color.blue(); + + int brightness_ = brightness(rb,gb,bb); + + int f0, f1; + if (brightness_ < COLOR_DARK_THRESHOLD) { + f0 = COLOR_DARK_BS_FACTOR; + f1 = COLOR_DARK_TS_FACTOR; + } else if (brightness_ > COLOR_LIGHT_THRESHOLD) { + f0 = COLOR_LITE_BS_FACTOR; + f1 = COLOR_LITE_TS_FACTOR; + } else { + f0 = COLOR_DARK_BS_FACTOR + + (brightness_ * + (COLOR_LITE_BS_FACTOR - COLOR_DARK_BS_FACTOR) / MAX_COLOR); + f1 = COLOR_DARK_TS_FACTOR + + (brightness_ * + (COLOR_LITE_TS_FACTOR - COLOR_DARK_TS_FACTOR) / MAX_COLOR); + } + + if (darken) { + int r = rb - (f0 * rb / 100); + int g = gb - (f0 * gb / 100); + int b = bb - (f0 * bb / 100); + if ((r == rb) && (g == gb) && (b == bb)) + color = (color == Qt::black) ? DARK_GRAY : Qt::black; + else + color.setRgb(r, g, b); + } else { + int r = kMin(rb + (f1 * (MAX_COLOR - rb) / 100), 255); + int g = kMin(gb + (f1 * (MAX_COLOR - gb) / 100), 255); + int b = kMin(bb + (f1 * (MAX_COLOR - bb) / 100), 255); + if ((r == rb) && (g == gb) && (b == bb)) + color = (color == Qt::white) ? LIGHT_GRAY : Qt::white; + else + color.setRgb(r, g, b); + } +} + +void RenderObject::drawBorder(TQPainter *p, int x1, int y1, int x2, int y2, + BorderSide s, TQColor c, const TQColor& textcolor, EBorderStyle style, + int adjbw1, int adjbw2, bool invalidisInvert) +{ + int width = (s==BSTop||s==BSBottom?y2-y1:x2-x1); + + if(style == DOUBLE && width < 3) + style = SOLID; + + if(!c.isValid()) { + if(invalidisInvert) + { + p->setRasterOp(TQt::XorROP); + c = Qt::white; + } + else { + if(style == INSET || style == OUTSET || style == RIDGE || style == + GROOVE) + c = Qt::white; + else + c = textcolor; + } + } + + switch(style) + { + case BNATIVE: + case BNONE: + case BHIDDEN: + // should not happen + if(invalidisInvert && p->rasterOp() == TQt::XorROP) + p->setRasterOp(TQt::CopyROP); + + return; + case DOTTED: + if ( width == 1 ) { + // workaround Qt brokenness + p->setPen(TQPen(c, width, Qt::SolidLine)); + switch(s) { + case BSBottom: + case BSTop: + for ( ; x1 < x2; x1 += 2 ) + p->drawPoint( x1, y1 ); + break; + case BSRight: + case BSLeft: + for ( ; y1 < y2; y1 += 2 ) + p->drawPoint( x1, y1 ); + } + break; + } + + p->setPen(TQPen(c, width, Qt::DotLine)); + /* nobreak; */ + case DASHED: + if(style == DASHED) + p->setPen(TQPen(c, width == 1 ? 0 : width, width == 1 ? Qt::DotLine : Qt::DashLine)); + + if (width > 0) + switch(s) { + case BSBottom: + case BSTop: + p->drawLine(x1, (y1+y2)/2, x2, (y1+y2)/2); + break; + case BSRight: + case BSLeft: + p->drawLine((x1+x2)/2, y1, (x1+x2)/2, y2); + break; + } + + break; + case DOUBLE: + { + int third = (width+1)/3; + + if (adjbw1 == 0 && adjbw2 == 0) + { + p->setPen(Qt::NoPen); + p->setBrush(c); + switch(s) + { + case BSTop: + case BSBottom: + p->drawRect(x1, y1 , x2-x1, third); + p->drawRect(x1, y2-third, x2-x1, third); + break; + case BSLeft: + p->drawRect(x1 , y1+1, third, y2-y1-1); + p->drawRect(x2-third, y1+1, third, y2-y1-1); + break; + case BSRight: + p->drawRect(x1 , y1+1, third, y2-y1-1); + p->drawRect(x2-third, y1+1, third, y2-y1-1); + break; + } + } + else + { + int adjbw1bigthird; + if (adjbw1>0) adjbw1bigthird = adjbw1+1; + else adjbw1bigthird = adjbw1 - 1; + adjbw1bigthird /= 3; + + int adjbw2bigthird; + if (adjbw2>0) adjbw2bigthird = adjbw2 + 1; + else adjbw2bigthird = adjbw2 - 1; + adjbw2bigthird /= 3; + + switch(s) + { + case BSTop: + drawBorder(p, x1+kMax((-adjbw1*2+1)/3,0), y1 , x2-kMax((-adjbw2*2+1)/3,0), y1 + third, s, c, textcolor, SOLID, adjbw1bigthird, adjbw2bigthird); + drawBorder(p, x1+kMax(( adjbw1*2+1)/3,0), y2 - third, x2-kMax(( adjbw2*2+1)/3,0), y2 , s, c, textcolor, SOLID, adjbw1bigthird, adjbw2bigthird); + break; + case BSLeft: + drawBorder(p, x1 , y1+kMax((-adjbw1*2+1)/3,0), x1+third, y2-kMax((-adjbw2*2+1)/3,0), s, c, textcolor, SOLID, adjbw1bigthird, adjbw2bigthird); + drawBorder(p, x2 - third, y1+kMax(( adjbw1*2+1)/3,0), x2 , y2-kMax(( adjbw2*2+1)/3,0), s, c, textcolor, SOLID, adjbw1bigthird, adjbw2bigthird); + break; + case BSBottom: + drawBorder(p, x1+kMax(( adjbw1*2+1)/3,0), y1 , x2-kMax(( adjbw2*2+1)/3,0), y1+third, s, c, textcolor, SOLID, adjbw1bigthird, adjbw2bigthird); + drawBorder(p, x1+kMax((-adjbw1*2+1)/3,0), y2-third, x2-kMax((-adjbw2*2+1)/3,0), y2 , s, c, textcolor, SOLID, adjbw1bigthird, adjbw2bigthird); + break; + case BSRight: + drawBorder(p, x1 , y1+kMax(( adjbw1*2+1)/3,0), x1+third, y2-kMax(( adjbw2*2+1)/3,0), s, c, textcolor, SOLID, adjbw1bigthird, adjbw2bigthird); + drawBorder(p, x2-third, y1+kMax((-adjbw1*2+1)/3,0), x2 , y2-kMax((-adjbw2*2+1)/3,0), s, c, textcolor, SOLID, adjbw1bigthird, adjbw2bigthird); + break; + default: + break; + } + } + break; + } + case RIDGE: + case GROOVE: + { + EBorderStyle s1; + EBorderStyle s2; + if (style==GROOVE) + { + s1 = INSET; + s2 = OUTSET; + } + else + { + s1 = OUTSET; + s2 = INSET; + } + + int adjbw1bighalf; + int adjbw2bighalf; + if (adjbw1>0) adjbw1bighalf=adjbw1+1; + else adjbw1bighalf=adjbw1-1; + adjbw1bighalf/=2; + + if (adjbw2>0) adjbw2bighalf=adjbw2+1; + else adjbw2bighalf=adjbw2-1; + adjbw2bighalf/=2; + + switch (s) + { + case BSTop: + drawBorder(p, x1+kMax(-adjbw1 ,0)/2, y1 , x2-kMax(-adjbw2,0)/2, (y1+y2+1)/2, s, c, textcolor, s1, adjbw1bighalf, adjbw2bighalf); + drawBorder(p, x1+kMax( adjbw1+1,0)/2, (y1+y2+1)/2, x2-kMax( adjbw2+1,0)/2, y2 , s, c, textcolor, s2, adjbw1/2, adjbw2/2); + break; + case BSLeft: + drawBorder(p, x1 , y1+kMax(-adjbw1 ,0)/2, (x1+x2+1)/2, y2-kMax(-adjbw2,0)/2, s, c, textcolor, s1, adjbw1bighalf, adjbw2bighalf); + drawBorder(p, (x1+x2+1)/2, y1+kMax( adjbw1+1,0)/2, x2 , y2-kMax( adjbw2+1,0)/2, s, c, textcolor, s2, adjbw1/2, adjbw2/2); + break; + case BSBottom: + drawBorder(p, x1+kMax( adjbw1 ,0)/2, y1 , x2-kMax( adjbw2,0)/2, (y1+y2+1)/2, s, c, textcolor, s2, adjbw1bighalf, adjbw2bighalf); + drawBorder(p, x1+kMax(-adjbw1+1,0)/2, (y1+y2+1)/2, x2-kMax(-adjbw2+1,0)/2, y2 , s, c, textcolor, s1, adjbw1/2, adjbw2/2); + break; + case BSRight: + drawBorder(p, x1 , y1+kMax( adjbw1 ,0)/2, (x1+x2+1)/2, y2-kMax( adjbw2,0)/2, s, c, textcolor, s2, adjbw1bighalf, adjbw2bighalf); + drawBorder(p, (x1+x2+1)/2, y1+kMax(-adjbw1+1,0)/2, x2 , y2-kMax(-adjbw2+1,0)/2, s, c, textcolor, s1, adjbw1/2, adjbw2/2); + break; + } + break; + } + case INSET: + case OUTSET: + calc3DColor(c, (style == OUTSET && (s == BSBottom || s == BSRight)) || + (style == INSET && ( s == BSTop || s == BSLeft ) ) ); + /* nobreak; */ + case SOLID: + p->setPen(Qt::NoPen); + p->setBrush(c); + Q_ASSERT(x2>=x1); + Q_ASSERT(y2>=y1); + if (adjbw1==0 && adjbw2 == 0) { + p->drawRect(x1,y1,x2-x1,y2-y1); + return; + } + TQPointArray quad(4); + switch(s) { + case BSTop: + quad.setPoints(4, + x1+kMax(-adjbw1,0), y1, + x1+kMax( adjbw1,0), y2, + x2-kMax( adjbw2,0), y2, + x2-kMax(-adjbw2,0), y1); + break; + case BSBottom: + quad.setPoints(4, + x1+kMax( adjbw1,0), y1, + x1+kMax(-adjbw1,0), y2, + x2-kMax(-adjbw2,0), y2, + x2-kMax( adjbw2,0), y1); + break; + case BSLeft: + quad.setPoints(4, + x1, y1+kMax(-adjbw1,0), + x1, y2-kMax(-adjbw2,0), + x2, y2-kMax( adjbw2,0), + x2, y1+kMax( adjbw1,0)); + break; + case BSRight: + quad.setPoints(4, + x1, y1+kMax( adjbw1,0), + x1, y2-kMax( adjbw2,0), + x2, y2-kMax(-adjbw2,0), + x2, y1+kMax(-adjbw1,0)); + break; + } + p->drawConvexPolygon(quad); + break; + } + + if(invalidisInvert && p->rasterOp() == TQt::XorROP) + p->setRasterOp(TQt::CopyROP); +} + +void RenderObject::paintBorder(TQPainter *p, int _tx, int _ty, int w, int h, const RenderStyle* style, bool begin, bool end) +{ + const TQColor& tc = style->borderTopColor(); + const TQColor& bc = style->borderBottomColor(); + const TQColor& lc = style->borderLeftColor(); + const TQColor& rc = style->borderRightColor(); + + bool tt = style->borderTopIsTransparent(); + bool bt = style->borderBottomIsTransparent(); + bool rt = style->borderRightIsTransparent(); + bool lt = style->borderLeftIsTransparent(); + + EBorderStyle ts = style->borderTopStyle(); + EBorderStyle bs = style->borderBottomStyle(); + EBorderStyle ls = style->borderLeftStyle(); + EBorderStyle rs = style->borderRightStyle(); + + bool render_t = ts > BHIDDEN && !tt; + bool render_l = ls > BHIDDEN && begin && !lt; + bool render_r = rs > BHIDDEN && end && !rt; + bool render_b = bs > BHIDDEN && !bt; + + if(render_t) { + bool ignore_left = + (tc == lc) && (tt == lt) && + (ts >= OUTSET) && + (ls == DOTTED || ls == DASHED || ls == SOLID || ls == OUTSET); + + bool ignore_right = + (tc == rc) && (tt == rt) && + (ts >= OUTSET) && + (rs == DOTTED || rs == DASHED || rs == SOLID || rs == INSET); + + drawBorder(p, _tx, _ty, _tx + w, _ty + style->borderTopWidth(), BSTop, tc, style->color(), ts, + ignore_left?0:style->borderLeftWidth(), + ignore_right?0:style->borderRightWidth()); + } + + if(render_b) { + bool ignore_left = + (bc == lc) && (bt == lt) && + (bs >= OUTSET) && + (ls == DOTTED || ls == DASHED || ls == SOLID || ls == OUTSET); + + bool ignore_right = + (bc == rc) && (bt == rt) && + (bs >= OUTSET) && + (rs == DOTTED || rs == DASHED || rs == SOLID || rs == INSET); + + drawBorder(p, _tx, _ty + h - style->borderBottomWidth(), _tx + w, _ty + h, BSBottom, bc, style->color(), bs, + ignore_left?0:style->borderLeftWidth(), + ignore_right?0:style->borderRightWidth()); + } + + if(render_l) + { + bool ignore_top = + (tc == lc) && (tt == lt) && + (ls >= OUTSET) && + (ts == DOTTED || ts == DASHED || ts == SOLID || ts == OUTSET); + + bool ignore_bottom = + (bc == lc) && (bt == lt) && + (ls >= OUTSET) && + (bs == DOTTED || bs == DASHED || bs == SOLID || bs == INSET); + + drawBorder(p, _tx, _ty, _tx + style->borderLeftWidth(), _ty + h, BSLeft, lc, style->color(), ls, + ignore_top?0:style->borderTopWidth(), + ignore_bottom?0:style->borderBottomWidth()); + } + + if(render_r) + { + bool ignore_top = + (tc == rc) && (tt == rt) && + (rs >= DOTTED || rs == INSET) && + (ts == DOTTED || ts == DASHED || ts == SOLID || ts == OUTSET); + + bool ignore_bottom = + (bc == rc) && (bt == rt) && + (rs >= DOTTED || rs == INSET) && + (bs == DOTTED || bs == DASHED || bs == SOLID || bs == INSET); + + drawBorder(p, _tx + w - style->borderRightWidth(), _ty, _tx + w, _ty + h, BSRight, rc, style->color(), rs, + ignore_top?0:style->borderTopWidth(), + ignore_bottom?0:style->borderBottomWidth()); + } +} + +void RenderObject::paintOutline(TQPainter *p, int _tx, int _ty, int w, int h, const RenderStyle* style) +{ + int ow = style->outlineWidth(); + if(!ow) return; + + const TQColor& oc = style->outlineColor(); + EBorderStyle os = style->outlineStyle(); + int offset = style->outlineOffset(); + +#ifdef APPLE_CHANGES + if (style->outlineStyleIsAuto()) { + p->initFocusRing(ow, offset, oc); + addFocusRingRects(p, _tx, _ty); + p->drawFocusRing(); + p->clearFocusRing(); + return; + } +#endif + + _tx -= offset; + _ty -= offset; + w += 2*offset; + h += 2*offset; + + drawBorder(p, _tx-ow, _ty-ow, _tx, _ty+h+ow, BSLeft, + TQColor(oc), style->color(), + os, ow, ow, true); + + drawBorder(p, _tx-ow, _ty-ow, _tx+w+ow, _ty, BSTop, + TQColor(oc), style->color(), + os, ow, ow, true); + + drawBorder(p, _tx+w, _ty-ow, _tx+w+ow, _ty+h+ow, BSRight, + TQColor(oc), style->color(), + os, ow, ow, true); + + drawBorder(p, _tx-ow, _ty+h, _tx+w+ow, _ty+h+ow, BSBottom, + TQColor(oc), style->color(), + os, ow, ow, true); + +} + +void RenderObject::paint( PaintInfo&, int /*tx*/, int /*ty*/) +{ +} + +void RenderObject::repaintRectangle(int x, int y, int w, int h, Priority p, bool f) +{ + if(parent()) parent()->repaintRectangle(x, y, w, h, p, f); +} + +#ifdef ENABLE_DUMP + +TQString RenderObject::information() const +{ + TQString str; + int x; int y; + absolutePosition(x,y); + x += inlineXPos(); + y += inlineYPos(); + TQTextStream ts( &str, IO_WriteOnly ); + ts << renderName() + << "(" << (style() ? style()->refCount() : 0) << ")" + << ": " << (void*)this << " "; + ts << "{" << x << " " << y << "} "; + if (isInline()) ts << "il "; + if (childrenInline()) ts << "ci "; + if (isFloating()) ts << "fl "; + if (isAnonymous()) ts << "an "; + if (isRelPositioned()) ts << "rp "; + if (isPositioned()) ts << "ps "; + if (isReplaced()) ts << "rp "; + if (overhangingContents()) ts << "oc "; + if (needsLayout()) ts << "nl "; + if (minMaxKnown()) ts << "mmk "; + if (m_recalcMinMax) ts << "rmm "; + if (mouseInside()) ts << "mi "; + if (style() && style()->zIndex()) ts << "zI: " << style()->zIndex(); + if (style() && style()->hasAutoZIndex()) ts << "zI: auto "; + if (element()) { + if (element()->active()) ts << "act "; + if (element()->hasAnchor()) ts << "anchor "; + if (element()->focused()) ts << "focus "; + ts << " <" << getTagName(element()->id()) << ">"; + + } else if (isPseudoAnonymous() && style() && style()->styleType() != RenderStyle::NOPSEUDO) { + ts << " <" << getTagName(node()->id()); + TQString pseudo; + switch (style()->styleType()) { + case RenderStyle::FIRST_LETTER: + pseudo = ":first-letter"; break; + case RenderStyle::BEFORE: + pseudo = ":before"; break; + case RenderStyle::AFTER: + pseudo = ":after"; break; + default: + pseudo = ":pseudo-element"; + } + ts << pseudo; + ts << ">"; + } + ts << " (" << xPos() << "," << yPos() << "," << width() << "," << height() << ")" + << " [" << minWidth() << "-" << maxWidth() << "]" + << " { mT: " << marginTop() << " qT: " << isTopMarginQuirk() + << " mB: " << marginBottom() << " qB: " << isBottomMarginQuirk() + << "}" + << (isTableCell() ? + ( TQString::fromLatin1(" [r=") + + TQString::number( static_cast<const RenderTableCell *>(this)->row() ) + + TQString::fromLatin1(" c=") + + TQString::number( static_cast<const RenderTableCell *>(this)->col() ) + + TQString::fromLatin1(" rs=") + + TQString::number( static_cast<const RenderTableCell *>(this)->rowSpan() ) + + TQString::fromLatin1(" cs=") + + TQString::number( static_cast<const RenderTableCell *>(this)->colSpan() ) + + TQString::fromLatin1("]") ) : TQString::null ); + if ( layer() ) + ts << " layer=" << layer(); + if ( continuation() ) + ts << " continuation=" << continuation(); + if (isText()) + ts << " \"" << TQConstString(static_cast<const RenderText *>(this)->text(), kMin(static_cast<const RenderText *>(this)->length(), 10u)).string() << "\""; + return str; +} + +void RenderObject::printTree(int indent) const +{ + TQString ind; + ind.fill(' ', indent); + + kdDebug() << ind << information() << endl; + + RenderObject *child = firstChild(); + while( child != 0 ) + { + child->printTree(indent+2); + child = child->nextSibling(); + } +} + +static TQTextStream &operator<<(TQTextStream &ts, const TQRect &r) +{ + return ts << "at (" << r.x() << "," << r.y() << ") size " << r.width() << "x" << r.height(); +} + +//A bit like getTagName, but handles XML, too. +static TQString lookupTagName(NodeImpl* node) { + return node->getDocument()->getName(NodeImpl::ElementId, node->id()).string(); +} + +void RenderObject::dump(TQTextStream &ts, const TQString &ind) const +{ + if ( !layer() ) + ts << endl; + + ts << ind << renderName(); + + if (style() && style()->zIndex()) { + ts << " zI: " << style()->zIndex(); + } + + if (element()) { + TQString tagName(lookupTagName(element())); + if (!tagName.isEmpty()) { + ts << " {" << tagName << "}"; + } + } else if (isPseudoAnonymous() && style() && style()->styleType() != RenderStyle::NOPSEUDO) { + TQString pseudo; + TQString tagName(lookupTagName(node())); + switch (style()->styleType()) { + case RenderStyle::FIRST_LETTER: + pseudo = ":first-letter"; break; + case RenderStyle::BEFORE: + pseudo = ":before"; break; + case RenderStyle::AFTER: + pseudo = ":after"; break; + default: + pseudo = ":pseudo-element"; + } + ts << " {" << tagName << pseudo << "}"; + } + + TQRect r(xPos(), yPos(), width(), height()); + ts << " " << r; + + if ( parent() ) + ts << style()->createDiff( *parent()->style() ); + + if (isAnonymous()) { ts << " anonymousBox"; } + if (isFloating()) { ts << " floating"; } + if (isPositioned()) { ts << " positioned"; } + if (isRelPositioned()) { ts << " relPositioned"; } + if (isText()) { ts << " text"; } + if (isInline()) { ts << " inline"; } + if (isReplaced()) { ts << " replaced"; } + if (shouldPaintBackgroundOrBorder()) { ts << " paintBackground"; } + if (needsLayout()) { ts << " needsLayout"; } + if (minMaxKnown()) { ts << " minMaxKnown"; } + if (overhangingContents()) { ts << " overhangingContents"; } + if (hasFirstLine()) { ts << " hasFirstLine"; } + if (afterPageBreak()) { ts << " afterPageBreak"; } +} +#endif + +void RenderObject::selectionStartEnd(int& spos, int& epos) +{ + if (parent()) + parent()->selectionStartEnd(spos, epos); +} + +void RenderObject::setStyle(RenderStyle *style) +{ + if (m_style == style) + return; + + RenderStyle::Diff d = m_style ? m_style->diff( style ) : RenderStyle::Layout; + //tqDebug("m_style: %p new style, diff=%d", m_style, d); + + Priority pri = NormalPriority; + if (m_style) { + pri = HighPriority; + if ( d >= RenderStyle::Visible && !isText() && m_parent && + ( d == RenderStyle::Position || + m_style->outlineWidth() > style->outlineWidth() || + (!m_style->hidesOverflow() && style->hidesOverflow()) || + ( m_style->hasClip() && !(m_style->clip() == style->clip()) ) ) ) { + // schedule a repaint with the old style + if (layer() && !isInlineFlow()) + layer()->repaint(pri); + else + repaint(pri); + } + + if ( ( isFloating() && m_style->floating() != style->floating() ) || + ( isPositioned() && m_style->position() != style->position() && + style->position() != ABSOLUTE && style->position() != FIXED ) ) + removeFromObjectLists(); + + if ( layer() ) { + if ( ( m_style->hasAutoZIndex() != style->hasAutoZIndex() || + m_style->zIndex() != style->zIndex() || + m_style->visibility() != style->visibility() ) ) { + layer()->stackingContext()->dirtyZOrderLists(); + layer()->dirtyZOrderLists(); + } + } + + // reset style flags + m_floating = false; + m_positioned = false; + m_relPositioned = false; + m_paintBackground = false; + m_hasOverflowClip = false; + } + + // only honour z-index for non-static objects + // ### and objects with opacity + if ( style->position() == STATIC ) { + if ( isRoot() ) + style->setZIndex( 0 ); + else + style->setHasAutoZIndex(); + } + + RenderStyle *oldStyle = m_style; + m_style = style; + + updateBackgroundImages(oldStyle); + + m_style->ref(); + + if (oldStyle) + oldStyle->deref(); + + setShouldPaintBackgroundOrBorder(m_style->hasBorder() || m_style->hasBackground()); + + m_hasFirstLine = (style->getPseudoStyle(RenderStyle::FIRST_LINE) != 0); + if (m_parent) { + if (d == RenderStyle::Position && !attemptDirectLayerTranslation()) + d = RenderStyle::Layout; + + if ( d > RenderStyle::Position) { + // we must perform a full layout + if (!isText() && d == RenderStyle::CbLayout) { + dirtyFormattingContext( true ); + } + setNeedsLayoutAndMinMaxRecalc(); + } else if (!isText() && d >= RenderStyle::Visible) { + // a repaint is enough + if (layer()) { + if (canvas() && canvas()->needsWidgetMasks()) { + // update our widget masks + RenderLayer *p, *d = 0; + for (p=layer()->parent();p;p=p->parent()) + if (p->hasOverlaidWidgets()) d=p; + if (d) // deepest + d->updateWidgetMasks( canvas()->layer() ); + } + } + if (layer() && !isInlineFlow()) + layer()->repaint(pri); + else + repaint(pri); + } + } +} + +bool RenderObject::attemptDirectLayerTranslation() +{ + // When the difference between two successive styles is only 'Position' + // we may attempt to save a layout by directly updating the object position. + + KHTMLAssert( m_style->position() != STATIC ); + if (!layer()) + return false; + setInline(m_style->isDisplayInlineType()); + setPositioned(m_style->position() != RELATIVE); + setRelPositioned(m_style->position() == RELATIVE); + int oldXPos = xPos(); + int oldYPos = yPos(); + int oldWidth = width(); + int oldHeight = height(); + calcWidth(); + calcHeight(); + if (oldWidth != width() || oldHeight != height()) { + // implicit size change or overconstrained dimensions: + // we'll need a layout. + setWidth(oldWidth); + setHeight(oldHeight); + // kdDebug() << "Layer translation failed for " << information() << endl; + return false; + } + layer()->updateLayerPosition(); + if (m_style->position() != FIXED) { + bool needsDocSizeUpdate = true; + RenderObject *cb = container(); + while (cb) { + if (cb->hasOverflowClip() && cb->layer()) { + cb->layer()->checkScrollbarsAfterLayout(); + needsDocSizeUpdate = false; + break; + } + cb = cb->container(); + } + if (needsDocSizeUpdate && canvas()) { + bool posXOffset = (xPos()-oldXPos >= 0); + bool posYOffset = (yPos()-oldYPos >= 0); + canvas()->updateDocSizeAfterLayerTranslation(this, posXOffset, posYOffset); + } + } + // success + return true; +} + +void RenderObject::dirtyFormattingContext( bool checkContainer ) +{ + if (m_markedForRepaint && !checkContainer) + return; + m_markedForRepaint = true; + if (layer() && (style()->position() == FIXED || style()->position() == ABSOLUTE)) + return; + if (m_parent && (checkContainer || style()->width().isVariable() || style()->height().isVariable() || + !(isFloating() || flowAroundFloats() || isTableCell()))) + m_parent->dirtyFormattingContext(false); +} + +void RenderObject::repaintDuringLayout() +{ + if (canvas()->needsFullRepaint() || isText()) + return; + if (layer() && !isInlineFlow()) { + layer()->repaint( NormalPriority, true ); + } else { + repaint(); + canvas()->deferredRepaint( this ); + } +} + +void RenderObject::setOverhangingContents(bool p) +{ + if (m_overhangingContents == p) + return; + + RenderBlock *cb = containingBlock(); + if (p) + { + m_overhangingContents = true; + KHTMLAssert( cb != this || isCanvas()); + if (cb && cb != this) + cb->setOverhangingContents(); + } + else + { + RenderObject *n; + bool c=false; + + for( n = firstChild(); n != 0; n = n->nextSibling() ) + { + if (n->isPositioned() || n->overhangingContents()) + c=true; + } + + if (c) + return; + else + { + m_overhangingContents = false; + KHTMLAssert( cb != this ); + if (cb && cb != this) + cb->setOverhangingContents(false); + } + } +} + +void RenderObject::updateBackgroundImages(RenderStyle* oldStyle) +{ + // FIXME: This will be slow when a large number of images is used. Fix by using a dict. + const BackgroundLayer* oldLayers = oldStyle ? oldStyle->backgroundLayers() : 0; + const BackgroundLayer* newLayers = m_style ? m_style->backgroundLayers() : 0; + for (const BackgroundLayer* currOld = oldLayers; currOld; currOld = currOld->next()) { + if (currOld->backgroundImage() && (!newLayers || !newLayers->containsImage(currOld->backgroundImage()))) + currOld->backgroundImage()->deref(this); + } + for (const BackgroundLayer* currNew = newLayers; currNew; currNew = currNew->next()) { + if (currNew->backgroundImage() && (!oldLayers || !oldLayers->containsImage(currNew->backgroundImage()))) + currNew->backgroundImage()->ref(this); + } +} + +TQRect RenderObject::viewRect() const +{ + return containingBlock()->viewRect(); +} + +bool RenderObject::absolutePosition(int &xPos, int &yPos, bool f) const +{ + RenderObject* p = parent(); + if (p) { + p->absolutePosition(xPos, yPos, f); + if ( p->hasOverflowClip() ) + p->layer()->subtractScrollOffset( xPos, yPos ); + return true; + } + else + { + xPos = yPos = 0; + return false; + } +} + +void RenderObject::caretPos(int /*offset*/, int /*flags*/, int &_x, int &_y, int &width, int &height) +{ + _x = _y = height = -1; + width = 1; // the caret has a default width of one pixel. If you want + // to check for validity, only test the x-coordinate for >= 0. +} + +int RenderObject::paddingTop() const +{ + int w = 0; + Length padding = m_style->paddingTop(); + if (padding.isPercent()) + w = containingBlock()->contentWidth(); + w = padding.minWidth(w); + if ( isTableCell() && padding.isVariable() ) + w = static_cast<const RenderTableCell *>(this)->table()->cellPadding(); + return w; +} + +int RenderObject::paddingBottom() const +{ + int w = 0; + Length padding = style()->paddingBottom(); + if (padding.isPercent()) + w = containingBlock()->contentWidth(); + w = padding.minWidth(w); + if ( isTableCell() && padding.isVariable() ) + w = static_cast<const RenderTableCell *>(this)->table()->cellPadding(); + return w; +} + +int RenderObject::paddingLeft() const +{ + int w = 0; + Length padding = style()->paddingLeft(); + if (padding.isPercent()) + w = containingBlock()->contentWidth(); + w = padding.minWidth(w); + if ( isTableCell() && padding.isVariable() ) + w = static_cast<const RenderTableCell *>(this)->table()->cellPadding(); + return w; +} + +int RenderObject::paddingRight() const +{ + int w = 0; + Length padding = style()->paddingRight(); + if (padding.isPercent()) + w = containingBlock()->contentWidth(); + w = padding.minWidth(w); + if ( isTableCell() && padding.isVariable() ) + w = static_cast<const RenderTableCell *>(this)->table()->cellPadding(); + return w; +} + +RenderObject *RenderObject::container() const +{ + // This method is extremely similar to containingBlock(), but with a few notable + // exceptions. + // (1) It can be used on orphaned subtrees, i.e., it can be called safely even when + // the object is not part of the primary document subtree yet. + // (2) For normal flow elements, it just returns the parent. + // (3) For absolute positioned elements, it will return a relative positioned inline. + // containingBlock() simply skips relpositioned inlines and lets an enclosing block handle + // the layout of the positioned object. This does mean that calcAbsoluteHorizontal and + // calcAbsoluteVertical have to use container(). + EPosition pos = m_style->position(); + RenderObject *o = 0; + if( pos == FIXED ) { + // container() can be called on an object that is not in the + // tree yet. We don't call canvas() since it will assert if it + // can't get back to the canvas. Instead we just walk as high up + // as we can. If we're in the tree, we'll get the root. If we + // aren't we'll get the root of our little subtree (most likely + // we'll just return 0). + o = parent(); + while ( o && o->parent() ) o = o->parent(); + } + else if ( pos == ABSOLUTE ) { + // Same goes here. We technically just want our containing block, but + // we may not have one if we're part of an uninstalled subtree. We'll + // climb as high as we can though. + o = parent(); + while (o && o->style()->position() == STATIC && !o->isCanvas()) + o = o->parent(); + } + else + o = parent(); + return o; +} + +DOM::DocumentImpl* RenderObject::document() const +{ + return m_node->getDocument(); +} + +void RenderObject::remove() +{ + if ( parent() ) + //have parent, take care of the tree integrity + parent()->removeChild(this); +} + +void RenderObject::removeFromObjectLists() +{ + // in destruction mode, don't care. + if ( !document()->renderer() ) return; + + if (isFloating()) { + RenderBlock* outermostBlock = containingBlock(); + for (RenderBlock* p = outermostBlock; p && !p->isCanvas() && p->containsFloat(this);) { + outermostBlock = p; + if (p->isFloatingOrPositioned()) + break; + p = p->containingBlock(); + } + + if (outermostBlock) + outermostBlock->markAllDescendantsWithFloatsForLayout(this); + } + + if (isPositioned()) { + RenderObject *p; + for (p = parent(); p; p = p->parent()) { + if (p->isRenderBlock()) + static_cast<RenderBlock*>(p)->removePositionedObject(this); + } + } +} + +RenderArena* RenderObject::renderArena() const +{ + return m_node->getDocument()->renderArena(); +} + +void RenderObject::detach() +{ + detachCounters(); + + deleteInlineBoxes(); + remove(); + + // make sure our DOM-node don't think we exist + if ( node() && node()->renderer() == this) + node()->setRenderer(0); + + // by default no refcounting + arenaDelete(renderArena(), this); +} + +void RenderObject::arenaDelete(RenderArena *arena, void *base) +{ +#ifndef NDEBUG + void *savedBase = baseOfRenderObjectBeingDeleted; + baseOfRenderObjectBeingDeleted = base; +#endif + delete this; +#ifndef NDEBUG + baseOfRenderObjectBeingDeleted = savedBase; +#endif + + // Recover the size left there for us by operator delete and free the memory. + arena->free(*(size_t *)base, base); +} + +void RenderObject::arenaDelete(RenderArena *arena) +{ + // static_cast unfortunately doesn't work, since we multiple inherit + // in eg. RenderWidget. + arenaDelete(arena, dynamic_cast<void *>(this)); +} + +FindSelectionResult RenderObject::checkSelectionPoint( int _x, int _y, int _tx, int _ty, DOM::NodeImpl*& node, int & offset, SelPointState &state ) +{ +#if 0 + NodeInfo info(true, false); + if ( nodeAtPoint( info, _x, _y, _tx, _ty ) && info.innerNode() ) + { + RenderObject* r = info.innerNode()->renderer(); + if ( r ) { + if ( r == this ) { + node = info.innerNode(); + offset = 0; // we have no text... + return SelectionPointInside; + } + else + return r->checkSelectionPoint( _x, _y, _tx, _ty, node, offset, state ); + } + } + //kdDebug(6030) << "nodeAtPoint Failed. Fallback - hmm, SelectionPointAfter" << endl; + node = 0; + offset = 0; + return SelectionPointAfter; +#endif + int off = offset; + DOM::NodeImpl* nod = node; + + for (RenderObject *child = firstChild(); child; child=child->nextSibling()) { + // ignore empty text boxes, they produce totally bogus information + // for caret navigation (LS) + if (child->isText() && !static_cast<RenderText *>(child)->inlineTextBoxCount()) + continue; + +// kdDebug(6040) << "iterating " << (child ? child->renderName() : "") << "@" << child << (child->isText() ? " contains: \"" + TQConstString(static_cast<RenderText *>(child)->text(), kMin(static_cast<RenderText *>(child)->length(), 10u)).string() + "\"" : TQString::null) << endl; +// kdDebug(6040) << "---------- checkSelectionPoint recursive -----------" << endl; + tdehtml::FindSelectionResult pos = child->checkSelectionPoint(_x, _y, _tx+xPos(), _ty+yPos(), nod, off, state); +// kdDebug(6040) << "-------- end checkSelectionPoint recursive ---------" << endl; +// kdDebug(6030) << this << " child->findSelectionNode returned result=" << pos << " nod=" << nod << " off=" << off << endl; + switch(pos) { + case SelectionPointBeforeInLine: + case SelectionPointInside: + //kdDebug(6030) << "RenderObject::checkSelectionPoint " << this << " returning SelectionPointInside offset=" << offset << endl; + node = nod; + offset = off; + return SelectionPointInside; + case SelectionPointBefore: + //x,y is before this element -> stop here + if ( state.m_lastNode ) { + node = state.m_lastNode; + offset = state.m_lastOffset; + //kdDebug(6030) << "RenderObject::checkSelectionPoint " << this << " before this child " + // << node << "-> returning SelectionPointInside, offset=" << offset << endl; + return SelectionPointInside; + } else { + node = nod; + offset = off; + //kdDebug(6030) << "RenderObject::checkSelectionPoint " << this << " before us -> returning SelectionPointBefore " << node << "/" << offset << endl; + return SelectionPointBefore; + } + break; + case SelectionPointAfter: + if (state.m_afterInLine) break; + // fall through + case SelectionPointAfterInLine: + if (pos == SelectionPointAfterInLine) state.m_afterInLine = true; + //kdDebug(6030) << "RenderObject::checkSelectionPoint: selection after: " << nod << " offset: " << off << " afterInLine: " << state.m_afterInLine << endl; + state.m_lastNode = nod; + state.m_lastOffset = off; + // No "return" here, obviously. We must keep looking into the children. + break; + } + } + // If we are after the last child, return lastNode/lastOffset + // But lastNode can be 0L if there is no child, for instance. + if ( state.m_lastNode ) + { + node = state.m_lastNode; + offset = state.m_lastOffset; + } + //kdDebug(6030) << "fallback - SelectionPointAfter node=" << node << " offset=" << offset << endl; + return SelectionPointAfter; +} + +bool RenderObject::mouseInside() const +{ + if (!m_mouseInside && continuation()) + return continuation()->mouseInside(); + return m_mouseInside; +} + +bool RenderObject::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inside) +{ + int tx = _tx + xPos(); + int ty = _ty + yPos(); + + inside |= ( style()->visibility() != HIDDEN && + (_y >= ty) && (_y < ty + height()) && (_x >= tx) && (_x < tx + width())) || isRoot() || isBody(); + bool inOverflowRect = inside; + if ( !inOverflowRect ) { + int ol = overflowLeft(); + int ot = overflowTop(); + TQRect overflowRect( tx+ol, ty+ot, overflowWidth()-ol, overflowHeight()-ot ); + inOverflowRect = overflowRect.contains( _x, _y ); + } + + // ### table should have its own, more performant method + if (hitTestAction != HitTestSelfOnly && + (( !isRenderBlock() || + !static_cast<RenderBlock*>( this )->isPointInScrollbar( _x, _y, _tx, _ty )) && + (overhangingContents() || inOverflowRect || isInline() || isRoot() || isCanvas() || + isTableRow() || isTableSection() || inside || mouseInside() ))) { + if ( hitTestAction == HitTestChildrenOnly ) + inside = false; + if ( hasOverflowClip() && layer() ) + layer()->subtractScrollOffset(tx, ty); + for (RenderObject* child = lastChild(); child; child = child->previousSibling()) + if (!child->layer() && child->nodeAtPoint(info, _x, _y, tx, ty, HitTestAll)) + inside = true; + } + + if (inside) + setInnerNode(info); + + return inside; +} + + +void RenderObject::setInnerNode(NodeInfo& info) +{ + if (!info.innerNode() && !isInline() && continuation()) { + // We are in the margins of block elements that are part of a continuation. In + // this case we're actually still inside the enclosing inline element that was + // split. Go ahead and set our inner node accordingly. + info.setInnerNode(continuation()->element()); + if (!info.innerNonSharedNode()) + info.setInnerNonSharedNode(continuation()->element()); + } + + if (!info.innerNode() && element()) + info.setInnerNode(element()); + + if(!info.innerNonSharedNode() && element()) + info.setInnerNonSharedNode(element()); +} + + +short RenderObject::verticalPositionHint( bool firstLine ) const +{ + short vpos = m_verticalPosition; + if ( m_verticalPosition == PositionUndefined || firstLine ) { + vpos = getVerticalPosition( firstLine ); + if ( !firstLine ) + const_cast<RenderObject *>(this)->m_verticalPosition = vpos; + } + return vpos; + +} + +short RenderObject::getVerticalPosition( bool firstLine, RenderObject* ref ) const +{ + // vertical align for table cells has a different meaning + int vpos = 0; + if ( !isTableCell() && isInline() ) { + EVerticalAlign va = style()->verticalAlign(); + if ( va == TOP ) { + vpos = PositionTop; + } else if ( va == BOTTOM ) { + vpos = PositionBottom; + } else { + if (!ref) ref = parent(); + bool checkParent = ref->isInline() && !ref->isReplacedBlock() && + !( ref->style()->verticalAlign() == TOP || ref->style()->verticalAlign() == BOTTOM ); + vpos = checkParent ? ref->verticalPositionHint( firstLine ) : 0; + // don't allow elements nested inside text-top to have a different valignment. + if ( va == BASELINE ) + return vpos; + else if ( va == LENGTH ) + return vpos - style()->verticalAlignLength().width( lineHeight( firstLine ) ); + + const TQFont &f = ref->font( firstLine ); + int fontsize = f.pixelSize(); + + if ( va == SUB ) + vpos += fontsize/5 + 1; + else if ( va == SUPER ) + vpos -= fontsize/3 + 1; + else if ( va == TEXT_TOP ) { + vpos += baselinePosition( firstLine ) - (TQFontMetrics(f).ascent() + TQFontMetrics(f).leading()/2); + } else if ( va == MIDDLE ) { + TQRect b = TQFontMetrics(f).boundingRect('x'); + vpos += -b.height()/2 - lineHeight( firstLine )/2 + baselinePosition( firstLine ); + } else if ( va == TEXT_BOTTOM ) { + vpos += TQFontMetrics(f).descent() + TQFontMetrics(f).leading()/2; + if ( !isReplaced() ) + vpos -= fontMetrics(firstLine).descent(); + } else if ( va == BASELINE_MIDDLE ) + vpos += - lineHeight( firstLine )/2 + baselinePosition( firstLine ); + } + } + return vpos; +} + +short RenderObject::lineHeight( bool firstLine ) const +{ + // Inline blocks are replaced elements. Otherwise, just pass off to + // the base class. If we're being queried as though we're the root line + // box, then the fact that we're an inline-block is irrelevant, and we behave + // just like a block. + + if (isReplaced() && (!isInlineBlockOrInlineTable() || !needsLayout())) + return height()+marginTop()+marginBottom(); + + Length lh; + if( firstLine && hasFirstLine() ) { + RenderStyle *pseudoStyle = style()->getPseudoStyle(RenderStyle::FIRST_LINE); + if ( pseudoStyle ) + lh = pseudoStyle->lineHeight(); + } + else + lh = style()->lineHeight(); + + // its "unset", choose nice default + if ( lh.value() < 0 ) + return style()->fontMetrics().lineSpacing(); + + if ( lh.isPercent() ) + return lh.minWidth( style()->font().pixelSize() ); + + // its fixed + return lh.value(); +} + +short RenderObject::baselinePosition( bool firstLine ) const +{ + // Inline blocks are replaced elements. Otherwise, just pass off to + // the base class. If we're being queried as though we're the root line + // box, then the fact that we're an inline-block is irrelevant, and we behave + // just like a block. + + if (isReplaced() && (!isInlineBlockOrInlineTable() || !needsLayout())) + return height()+marginTop()+marginBottom(); + + const TQFontMetrics &fm = fontMetrics( firstLine ); + return fm.ascent() + ( lineHeight( firstLine) - fm.height() ) / 2; +} + +void RenderObject::invalidateVerticalPositions() +{ + m_verticalPosition = PositionUndefined; + RenderObject *child = firstChild(); + while( child ) { + child->invalidateVerticalPositions(); + child = child->nextSibling(); + } +} + +void RenderObject::recalcMinMaxWidths() +{ + KHTMLAssert( m_recalcMinMax ); + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << " recalcMinMaxWidths() this=" << this <<endl; +#endif + + RenderObject *child = firstChild(); + int cmin=0; + int cmax=0; + + while( child ) { + bool test = false; + if ( ( m_minMaxKnown && child->m_recalcMinMax ) || !child->m_minMaxKnown ) { + cmin = child->minWidth(); + cmax = child->maxWidth(); + test = true; + } + if ( child->m_recalcMinMax ) + child->recalcMinMaxWidths(); + if ( !child->m_minMaxKnown ) + child->calcMinMaxWidth(); + if ( m_minMaxKnown && test && (cmin != child->minWidth() || cmax != child->maxWidth()) ) + m_minMaxKnown = false; + child = child->nextSibling(); + } + + // we need to recalculate, if the contains inline children, as the change could have + // happened somewhere deep inside the child tree + if ( ( !isInline() || isReplacedBlock() ) && childrenInline() ) + m_minMaxKnown = false; + + if ( !m_minMaxKnown ) + calcMinMaxWidth(); + m_recalcMinMax = false; +} + +void RenderObject::scheduleRelayout(RenderObject *clippedObj) +{ + if (!isCanvas()) return; + KHTMLView *view = static_cast<RenderCanvas *>(this)->view(); + if ( view ) + view->scheduleRelayout(clippedObj); +} + + +void RenderObject::removeLeftoverAnonymousBoxes() +{ +} + +InlineBox* RenderObject::createInlineBox(bool /*makePlaceHolderBox*/, bool /*isRootLineBox*/) +{ + KHTMLAssert(false); + return 0; +} + +void RenderObject::getTextDecorationColors(int decorations, TQColor& underline, TQColor& overline, + TQColor& linethrough, bool quirksMode) +{ + RenderObject* curr = this; + do { + RenderStyle *st = curr->style(); + int currDecs = st->textDecoration(); + if (currDecs) { + if (currDecs & UNDERLINE) { + decorations &= ~UNDERLINE; + underline = st->color(); + } + if (currDecs & OVERLINE) { + decorations &= ~OVERLINE; + overline = st->color(); + } + if (currDecs & LINE_THROUGH) { + decorations &= ~LINE_THROUGH; + linethrough = st->color(); + } + } + curr = curr->parent(); + if (curr && curr->isRenderBlock() && curr->continuation()) + curr = curr->continuation(); + } while (curr && decorations && (!quirksMode || !curr->element() || + (curr->element()->id() != ID_A && curr->element()->id() != ID_FONT))); + + // If we bailed out, use the element we bailed out at (typically a <font> or <a> element). + if (decorations && curr) { + RenderStyle *st = curr->style(); + if (decorations & UNDERLINE) + underline = st->color(); + if (decorations & OVERLINE) + overline = st->color(); + if (decorations & LINE_THROUGH) + linethrough = st->color(); + } +} + +int RenderObject::maximalOutlineSize(PaintAction p) const +{ + if (p != PaintActionOutline) + return 0; + return static_cast<RenderCanvas*>(document()->renderer())->maximalOutlineSize(); +} + +void RenderObject::collectBorders(TQValueList<CollapsedBorderValue>& borderStyles) +{ + for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) + curr->collectBorders(borderStyles); +} + +bool RenderObject::flowAroundFloats() const +{ + return isReplaced() || hasOverflowClip() || style()->flowAroundFloats(); +} + +bool RenderObject::usesLineWidth() const +{ + // 1. All auto-width objects that avoid floats should always use lineWidth + // 2. For objects with a specified width, we match WinIE's behavior: + // (a) tables use contentWidth + // (b) <hr>s use lineWidth + // (c) all other objects use lineWidth in quirks mode and contentWidth in strict mode. + return (flowAroundFloats() && (style()->width().isVariable() || isHR() || (style()->htmlHacks() && !isTable()))); +} + +bool RenderObject::hasCounter(const TQString& counter) const +{ + if (style() && (!isText() || isCounter())) { + if (lookupCounter(counter)) return true; + if (style()->hasCounterReset(counter)) { + return true; + } + else if (style()->hasCounterIncrement(counter)) { + return true; + } + } + if (counter == "list-item") { + if (isListItem()) return true; + if (element() && ( + element()->id() == ID_OL || + element()->id() == ID_UL || + element()->id() == ID_MENU || + element()->id() == ID_DIR)) + return true; + } else + if (counter == "-tdehtml-quotes" && isQuote()) { + return (static_cast<const RenderQuote*>(this)->quoteCount() != 0); + } + return false; +} + +CounterNode* RenderObject::getCounter(const TQString& counter, bool view, bool counters) +{ +// kdDebug( 6040 ) << renderName() << " getCounter(" << counter << ")" << endl; + + if (!style()) return 0; + + if (isText() && !isCounter()) return 0; + + CounterNode *i = lookupCounter(counter); + if (i) return i; + int val = 0; + + if (style()->hasCounterReset(counter) || isRoot()) { + i = new CounterReset(this); + val = style()->counterReset(counter); + if (style()->hasCounterIncrement(counter)) { + val += style()->counterIncrement(counter); + } +// kdDebug( 6040 ) << renderName() << " counter-reset: " << counter << " " << val << endl; + } + else + if (style()->hasCounterIncrement(counter)) { + i = new CounterNode(this); + val = style()->counterIncrement(counter); +// kdDebug( 6040 ) << renderName() << " counter-increment: " << counter << " " << val << endl; + } + else if (counter == "list-item") { + if (isListItem()) { + if (element() && element()->id() == ID_LI) { + DOMString v = static_cast<ElementImpl*>(element())->getAttribute(ATTR_VALUE); + if ( !v.isEmpty() ) { + i = new CounterReset(this); + val = v.toInt(); +// kdDebug( 6040 ) << renderName() << " counter-reset: " << counter << " " << val << endl; + } + } + if (!i) { + i = new CounterNode(this); + val = 1; +// kdDebug( 6040 ) << renderName() << " counter-increment: " << counter << " " << val << endl; + } + } + else + if (element() && element()->id() == ID_OL) { + i = new CounterReset(this); + DOMString v = static_cast<ElementImpl*>(element())->getAttribute(ATTR_START); + if ( !v.isEmpty() ) + val = v.toInt()-1; + else + val = 0; +// kdDebug( 6040 ) << renderName() << " counter-reset: " << counter << " " << val << endl; + } + else + if (element() && + (element()->id() == ID_UL || + element()->id() == ID_MENU|| + element()->id() == ID_DIR)) + { + i = new CounterReset(this); + val = 0; +// kdDebug( 6040 ) << renderName() << " counter-reset: " << counter << " " << val << endl; + } + } + else if (counter == "-tdehtml-quotes" && isQuote()) { + i = new CounterNode(this); + val = static_cast<RenderQuote*>(this)->quoteCount(); + } + + if (!i) { + i = new CounterNode(this); + val = 0; +// kdDebug( 6040 ) << renderName() << " counter-increment: " << counter << " " << val << endl; + } + i->setValue(val); + if (view) i->setIsVisual(); + if (counters) i->setHasCounters(); + + insertCounter(counter, i); + + if (!isRoot()) { + CounterNode *last=0, *current=0; + RenderObject *n = previousSibling(); + while(n) { + if (n->hasCounter(counter)) { + current = n->getCounter(counter); + break; + } + else + n = n->previousSibling(); + } + last = current; + + CounterNode *sibling = current; + // counter-reset on same render-level is our counter-parent + if (last) { + // Found render-sibling, now search for later counter-siblings among its render-children + n = n->lastChild(); + while (n) { + if (n->hasCounter(counter)) { + current = n->getCounter(counter); + if (last->parent() == current->parent() || sibling == current->parent()) { + last = current; + // If the current counter is not the last, search deeper + if (current->nextSibling()) { + n = n->lastChild(); + continue; + } + else + break; + } + } + n = n->previousSibling(); + } + if (sibling->isReset()) + { + if (last != sibling) + sibling->insertAfter(i, last); + else + sibling->insertAfter(i, 0); + } + else if (last->parent()) + last->parent()->insertAfter(i, last); + } + else if (parent()) { + // Nothing found among siblings, let our parent search + last = parent()->getCounter(counter, false); + if (last->isReset()) + last->insertAfter(i, 0); + else if (last->parent()) + last->parent()->insertAfter(i, last); + } + } + + return i; +} + +CounterNode* RenderObject::lookupCounter(const TQString& counter) const +{ + TQDict<tdehtml::CounterNode>* counters = document()->counters(this); + if (counters) + return counters->find(counter); + else + return 0; +} + +void RenderObject::detachCounters() +{ + TQDict<tdehtml::CounterNode>* counters = document()->counters(this); + if (!counters) return; + + TQDictIterator<tdehtml::CounterNode> i(*counters); + + while (i.current()) { + (*i)->remove(); + delete (*i); + ++i; + } + document()->removeCounters(this); +} + +void RenderObject::insertCounter(const TQString& counter, CounterNode* val) +{ + TQDict<tdehtml::CounterNode>* counters = document()->counters(this); + + if (!counters) { + counters = new TQDict<tdehtml::CounterNode>(11); + document()->setCounters(this, counters); + } + + counters->insert(counter, val); +} + +void RenderObject::updateWidgetMasks() { + for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) { + if ( curr->isWidget() && static_cast<RenderWidget*>(curr)->needsMask() ) { + TQWidget* w = static_cast<RenderWidget*>(curr)->widget(); + if (!w) + return; + RenderLayer* l = curr->enclosingStackingContext(); + TQRegion r = l ? l->getMask() : TQRegion(); + int x,y; + if (!r.isNull() && curr->absolutePosition(x,y)) { + int pbx = curr->borderLeft()+curr->paddingLeft(); + int pby = curr->borderTop()+curr->paddingTop(); + x+= pbx; + y+= pby; + r = r.intersect(TQRect(x,y, + curr->width()-pbx-curr->borderRight()-curr->paddingRight(), + curr->height()-pby-curr->borderBottom()-curr->paddingBottom())); +#ifdef MASK_DEBUG + TQMemArray<TQRect> ar = r.rects(); + kdDebug(6040) << "|| Setting widget mask for " << curr->information() << endl; + for (int i = 0; i < ar.size() ; ++i) { + kdDebug(6040) << " " << ar[i] << endl; + } +#endif + r.translate(-x,-y); + w->setMask(r); + } else { + w->clearMask(); + } + } + else if (!curr->layer() || !curr->layer()->isStackingContext()) + curr->updateWidgetMasks(); + + } +} + +TQRegion RenderObject::visibleFlowRegion(int x, int y) const +{ + TQRegion r; + for (RenderObject* ro=firstChild();ro;ro=ro->nextSibling()) { + if( !ro->layer() && !ro->isInlineFlow() && ro->style()->visibility() == VISIBLE) { + const RenderStyle *s = ro->style(); + if (ro->isRelPositioned()) + static_cast<const RenderBox*>(ro)->relativePositionOffset(x,y); + if ( s->backgroundImage() || s->backgroundColor().isValid() || s->hasBorder() ) + r += TQRect(x + ro->effectiveXPos(),y + ro->effectiveYPos(), ro->effectiveWidth(), ro->effectiveHeight()); + else + r += ro->visibleFlowRegion(x+ro->xPos(), y+ro->yPos()); + } + } + return r; +} + +#undef RED_LUMINOSITY +#undef GREEN_LUMINOSITY +#undef BLUE_LUMINOSITY +#undef INTENSITY_FACTOR +#undef LIGHT_FACTOR +#undef LUMINOSITY_FACTOR + +#undef MAX_COLOR +#undef COLOR_DARK_THRESHOLD +#undef COLOR_LIGHT_THRESHOLD + +#undef COLOR_LITE_BS_FACTOR +#undef COLOR_LITE_TS_FACTOR + +#undef COLOR_DARK_BS_FACTOR +#undef COLOR_DARK_TS_FACTOR + +#undef LIGHT_GRAY +#undef DARK_GRAY + diff --git a/tdehtml/rendering/render_object.h b/tdehtml/rendering/render_object.h new file mode 100644 index 000000000..9dd064932 --- /dev/null +++ b/tdehtml/rendering/render_object.h @@ -0,0 +1,866 @@ +/* + * This file is part of the html renderer for KDE. + * + * Copyright (C) 2000-2003 Lars Knoll (knoll@kde.org) + * (C) 2000 Antti Koivisto (koivisto@kde.org) + * (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * (C) 2002-2003 Apple Computer, Inc. + * (C) 2004 Allan Sandfeld Jensen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef render_object_h +#define render_object_h + +#include <tqcolor.h> +#include <tqrect.h> +#include <assert.h> +#include <tqvaluelist.h> + +#include <kdebug.h> +#include <kglobal.h> + +#include "xml/dom_docimpl.h" +#include "misc/tdehtmllayout.h" +#include "misc/loader_client.h" +#include "misc/helper.h" +#include "rendering/render_style.h" + +class TQPainter; +class TQTextStream; +class CSSStyle; +class KHTMLView; + +#ifndef NDEBUG +#define KHTMLAssert( x ) if( !(x) ) { \ + const RenderObject *o = this; while( o->parent() ) o = o->parent(); \ + o->printTree(); \ + tqDebug(" this object = %p, %s", (void*) this, kdBacktrace().latin1() ); \ + assert( x ); \ +} +#else +#define KHTMLAssert( x ) +#endif + +/* + * The painting of a layer occurs in three distinct phases. Each phase involves + * a recursive descent into the layer's render objects. The first phase is the background phase. + * The backgrounds and borders of all blocks are painted. Inlines are not painted at all. + * Floats must paint above block backgrounds but entirely below inline content that can overlap them. + * In the foreground phase, all inlines are fully painted. Inline replaced elements will get all + * three phases invoked on them during this phase. + */ + +typedef enum { + PaintActionElementBackground = 0, + PaintActionChildBackground, + PaintActionChildBackgrounds, + PaintActionFloat, + PaintActionForeground, + PaintActionOutline, + PaintActionSelection, + PaintActionCollapsedTableBorders +} PaintAction; + +typedef enum { + HitTestAll = 0, + HitTestSelfOnly = 1, + HitTestChildrenOnly = 2 +} HitTestAction; + +typedef enum { + PageBreakNormal = 0, // all rules apply + PageBreakHarder = 1, // page-break-inside: avoid is ignored + PageBreakForced = 2 // page-break-after/before: avoid, orphans and widows ignored +} PageBreakLevel; + +typedef enum { + LowPriority = 0, + NormalPriority = 1, + HighPriority = 2, + RealtimePriority = 3 +} Priority; + +inline PageBreakLevel operator| (PageBreakLevel a, PageBreakLevel b) { + if (a == PageBreakForced || b == PageBreakForced) + return PageBreakForced; + if (a == PageBreakHarder || b == PageBreakHarder) + return PageBreakHarder; + return PageBreakNormal; +} + +namespace DOM { + class HTMLAreaElementImpl; + class DOMString; + class NodeImpl; + class DocumentImpl; + class ElementImpl; + class EventImpl; +} + +namespace tdehtml { + class RenderFlow; + class RenderStyle; + class RenderTable; + class CachedObject; + class RenderObject; + class RenderCanvas; + class RenderText; + class RenderFrameSet; + class RenderArena; + class RenderLayer; + class RenderBlock; + class InlineBox; + class InlineFlowBox; + class CounterNode; + +/** + * Base Class for all rendering tree objects. + */ +class RenderObject : public CachedObjectClient +{ + RenderObject(const RenderObject&); + RenderObject& operator=(const RenderObject&); +public: + + RenderObject(DOM::NodeImpl* node); + virtual ~RenderObject(); + + RenderObject *parent() const { return m_parent; } + + RenderObject *previousSibling() const { return m_previous; } + RenderObject *nextSibling() const { return m_next; } + + virtual RenderObject *firstChild() const { return 0; } + virtual RenderObject *lastChild() const { return 0; } + + RenderObject *nextRenderer() const; + RenderObject *previousRenderer() const; + + virtual bool childAllowed() const { return false; } + virtual int borderTopExtra() const { return 0; } + virtual int borderBottomExtra() const { return 0; } + + virtual RenderLayer* layer() const { return 0; } + RenderLayer* enclosingLayer() const; + RenderLayer* enclosingStackingContext() const; + void addLayers(RenderLayer* parentLayer, RenderObject* newObject); + void removeLayers(RenderLayer* parentLayer); + void moveLayers(RenderLayer* oldParent, RenderLayer* newParent); + RenderLayer* findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint, + bool checkParent=true); + virtual void positionChildLayers() { } + virtual bool requiresLayer() const { + return isRoot()/* ### */ || isPositioned() || isRelPositioned() || hasOverflowClip(); + } + + // ### rename to overflowClipRect and clipRect + virtual TQRect getOverflowClipRect(int /*tx*/, int /*ty*/) + { return TQRect(0,0,0,0); } + virtual TQRect getClipRect(int /*tx*/, int /*ty*/) { return TQRect(0,0,0,0); } + bool hasClip() const { return isPositioned() && style()->hasClip(); } + bool hasOverflowClip() const { return m_hasOverflowClip; } + + bool scrollsOverflow() const { return scrollsOverflowX() || scrollsOverflowY(); } + bool scrollsOverflowX() const { return hasOverflowClip() && (style()->overflowX() == OSCROLL || style()->overflowX() == OAUTO); } + bool scrollsOverflowY() const { return hasOverflowClip() && (style()->overflowY() == OSCROLL || style()->overflowY() == OAUTO); } + + virtual int getBaselineOfFirstLineBox() { return -1; } // Tables and blocks implement this. + virtual InlineFlowBox* getFirstLineBox() { return 0; } // Tables and blocks implement this. + + // Whether or not a positioned element requires normal flow x/y to be computed + // to determine its position. + bool hasStaticX() const; + bool hasStaticY() const; + + // Linear tree traversal + RenderObject *objectBelow() const; + RenderObject *objectAbove() const; + + // Returns if an object has counter-increment or counter-reset + bool hasCounter(const TQString& counter) const; + // Calculates the value of the counter + CounterNode* getCounter(const TQString& counter, bool view = false, bool counters = false); + // Detaches all counterNodes + void detachCounters(); + + +protected: + // Helper functions for counter-cache + void insertCounter(const TQString& counter, CounterNode* value); + CounterNode* lookupCounter(const TQString& counter) const; + +public: + ////////////////////////////////////////// + // RenderObject tree manipulation + virtual void addChild(RenderObject *newChild, RenderObject *beforeChild = 0); + void removeChild(RenderObject *oldChild); + + // raw tree manipulation + virtual RenderObject* removeChildNode(RenderObject* child); + virtual void appendChildNode(RenderObject* child); + virtual void insertChildNode(RenderObject* child, RenderObject* before); + ////////////////////////////////////////// + + ////////////////////////////////////////// + // Helper functions. Dangerous to use! + void setPreviousSibling(RenderObject *previous) { m_previous = previous; } + void setNextSibling(RenderObject *next) { m_next = next; } + void setParent(RenderObject *parent) { m_parent = parent; } + ////////////////////////////////////////// + +public: + virtual const char *renderName() const { return "RenderObject"; } +#ifdef ENABLE_DUMP + TQString information() const; + virtual void printTree(int indent=0) const; + virtual void dump(TQTextStream &stream, const TQString &ind = TQString::null) const; +#endif + + static RenderObject *createObject(DOM::NodeImpl* node, RenderStyle* style); + + // Overloaded new operator. Derived classes must override operator new + // in order to allocate out of the RenderArena. + void* operator new(size_t sz, RenderArena* renderArena) throw(); + + // Overridden to prevent the normal delete from being called. + void operator delete(void* ptr, size_t sz); + +private: + // The normal operator new is disallowed on all render objects. + void* operator new(size_t sz); + +public: + RenderArena* renderArena() const; + virtual RenderFlow* continuation() const { return 0; } + virtual bool isInlineContinuation() const { return false; } + + + bool isRoot() const { return m_isRoot && !m_isAnonymous; } + void setIsRoot(bool b) { m_isRoot = b; } + bool isHR() const; + // some helper functions... + virtual bool isRenderBlock() const { return false; } + virtual bool isRenderInline() const { return false; } + virtual bool isInlineFlow() const { return false; } + virtual bool isBlockFlow() const { return false; } + virtual bool isInlineBlockOrInlineTable() const { return false; } + virtual bool childrenInline() const { return false; } + virtual bool isBox() const { return false; } + virtual bool isRenderReplaced() const { return false; } + + virtual bool isGlyph() const { return false; } + virtual bool isCounter() const { return false; } + virtual bool isQuote() const { return false; } + virtual bool isListItem() const { return false; } + virtual bool isListMarker() const { return false; } + virtual bool isCanvas() const { return false; } + virtual bool isBR() const { return false; } + virtual bool isTableCell() const { return false; } + virtual bool isTableRow() const { return false; } + virtual bool isTableSection() const { return false; } + virtual bool isTableCol() const { return false; } + virtual bool isTable() const { return false; } + virtual bool isWidget() const { return false; } + virtual bool isBody() const { return false; } + virtual bool isFormElement() const { return false; } + virtual bool isFrameSet() const { return false; } + virtual bool isApplet() const { return false; } + + bool isHTMLMarquee() const; + bool isWordBreak() const; + + bool isAnonymous() const { return m_isAnonymous; } + void setIsAnonymous(bool b) { m_isAnonymous = b; } + bool isAnonymousBlock() const { return isAnonymous() && style()->display() == BLOCK && node()->isDocumentNode(); } + bool isPseudoAnonymous() const { return isAnonymous() && !node()->isDocumentNode(); } + + bool isFloating() const { return m_floating; } + bool isPositioned() const { return m_positioned; } + bool isRelPositioned() const { return m_relPositioned; } + bool isText() const { return m_isText; } + bool isInline() const { return m_inline; } + bool isCompact() const { return style()->display() == COMPACT; } // compact + bool isRunIn() const { return style()->display() == RUN_IN; } // run-in object + bool mouseInside() const; + bool isReplaced() const { return m_replaced; } + bool isReplacedBlock() const { return isInline() && isReplaced() && isRenderBlock(); } + bool shouldPaintBackgroundOrBorder() const { return m_paintBackground; } + bool needsLayout() const { return m_needsLayout || m_normalChildNeedsLayout || m_posChildNeedsLayout; } + bool markedForRepaint() const { return m_markedForRepaint; } + void setMarkedForRepaint(bool m) { m_markedForRepaint = m; } + bool selfNeedsLayout() const { return m_needsLayout; } + bool posChildNeedsLayout() const { return m_posChildNeedsLayout; } + bool normalChildNeedsLayout() const { return m_normalChildNeedsLayout; } + bool minMaxKnown() const{ return m_minMaxKnown; } + bool overhangingContents() const { return m_overhangingContents; } + bool hasFirstLine() const { return m_hasFirstLine; } + bool isSelectionBorder() const { return m_isSelectionBorder; } + bool recalcMinMax() const { return m_recalcMinMax; } + + RenderCanvas* canvas() const; + // don't even think about making this method virtual! + DOM::DocumentImpl* document() const; + DOM::NodeImpl* element() const { return isAnonymous() ? 0L : m_node; } + DOM::NodeImpl* node() const { return m_node; } + + /** + * returns the object containing this one. can be different from parent for + * positioned elements + */ + RenderObject *container() const; + + void setOverhangingContents(bool p=true); + void markContainingBlocksForLayout(); + void dirtyFormattingContext( bool checkContainer ); + void repaintDuringLayout(); + void setNeedsLayout(bool b, bool markParents = true); + void setChildNeedsLayout(bool b, bool markParents = true); + void setMinMaxKnown(bool b=true) { + m_minMaxKnown = b; + if ( !b ) { + RenderObject *o = this; + RenderObject *root = this; + while( o ) { // ### && !o->m_recalcMinMax ) { + o->m_recalcMinMax = true; + root = o; + o = o->m_parent; + } + } + } + void setNeedsLayoutAndMinMaxRecalc() { + setMinMaxKnown(false); + setNeedsLayout(true); + } + void setPositioned(bool b=true) { m_positioned = b; } + void setRelPositioned(bool b=true) { m_relPositioned = b; } + void setFloating(bool b=true) { m_floating = b; } + void setInline(bool b=true) { m_inline = b; } + void setMouseInside(bool b=true) { m_mouseInside = b; } + void setShouldPaintBackgroundOrBorder(bool b=true) { m_paintBackground = b; } + void setRenderText() { m_isText = true; } + void setReplaced(bool b=true) { m_replaced = b; } + void setHasOverflowClip(bool b = true) { m_hasOverflowClip = b; } + void setIsSelectionBorder(bool b=true) { m_isSelectionBorder = b; } + + void scheduleRelayout(RenderObject *clippedObj = 0); + + void updateBackgroundImages(RenderStyle* oldStyle); + + virtual InlineBox* createInlineBox(bool makePlaceHolderBox, bool isRootLineBox); + + virtual short lineHeight( bool firstLine ) const; + virtual short verticalPositionHint( bool firstLine ) const; + virtual short baselinePosition( bool firstLine ) const; + short getVerticalPosition( bool firstLine, RenderObject* ref=0 ) const; + + /* + * Print the object and its children, clipped by (x|y|w|h). + * (tx|ty) is the calculated position of the parent + */ + struct PaintInfo { + PaintInfo(TQPainter* _p, const TQRect& _r, PaintAction _phase) + : p(_p), r(_r), phase(_phase), outlineObjects(0) {} + ~PaintInfo() { delete outlineObjects; } + TQPainter* p; + TQRect r; + PaintAction phase; + TQValueList<RenderFlow *>* outlineObjects; // used to list which outlines should be painted by a block with inline children + }; + virtual void paint( PaintInfo& i, int tx, int ty); + + void paintBorder(TQPainter *p, int _tx, int _ty, int w, int h, const RenderStyle* style, bool begin=true, bool end=true); + void paintOutline(TQPainter *p, int _tx, int _ty, int w, int h, const RenderStyle* style); + + virtual void paintBoxDecorations(PaintInfo&, int /*_tx*/, int /*_ty*/) {} + + virtual void paintBackgroundExtended(TQPainter* /*p*/, const TQColor& /*c*/, const BackgroundLayer */*bgLayer*/, + int /*clipy*/, int /*cliph*/, int /*_tx*/, int /*_ty*/, + int /*w*/, int /*height*/, int /*bleft*/, int /*bright*/, int /*pleft*/, int /*pright*/ ) {} + + + /* + * This function calculates the minimum & maximum width that the object + * can be set to. + * + * when the Element calls setMinMaxKnown(true), calcMinMaxWidth() will + * be no longer called. + * + * when a element has a fixed size, m_minWidth and m_maxWidth should be + * set to the same value. This has the special meaning that m_width, + * contains the actual value. + * + * assumes calcMinMaxWidth has already been called for all children. + */ + virtual void calcMinMaxWidth() { } + + /* + * Does the min max width recalculations after changes. + */ + void recalcMinMaxWidths(); + + /* + * Calculates the actual width of the object (only for non inline + * objects) + */ + virtual void calcWidth() {} + + /* + * Calculates the actual width of the object (only for non inline + * objects) + */ + virtual void calcHeight() {} + + /* + * This function should cause the Element to calculate its + * width and height and the layout of its content + * + * when the Element calls setNeedsLayout(false), layout() is no + * longer called during relayouts, as long as there is no + * style sheet change. When that occurs, m_needsLayout will be + * set to true and the Element receives layout() calls + * again. + */ + virtual void layout() = 0; + + /* This function performs a layout only if one is needed. */ + void layoutIfNeeded() { if (needsLayout()) layout(); } + + // used for element state updates that can not be fixed with a + // repaint and do not need a relayout + virtual void updateFromElement() {} + + // Called immediately after render-object is inserted + virtual void attach() { m_attached = true; } + bool attached() { return m_attached; } + // The corresponding closing element has been parsed. ### remove me + virtual void close() { } + + virtual int availableHeight() const { return 0; } + + // Whether or not the element shrinks to its max width (rather than filling the width + // of a containing block). HTML4 buttons, legends, and floating/compact elements do this. + bool sizesToMaxWidth() const; + + /* + * NeesPageClear indicates the object crossed a page-break but could not break itself and now + * needs to be moved clear by its parent. + */ + void setNeedsPageClear(bool b = true) { m_needsPageClear = b; } + virtual bool needsPageClear() const { return m_needsPageClear; } + + /* + * ContainsPageBreak indicates the object contains a clean page-break. + * ### should be removed and replaced with (crossesPageBreak && !needsPageClear) + */ + void setContainsPageBreak(bool b = true) { m_containsPageBreak = b; } + virtual bool containsPageBreak() const { return m_containsPageBreak; } + + virtual int pageTopAfter(int y) const { if (parent()) return parent()->pageTopAfter(y); else return 0; } + + virtual int crossesPageBreak(int top, int bottom) const + { if (parent()) return parent()->crossesPageBreak(top, bottom); else return 0; } + + // Checks if a page-break before child is possible at the given page-break level + // false means the child should attempt the break self. + virtual bool canClear(RenderObject */*child*/, PageBreakLevel level) + { if (parent()) return parent()->canClear(this, level); else return false; } + + void setAfterPageBreak(bool b = true) { m_afterPageBreak = b; }; + void setBeforePageBreak(bool b = true) { m_beforePageBreak = b; }; + virtual bool afterPageBreak() const { return m_afterPageBreak; } + virtual bool beforePageBreak() const { return m_beforePageBreak; } + + // does a query on the rendertree and finds the innernode + // and overURL for the given position + // if readonly == false, it will recalc hover styles accordingly + class NodeInfo + { + friend class RenderImage; + friend class RenderFlow; + friend class RenderInline; + friend class RenderText; + friend class RenderWidget; + friend class RenderObject; + friend class RenderFrameSet; + friend class RenderLayer; + friend class DOM::HTMLAreaElementImpl; + public: + NodeInfo(bool readonly, bool active) + : m_innerNode(0), m_innerNonSharedNode(0), m_innerURLElement(0), m_readonly(readonly), m_active(active) + { } + + DOM::NodeImpl* innerNode() const { return m_innerNode; } + DOM::NodeImpl* innerNonSharedNode() const { return m_innerNonSharedNode; } + DOM::NodeImpl* URLElement() const { return m_innerURLElement; } + bool readonly() const { return m_readonly; } + bool active() const { return m_active; } + + private: + void setInnerNode(DOM::NodeImpl* n) { m_innerNode = n; } + void setInnerNonSharedNode(DOM::NodeImpl* n) { m_innerNonSharedNode = n; } + void setURLElement(DOM::NodeImpl* n) { m_innerURLElement = n; } + + DOM::NodeImpl* m_innerNode; + DOM::NodeImpl* m_innerNonSharedNode; + DOM::NodeImpl* m_innerURLElement; + bool m_readonly; + bool m_active; + }; + + /** contains stateful information for a checkSelectionPoint call + */ + struct SelPointState { + /** last node that was before the current position */ + DOM::NodeImpl *m_lastNode; + /** offset of last node */ + long m_lastOffset; + /** true when the last node had the result SelectionAfterInLine */ + bool m_afterInLine; + + SelPointState() : m_lastNode(0), m_lastOffset(0), m_afterInLine(false) + {} + }; + + virtual FindSelectionResult checkSelectionPoint( int _x, int _y, int _tx, int _ty, + DOM::NodeImpl*&, int & offset, + SelPointState & ); + virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction, bool inside = false); + void setInnerNode(NodeInfo& info); + + // set the style of the object. + virtual void setStyle(RenderStyle *style); + + // returns the containing block level element for this element. + RenderBlock *containingBlock() const; + + // return just the width of the containing block + virtual short containingBlockWidth() const; + // return just the height of the containing block + virtual int containingBlockHeight() const; + + // size of the content area (box size minus padding/border) + virtual short contentWidth() const { return 0; } + virtual int contentHeight() const { return 0; } + + // intrinsic extend of replaced elements. undefined otherwise + virtual short intrinsicWidth() const { return 0; } + virtual int intrinsicHeight() const { return 0; } + + // relative to parent node + virtual void setPos( int /*xPos*/, int /*yPos*/ ) { } + virtual void setWidth( int /*width*/ ) { } + virtual void setHeight( int /*height*/ ) { } + + virtual int xPos() const { return 0; } + virtual int yPos() const { return 0; } + + /** the position of the object from where it begins drawing, including + * its negative overflow + */ + int effectiveXPos() const { return xPos() + (hasOverflowClip() ? 0 : overflowLeft()); } + + /** the position of the object from where it begins drawing, including + * its negative overflow + */ + int effectiveYPos() const { return yPos() + (hasOverflowClip() ? -borderTopExtra() : kMin(overflowTop(), -borderTopExtra())); } + + /** Leftmost coordinate of this inline element relative to containing + * block. Always zero for non-inline elements. + */ + virtual int inlineXPos() const { return 0; } + /** Topmost coordinate of this inline element relative to containing + * block. Always zero for non-inline elements. + */ + virtual int inlineYPos() const { return 0; } + + // calculate client position of box + virtual bool absolutePosition(int &/*xPos*/, int &/*yPos*/, bool fixed = false) const; + + // width and height are without margins but include paddings and borders + virtual short width() const { return 0; } + virtual int height() const { return 0; } + + // The height of a block when you include overflow spillage out of + // the bottom of the block (e.g., a <div style="height:25px"> that + // has a 100px tall image inside it would have an overflow height + // of borderTop() + paddingTop() + 100px. + virtual int overflowHeight() const { return height(); } + virtual int overflowWidth() const { return width(); } + // how much goes over the left hand side (0 or a negative number) + virtual int overflowTop() const { return 0; } + virtual int overflowLeft() const { return 0; } + + /** + * Returns the height that is effectively considered when contemplating the + * object as a whole -- usually the overflow height, or the height if clipped. + */ + int effectiveHeight() const { return hasOverflowClip() ? height() + borderTopExtra() + borderBottomExtra() : + kMax(overflowHeight() - overflowTop(), height() + borderTopExtra() + borderBottomExtra()); } + /** + * Returns the width that is effectively considered when contemplating the + * object as a whole -- usually the overflow width, or the width if clipped. + */ + int effectiveWidth() const { return hasOverflowClip() ? width() : overflowWidth() - overflowLeft(); } + + // IE extensions, heavily used in ECMA + virtual short offsetWidth() const { return width(); } + virtual int offsetHeight() const { return height() + borderTopExtra() + borderBottomExtra(); } + virtual int offsetLeft() const; + virtual int offsetTop() const; + virtual RenderObject* offsetParent() const; + short clientWidth() const; + int clientHeight() const; + short scrollWidth() const; + int scrollHeight() const; + + virtual bool isSelfCollapsingBlock() const { return false; } + short collapsedMarginTop() const { return maxTopMargin(true)-maxTopMargin(false); } + short collapsedMarginBottom() const { return maxBottomMargin(true)-maxBottomMargin(false); } + + virtual bool isTopMarginQuirk() const { return false; } + virtual bool isBottomMarginQuirk() const { return false; } + virtual short maxTopMargin(bool positive) const + { return positive ? kMax( int( marginTop() ), 0 ) : - kMin( int( marginTop() ), 0 ); } + virtual short maxBottomMargin(bool positive) const + { return positive ? kMax( int( marginBottom() ), 0 ) : - kMin( int( marginBottom() ), 0 ); } + + virtual short marginTop() const { return 0; } + virtual short marginBottom() const { return 0; } + virtual short marginLeft() const { return 0; } + virtual short marginRight() const { return 0; } + + virtual int paddingTop() const; + virtual int paddingBottom() const; + virtual int paddingLeft() const; + virtual int paddingRight() const; + + virtual int borderTop() const { return style()->borderTopWidth(); } + virtual int borderBottom() const { return style()->borderBottomWidth(); } + virtual int borderLeft() const { return style()->borderLeftWidth(); } + virtual int borderRight() const { return style()->borderRightWidth(); } + + virtual short minWidth() const { return 0; } + virtual int maxWidth() const { return 0; } + + RenderStyle* style() const { return m_style; } + RenderStyle* style( bool firstLine ) const { + RenderStyle *s = m_style; + if( firstLine && hasFirstLine() ) { + RenderStyle *pseudoStyle = style()->getPseudoStyle(RenderStyle::FIRST_LINE); + if ( pseudoStyle ) + s = pseudoStyle; + } + return s; + } + + void getTextDecorationColors(int decorations, TQColor& underline, TQColor& overline, + TQColor& linethrough, bool quirksMode=false); + + enum BorderSide { + BSTop, BSBottom, BSLeft, BSRight + }; + void drawBorder(TQPainter *p, int x1, int y1, int x2, int y2, BorderSide s, + TQColor c, const TQColor& textcolor, EBorderStyle style, + int adjbw1, int adjbw2, bool invalidisInvert = false); + + // Used by collapsed border tables. + virtual void collectBorders(TQValueList<CollapsedBorderValue>& borderStyles); + + // force a complete repaint + virtual void repaint(Priority p = NormalPriority) { if(m_parent) m_parent->repaint(p); } + virtual void repaintRectangle(int x, int y, int w, int h, Priority p=NormalPriority, bool f=false); + + virtual unsigned int length() const { return 1; } + + virtual bool isHidden() const { return isFloating() || isPositioned(); } + + // Special objects are objects that are neither really inline nor blocklevel + bool isFloatingOrPositioned() const { return (isFloating() || isPositioned()); }; + virtual bool hasOverhangingFloats() const { return false; } + virtual bool hasFloats() const { return false; } + virtual bool containsFloat(RenderObject* /*o*/) const { return false; } + virtual void markAllDescendantsWithFloatsForLayout(RenderObject* /*floatToRemove*/ = 0) {} + + bool flowAroundFloats() const; + bool usesLineWidth() const; + + // positioning of inline children (bidi) + virtual void position(InlineBox*, int, int, bool) {} +// virtual void position(int, int, int, int, int, bool, bool, int) {} + + // Applied as a "slop" to dirty rect checks during the outline painting phase's dirty-rect checks. + int maximalOutlineSize(PaintAction p) const; + + enum SelectionState { + SelectionNone, + SelectionStart, + SelectionInside, + SelectionEnd, + SelectionBoth + }; + + virtual SelectionState selectionState() const { return SelectionNone;} + virtual void setSelectionState(SelectionState) {} + + /** + * Flags which influence the appearence and position + * @param CFOverride input overrides existing character, caret should be + * cover the whole character + * @param CFOutside coordinates are to be interpreted outside of the + * render object + * @param CFOutsideEnd coordinates are to be interpreted at the outside + * end of the render object (only valid if CFOutside is also set) + */ + enum CaretFlags { CFOverride = 0x01, CFOutside = 0x02, CFOutsideEnd = 0x04 }; + + /** + * Returns the content coordinates of the caret within this render object. + * @param offset zero-based offset determining position within the render object. + * @param flags combination of enum CaretFlags + * @param _x returns the left coordinate + * @param _y returns the top coordinate + * @param width returns the caret's width + * @param height returns the caret's height + */ + virtual void caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height); + + // returns the lowest position of the lowest object in that particular object. + // This 'height' is relative to the topleft of the margin box of the object. + // Implemented in RenderFlow. + virtual int lowestPosition(bool /*includeOverflowInterior*/=true, bool /*includeSelf*/=true) const { return 0; } + virtual int rightmostPosition(bool /*includeOverflowInterior*/=true, bool /*includeSelf*/=true) const { return 0; } + virtual int leftmostPosition(bool /*includeOverflowInterior*/=true, bool /*includeSelf*/=true) const { return 0; } + virtual int highestPosition(bool /*includeOverflowInterior*/=true, bool /*includeSelf*/=true) const { return 0; } + + // recursively invalidate current layout + // unused: void invalidateLayout(); + + virtual void calcVerticalMargins() {} + void removeFromObjectLists(); + + virtual void deleteInlineBoxes(RenderArena* arena=0) {(void)arena;} + virtual void detach( ); + + void setDoNotDelete(bool b) { m_doNotDelete = b; } + bool doNotDelete() const { return m_doNotDelete; } + + const TQFont &font(bool firstLine) const { + return style( firstLine )->font(); + } + + const TQFontMetrics &fontMetrics(bool firstLine) const { + return style( firstLine )->fontMetrics(); + } + + /** returns the lowest possible value the caret offset may have to + * still point to a valid position. + * + * Returns 0 by default. + */ + virtual long minOffset() const { return 0; } + /** returns the highest possible value the caret offset may have to + * still point to a valid position. + * + * Returns 0 by default, as generic elements are considered to have no + * width. + */ + virtual long maxOffset() const { return 0; } + + virtual void setPixmap(const TQPixmap &, const TQRect&, CachedImage *); + + TQRegion visibleFlowRegion(int x, int y) const; + +protected: + virtual void selectionStartEnd(int& spos, int& epos); + + virtual TQRect viewRect() const; + void remove(); + void invalidateVerticalPositions(); + bool attemptDirectLayerTranslation(); + void updateWidgetMasks(); + + virtual void removeLeftoverAnonymousBoxes(); + + void arenaDelete(RenderArena *arena); + +private: + RenderStyle* m_style; + DOM::NodeImpl* m_node; + RenderObject *m_parent; + RenderObject *m_previous; + RenderObject *m_next; + + short m_verticalPosition; + + bool m_needsLayout : 1; + bool m_normalChildNeedsLayout : 1; + bool m_markedForRepaint : 1; + bool m_posChildNeedsLayout : 1; + + bool m_minMaxKnown : 1; + bool m_floating : 1; + + bool m_positioned : 1; + bool m_overhangingContents : 1; + bool m_relPositioned : 1; + bool m_paintBackground : 1; // if the box has something to paint in the + // background painting phase (background, border, etc) + + bool m_isAnonymous : 1; + bool m_recalcMinMax : 1; + bool m_isText : 1; + bool m_inline : 1; + bool m_attached : 1; + + bool m_replaced : 1; + bool m_mouseInside : 1; + bool m_hasFirstLine : 1; + bool m_isSelectionBorder : 1; + + bool m_isRoot : 1; + + bool m_beforePageBreak : 1; + bool m_afterPageBreak : 1; + + bool m_needsPageClear : 1; + bool m_containsPageBreak : 1; + + bool m_hasOverflowClip : 1; + + bool m_doNotDelete : 1; // This object should not be auto-deleted + + // ### we have 16 + 26 bits. + + + void arenaDelete(RenderArena *arena, void *objectBase); + + friend class RenderLayer; + friend class RenderListItem; + friend class RenderContainer; + friend class RenderCanvas; +}; + + +enum VerticalPositionHint { + PositionTop = -0x4000, + PositionBottom = 0x4000, + PositionUndefined = 0x3fff +}; + +} //namespace +#endif diff --git a/tdehtml/rendering/render_replaced.cpp b/tdehtml/rendering/render_replaced.cpp new file mode 100644 index 000000000..42fce027e --- /dev/null +++ b/tdehtml/rendering/render_replaced.cpp @@ -0,0 +1,940 @@ +/** + * This file is part of the HTML widget for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * Copyright (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * Copyright (C) 2003 Apple Computer, Inc. + * Copyright (C) 2004 Germain Garand (germain@ebooksfrance.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#include "render_replaced.h" +#include "render_layer.h" +#include "render_canvas.h" +#include "render_line.h" + +#include "render_arena.h" + +#include <assert.h> +#include <tqwidget.h> +#include <tqpainter.h> +#include <tqevent.h> +#include <tqapplication.h> +#include <tqlineedit.h> +#include <kglobalsettings.h> +#include <tqobjectlist.h> +#include <tqvaluevector.h> + +#include "tdehtml_ext.h" +#include "tdehtmlview.h" +#include "xml/dom2_eventsimpl.h" +#include "tdehtml_part.h" +#include "xml/dom_docimpl.h" +#include <kdebug.h> + +bool tdehtml::allowWidgetPaintEvents = false; + +using namespace tdehtml; +using namespace DOM; + + +RenderReplaced::RenderReplaced(DOM::NodeImpl* node) + : RenderBox(node) +{ + // init RenderObject attributes + setReplaced(true); + + m_intrinsicWidth = 300; + m_intrinsicHeight = 150; +} + +void RenderReplaced::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown()); + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << "RenderReplaced::calcMinMaxWidth() known=" << minMaxKnown() << endl; +#endif + + m_width = calcReplacedWidth(); + m_width = calcBoxWidth( m_width ); + + if ( style()->width().isPercent() || style()->height().isPercent() || + style()->maxWidth().isPercent() || style()->maxHeight().isPercent() || + style()->minWidth().isPercent() || style()->minHeight().isPercent() ) { + m_minWidth = 0; + m_maxWidth = m_width; + } + else + m_minWidth = m_maxWidth = m_width; + + setMinMaxKnown(); +} + +void RenderReplaced::position(InlineBox* box, int /*from*/, int /*len*/, bool /*reverse*/) +{ + setPos( box->xPos(), box->yPos() ); +} + +// ----------------------------------------------------------------------------- + +RenderWidget::RenderWidget(DOM::NodeImpl* node) + : RenderReplaced(node) +{ + m_widget = 0; + // a widget doesn't support being anonymous + assert(!isAnonymous()); + m_view = node->getDocument()->view(); + m_arena.reset(renderArena()); + m_resizePending = false; + m_discardResizes = false; + m_isKHTMLWidget = false; + m_needsMask = false; + + // this is no real reference counting, its just there + // to make sure that we're not deleted while we're recursed + // in an eventFilter of the widget + ref(); +} + +void RenderWidget::detach() +{ + remove(); + deleteInlineBoxes(); + + if ( m_widget ) { + if ( m_view ) { + m_view->setWidgetVisible(this, false); + m_view->removeChild( m_widget ); + } + + m_widget->removeEventFilter( this ); + m_widget->setMouseTracking( false ); + } + + deref(); +} + +RenderWidget::~RenderWidget() +{ + KHTMLAssert( refCount() <= 0 ); + + if(m_widget) { + m_widget->hide(); + m_widget->deleteLater(); + } +} + +class TQWidgetResizeEvent : public TQEvent +{ +public: + enum { Type = TQEvent::User + 0xbee }; + TQWidgetResizeEvent( int _w, int _h ) : + TQEvent( ( TQEvent::Type ) Type ), w( _w ), h( _h ) {} + int w; + int h; +}; + +void RenderWidget::resizeWidget( int w, int h ) +{ + // ugly hack to limit the maximum size of the widget ( as X11 has problems if + // its bigger ) + h = kMin( h, 3072 ); + w = kMin( w, 2000 ); + + if (m_widget->width() != w || m_widget->height() != h) { + m_resizePending = isKHTMLWidget(); + ref(); + element()->ref(); + TQApplication::postEvent( this, new TQWidgetResizeEvent( w, h ) ); + element()->deref(); + deref(); + } +} + +void RenderWidget::cancelPendingResize() +{ + if (!m_widget) + return; + m_discardResizes = true; + TQApplication::sendPostedEvents(this, TQWidgetResizeEvent::Type); + m_discardResizes = false; +} + +bool RenderWidget::event( TQEvent *e ) +{ + if ( m_widget && (e->type() == (TQEvent::Type)TQWidgetResizeEvent::Type) ) { + m_resizePending = false; + if (m_discardResizes) + return true; + TQWidgetResizeEvent *re = static_cast<TQWidgetResizeEvent *>(e); + m_widget->resize( re->w, re->h ); + repaint(); + } + // eat all events - except if this is a frame (in which case KHTMLView handles it all) + if ( ::tqqt_cast<KHTMLView *>( m_widget ) ) + return TQObject::event( e ); + return true; +} + +void RenderWidget::flushWidgetResizes() //static +{ + TQApplication::sendPostedEvents( 0, TQWidgetResizeEvent::Type ); +} + +void RenderWidget::setQWidget(TQWidget *widget) +{ + if (widget != m_widget) + { + if (m_widget) { + m_widget->removeEventFilter(this); + disconnect( m_widget, TQT_SIGNAL( destroyed()), this, TQT_SLOT( slotWidgetDestructed())); + m_widget->hide(); + m_widget->deleteLater(); //Might happen due to event on the widget, so be careful + m_widget = 0; + } + m_widget = widget; + if (m_widget) { + connect( m_widget, TQT_SIGNAL( destroyed()), this, TQT_SLOT( slotWidgetDestructed())); + m_widget->installEventFilter(this); + + if ( (m_isKHTMLWidget = !strcmp(m_widget->name(), "__tdehtml")) && !::tqqt_cast<TQFrame*>(m_widget)) + m_widget->setBackgroundMode( TQWidget::NoBackground ); + + if (m_widget->focusPolicy() > TQ_StrongFocus) + m_widget->setFocusPolicy(TQ_StrongFocus); + // if we've already received a layout, apply the calculated space to the + // widget immediately, but we have to have really been full constructed (with a non-null + // style pointer). + if (!needsLayout() && style()) { + resizeWidget( m_width-borderLeft()-borderRight()-paddingLeft()-paddingRight(), + m_height-borderTop()-borderBottom()-paddingTop()-paddingBottom() ); + } + else + setPos(xPos(), -500000); + } + m_view->setWidgetVisible(this, false); + m_view->addChild( m_widget, 0, -500000); + if ( m_widget ) m_widget->hide(); + m_resizePending = false; + } +} + +void RenderWidget::layout( ) +{ + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + if ( m_widget ) { + resizeWidget( m_width-borderLeft()-borderRight()-paddingLeft()-paddingRight(), + m_height-borderTop()-borderBottom()-paddingTop()-paddingBottom() ); + if (!isKHTMLWidget() && !isFrame() && !m_needsMask) { + m_needsMask = true; + RenderLayer* rl = enclosingStackingContext(); + RenderLayer* el = enclosingLayer(); + while (rl && el && el != rl) { + if (el->renderer()->style()->position() != STATIC) { + m_needsMask = false; + break; + } + el = el->parent(); + } + if (m_needsMask) { + if (rl) rl->setHasOverlaidWidgets(); + canvas()->setNeedsWidgetMasks(); + } + } + } + + setNeedsLayout(false); +} + +void RenderWidget::updateFromElement() +{ + if (m_widget) { + // Color: + TQColor color = style()->color(); + TQColor backgroundColor = style()->backgroundColor(); + + if ( color.isValid() || backgroundColor.isValid() ) { + TQPalette pal(TQApplication::palette(m_widget)); + + int contrast_ = TDEGlobalSettings::contrast(); + int highlightVal = 100 + (2*contrast_+4)*16/10; + int lowlightVal = 100 + (2*contrast_+4)*10; + + if (backgroundColor.isValid()) { + if (!isKHTMLWidget()) + widget()->setEraseColor(backgroundColor ); + for ( int i = 0; i < TQPalette::NColorGroups; ++i ) { + pal.setColor( (TQPalette::ColorGroup)i, TQColorGroup::Background, backgroundColor ); + pal.setColor( (TQPalette::ColorGroup)i, TQColorGroup::Light, backgroundColor.light(highlightVal) ); + pal.setColor( (TQPalette::ColorGroup)i, TQColorGroup::Dark, backgroundColor.dark(lowlightVal) ); + pal.setColor( (TQPalette::ColorGroup)i, TQColorGroup::Mid, backgroundColor.dark(120) ); + pal.setColor( (TQPalette::ColorGroup)i, TQColorGroup::Midlight, backgroundColor.light(110) ); + pal.setColor( (TQPalette::ColorGroup)i, TQColorGroup::Button, backgroundColor ); + pal.setColor( (TQPalette::ColorGroup)i, TQColorGroup::Base, backgroundColor ); + } + } + if ( color.isValid() ) { + struct ColorSet { + TQPalette::ColorGroup cg; + TQColorGroup::ColorRole cr; + }; + const struct ColorSet toSet [] = { + { TQPalette::Active, TQColorGroup::Foreground }, + { TQPalette::Active, TQColorGroup::ButtonText }, + { TQPalette::Active, TQColorGroup::Text }, + { TQPalette::Inactive, TQColorGroup::Foreground }, + { TQPalette::Inactive, TQColorGroup::ButtonText }, + { TQPalette::Inactive, TQColorGroup::Text }, + { TQPalette::Disabled,TQColorGroup::ButtonText }, + { TQPalette::NColorGroups, TQColorGroup::NColorRoles }, + }; + const ColorSet *set = toSet; + while( set->cg != TQPalette::NColorGroups ) { + pal.setColor( set->cg, set->cr, color ); + ++set; + } + + TQColor disfg = color; + int h, s, v; + disfg.hsv( &h, &s, &v ); + if (v > 128) + // dark bg, light fg - need a darker disabled fg + disfg = disfg.dark(lowlightVal); + else if (disfg != Qt::black) + // light bg, dark fg - need a lighter disabled fg - but only if !black + disfg = disfg.light(highlightVal); + else + // black fg - use darkgray disabled fg + disfg = Qt::darkGray; + pal.setColor(TQPalette::Disabled,TQColorGroup::Foreground,disfg); + } + + m_widget->setPalette(pal); + } + else + m_widget->unsetPalette(); + // Border: + TQFrame* frame = ::tqqt_cast<TQFrame*>(m_widget); + if (frame) { + if (shouldPaintBackgroundOrBorder()) + { + frame->setFrameShape(TQFrame::NoFrame); + } + } + + } + + RenderReplaced::updateFromElement(); +} + +void RenderWidget::slotWidgetDestructed() +{ + if (m_view) + m_view->setWidgetVisible(this, false); + m_widget = 0; +} + +void RenderWidget::setStyle(RenderStyle *_style) +{ + RenderReplaced::setStyle(_style); + if(m_widget) + { + m_widget->setFont(style()->font()); + if (style()->visibility() != VISIBLE) { + if (m_view) + m_view->setWidgetVisible(this, false); + m_widget->hide(); + } + } + + // Don't paint borders if the border-style is native + // or borders are not supported on this widget + if (!canHaveBorder() || + (style()->borderLeftStyle() == BNATIVE && + style()->borderRightStyle() == BNATIVE && + style()->borderTopStyle() == BNATIVE && + style()->borderBottomStyle() == BNATIVE)) + { + setShouldPaintBackgroundOrBorder(false); + } +} + +void RenderWidget::paint(PaintInfo& paintInfo, int _tx, int _ty) +{ + _tx += m_x; + _ty += m_y; + + if (shouldPaintBackgroundOrBorder() && + (paintInfo.phase == PaintActionChildBackground || paintInfo.phase == PaintActionChildBackgrounds)) + paintBoxDecorations(paintInfo, _tx, _ty); + + if (!m_widget || !m_view || paintInfo.phase != PaintActionForeground) + return; + + // not visible or not even once layouted + if (style()->visibility() != VISIBLE || m_y <= -500000 || m_resizePending ) + return; + + if ( (_ty > paintInfo.r.bottom()) || (_ty + m_height <= paintInfo.r.top()) || + (_tx + m_width <= paintInfo.r.left()) || (_tx > paintInfo.r.right()) ) + return; + + int xPos = _tx+borderLeft()+paddingLeft(); + int yPos = _ty+borderTop()+paddingTop(); + + bool tdehtmlw = isKHTMLWidget(); + int childw = m_widget->width(); + int childh = m_widget->height(); + if ( (childw == 2000 || childh == 3072) && m_widget->inherits( "KHTMLView" ) ) { + KHTMLView *vw = static_cast<KHTMLView *>(m_widget); + int cy = m_view->contentsY(); + int ch = m_view->visibleHeight(); + + + int childx = m_view->childX( m_widget ); + int childy = m_view->childY( m_widget ); + + int xNew = xPos; + int yNew = childy; + + // tqDebug("cy=%d, ch=%d, childy=%d, childh=%d", cy, ch, childy, childh ); + if ( childh == 3072 ) { + if ( cy + ch > childy + childh ) { + yNew = cy + ( ch - childh )/2; + } else if ( cy < childy ) { + yNew = cy + ( ch - childh )/2; + } +// tqDebug("calculated yNew=%d", yNew); + } + yNew = kMin( yNew, yPos + m_height - childh ); + yNew = kMax( yNew, yPos ); + if ( yNew != childy || xNew != childx ) { + if ( vw->contentsHeight() < yNew - yPos + childh ) + vw->resizeContents( vw->contentsWidth(), yNew - yPos + childh ); + vw->setContentsPos( xNew - xPos, yNew - yPos ); + } + xPos = xNew; + yPos = yNew; + } + m_view->setWidgetVisible(this, true); + m_view->addChild(m_widget, xPos, yPos ); + m_widget->show(); + if (tdehtmlw) + paintWidget(paintInfo, m_widget, xPos, yPos); +} + +#include <tqinternal_p.h> + +// The PaintBuffer class provides a shared buffer for widget painting. +// +// It will grow to encompass the biggest widget encountered, in order to avoid +// constantly resizing. +// When it grows over maxPixelBuffering, it periodically checks if such a size +// is still needed. If not, it shrinks down to the biggest size < maxPixelBuffering +// that was requested during the overflow lapse. + +class PaintBuffer: public TQObject +{ +public: + static const int maxPixelBuffering = 320*200; + static const int leaseTime = 20*1000; + + static TQPixmap *grab( TQSize s = TQSize() ) { + if (!m_inst) + m_inst = new PaintBuffer; + return m_inst->getBuf( s ); + } + static void release() { m_inst->m_grabbed = false; } +protected: + PaintBuffer(): m_overflow(false), m_grabbed(false), + m_timer(0), m_resetWidth(0), m_resetHeight(0) {}; + void timerEvent(TQTimerEvent* e) { + assert( m_timer == e->timerId() ); + if (m_grabbed) + return; + m_buf.resize(m_resetWidth, m_resetHeight); + m_resetWidth = m_resetHeight = 0; + killTimer( m_timer ); + m_timer = 0; + } + + TQPixmap *getBuf( TQSize s ) { + assert( !m_grabbed ); + if (s.isEmpty()) + return 0; + + m_grabbed = true; + bool cur_overflow = false; + + int nw = kMax(m_buf.width(), s.width()); + int nh = kMax(m_buf.height(), s.height()); + + if (!m_overflow && (nw*nh > maxPixelBuffering)) + cur_overflow = true; + + if (nw != m_buf.width() || nh != m_buf.height()) + m_buf.resize(nw, nh); + + if (cur_overflow) { + m_overflow = true; + m_timer = startTimer( leaseTime ); + } else if (m_overflow) { + if( s.width()*s.height() > maxPixelBuffering ) { + killTimer( m_timer ); + m_timer = startTimer( leaseTime ); + } else { + if (s.width() > m_resetWidth) + m_resetWidth = s.width(); + if (s.height() > m_resetHeight) + m_resetHeight = s.height(); + } + } + return &m_buf; + } +private: + static PaintBuffer* m_inst; + TQPixmap m_buf; + bool m_overflow; + bool m_grabbed; + int m_timer; + int m_resetWidth; + int m_resetHeight; +}; + +PaintBuffer *PaintBuffer::m_inst = 0; + +static void copyWidget(const TQRect& r, TQPainter *p, TQWidget *widget, int tx, int ty) +{ + if (r.isNull() || r.isEmpty() ) + return; + TQRegion blit(r); + TQValueVector<TQWidget*> cw; + TQValueVector<TQRect> cr; + + if (!widget->childrenListObject().isEmpty()) { + // build region + TQObjectList childWidgets = widget->childrenListObject(); + TQObjectListIterator it(childWidgets); + for (; it.current(); ++it) { + TQWidget* const w = ::tqqt_cast<TQWidget *>(it.current()); + if ( w && !w->isTopLevel() && !w->isHidden()) { + TQRect r2 = w->geometry(); + blit -= r2; + r2 = r2.intersect( r ); + r2.moveBy(-w->x(), -w->y()); + cr.append(r2); + cw.append(w); + } + } + } + TQMemArray<TQRect> br = blit.rects(); + + const int cnt = br.size(); + const bool external = p->device()->isExtDev(); + TQPixmap* const pm = PaintBuffer::grab( widget->size() ); + if (!pm) + { + kdWarning(6040) << "Rendering widget [ " << widget->className() << " ] failed due to invalid size." << endl; + return; + } + + // fill background + if ( external ) { + // even hackier! + TQPainter pt( pm ); + const TQColor c = widget->colorGroup().base(); + for (int i = 0; i < cnt; ++i) + pt.fillRect( br[i], c ); + } else { + TQRect dr; + for (int i = 0; i < cnt; ++i ) { + dr = br[i]; + dr.moveBy( tx, ty ); + dr = p->xForm( dr ); + bitBlt(pm, br[i].topLeft(), p->device(), dr); + } + } + + // send paint event + TQPainter::redirect(widget, pm); + TQPaintEvent e( r, false ); + TQApplication::sendEvent( widget, &e ); + TQPainter::redirect(widget, 0); + + // transfer result + if ( external ) + for ( int i = 0; i < cnt; ++i ) + p->drawPixmap(TQPoint(tx+br[i].x(), ty+br[i].y()), *pm, br[i]); + else + for ( int i = 0; i < cnt; ++i ) + bitBlt(p->device(), p->xForm( TQPoint(tx, ty) + br[i].topLeft() ), pm, br[i]); + + // cleanup and recurse + PaintBuffer::release(); + TQValueVector<TQWidget*>::iterator cwit = cw.begin(); + TQValueVector<TQWidget*>::iterator cwitEnd = cw.end(); + TQValueVector<TQRect>::const_iterator crit = cr.begin(); + for (; cwit != cwitEnd; ++cwit, ++crit) + copyWidget(*crit, p, *cwit, tx+(*cwit)->x(), ty+(*cwit)->y()); +} + +void RenderWidget::paintWidget(PaintInfo& pI, TQWidget *widget, int tx, int ty) +{ + TQPainter* const p = pI.p; + allowWidgetPaintEvents = true; + + const bool dsbld = TQSharedDoubleBuffer::isDisabled(); + TQSharedDoubleBuffer::setDisabled(true); + TQRect rr = pI.r; + rr.moveBy(-tx, -ty); + const TQRect r = widget->rect().intersect( rr ); + copyWidget(r, p, widget, tx, ty); + TQSharedDoubleBuffer::setDisabled(dsbld); + + allowWidgetPaintEvents = false; +} + +bool RenderWidget::eventFilter(TQObject* /*o*/, TQEvent* e) +{ + // no special event processing if this is a frame (in which case KHTMLView handles it all) + if ( ::tqqt_cast<KHTMLView *>( m_widget ) ) + return false; + if ( !element() ) return true; + + + static bool directToWidget = false; + if (directToWidget) { + //We're trying to get the event to the widget + //promptly. So get out of here.. + return false; + } + + ref(); + element()->ref(); + + bool filtered = false; + + //kdDebug() << "RenderWidget::eventFilter type=" << e->type() << endl; + switch(e->type()) { + case TQEvent::FocusOut: + // First, forward it to the widget, so that Qt gets a precise + // state of the focus before pesky JS can try changing it.. + directToWidget = true; + TQApplication::sendEvent(m_widget, e); + directToWidget = false; + filtered = true; //We already delivered it! + + // Don't count popup as a valid reason for losing the focus + // (example: opening the options of a select combobox shouldn't emit onblur) + if ( TQT_TQFOCUSEVENT(e)->reason() != TQFocusEvent::Popup ) + handleFocusOut(); + break; + case TQEvent::FocusIn: + //As above, forward to the widget first... + directToWidget = true; + TQApplication::sendEvent(m_widget, e); + directToWidget = false; + filtered = true; //We already delivered it! + + //kdDebug(6000) << "RenderWidget::eventFilter captures FocusIn" << endl; + element()->getDocument()->setFocusNode(element()); +// if ( isEditable() ) { +// KHTMLPartBrowserExtension *ext = static_cast<KHTMLPartBrowserExtension *>( element()->view->part()->browserExtension() ); +// if ( ext ) ext->editableWidgetFocused( m_widget ); +// } + break; + case TQEvent::KeyPress: + case TQEvent::KeyRelease: + // TODO this seems wrong - Qt events are not correctly translated to DOM ones, + // like in KHTMLView::dispatchKeyEvent() + if (element()->dispatchKeyEvent(TQT_TQKEYEVENT(e),false)) + filtered = true; + break; + + case TQEvent::Wheel: + if (widget()->parentWidget() == view()->viewport()) { + // don't allow the widget to react to wheel event unless its + // currently focused. this avoids accidentally changing a select box + // or something while wheeling a webpage. + if (tqApp->focusWidget() != widget() && + widget()->focusPolicy() <= TQ_StrongFocus) { + TQT_TQWHEELEVENT(e)->ignore(); + TQApplication::sendEvent(view(), e); + filtered = true; + } + } + break; + default: + break; + }; + + element()->deref(); + + // stop processing if the widget gets deleted, but continue in all other cases + if (hasOneRef()) + filtered = true; + deref(); + + return filtered; +} + +void RenderWidget::EventPropagator::sendEvent(TQEvent *e) { + switch(e->type()) { + case TQEvent::MouseButtonPress: + mousePressEvent(TQT_TQMOUSEEVENT(e)); + break; + case TQEvent::MouseButtonRelease: + mouseReleaseEvent(TQT_TQMOUSEEVENT(e)); + break; + case TQEvent::MouseButtonDblClick: + mouseDoubleClickEvent(TQT_TQMOUSEEVENT(e)); + break; + case TQEvent::MouseMove: + mouseMoveEvent(TQT_TQMOUSEEVENT(e)); + break; + case TQEvent::KeyPress: + keyPressEvent(TQT_TQKEYEVENT(e)); + break; + case TQEvent::KeyRelease: + keyReleaseEvent(TQT_TQKEYEVENT(e)); + break; + default: + break; + } +} + +void RenderWidget::ScrollViewEventPropagator::sendEvent(TQEvent *e) { + switch(e->type()) { + case TQEvent::MouseButtonPress: + viewportMousePressEvent(TQT_TQMOUSEEVENT(e)); + break; + case TQEvent::MouseButtonRelease: + viewportMouseReleaseEvent(TQT_TQMOUSEEVENT(e)); + break; + case TQEvent::MouseButtonDblClick: + viewportMouseDoubleClickEvent(TQT_TQMOUSEEVENT(e)); + break; + case TQEvent::MouseMove: + viewportMouseMoveEvent(TQT_TQMOUSEEVENT(e)); + break; + case TQEvent::KeyPress: + keyPressEvent(TQT_TQKEYEVENT(e)); + break; + case TQEvent::KeyRelease: + keyReleaseEvent(TQT_TQKEYEVENT(e)); + break; + default: + break; + } +} + +bool RenderWidget::handleEvent(const DOM::EventImpl& ev) +{ + bool ret = false; + switch(ev.id()) { + case EventImpl::MOUSEDOWN_EVENT: + case EventImpl::MOUSEUP_EVENT: + case EventImpl::MOUSEMOVE_EVENT: { + if (!ev.isMouseEvent()) break; + const MouseEventImpl &me = static_cast<const MouseEventImpl &>(ev); + TQMouseEvent* const qme = me.qEvent(); + + int absx = 0; + int absy = 0; + + absolutePosition(absx, absy); + TQPoint p(me.clientX() - absx + m_view->contentsX(), + me.clientY() - absy + m_view->contentsY()); + TQMouseEvent::Type type; + int button = 0; + int state = 0; + + if (qme) { + button = qme->button(); + state = qme->state(); + type = qme->type(); + } else { + switch(me.id()) { + case EventImpl::MOUSEDOWN_EVENT: + type = TQMouseEvent::MouseButtonPress; + break; + case EventImpl::MOUSEUP_EVENT: + type = TQMouseEvent::MouseButtonRelease; + break; + case EventImpl::MOUSEMOVE_EVENT: + default: + type = TQMouseEvent::MouseMove; + break; + } + switch (me.button()) { + case 0: + button = Qt::LeftButton; + break; + case 1: + button = Qt::MidButton; + break; + case 2: + button = Qt::RightButton; + break; + default: + break; + } + if (me.ctrlKey()) + state |= ControlButton; + if (me.altKey()) + state |= AltButton; + if (me.shiftKey()) + state |= ShiftButton; + if (me.metaKey()) + state |= MetaButton; + } + +// kdDebug(6000) << "sending event to widget " +// << " pos=" << p << " type=" << type +// << " button=" << button << " state=" << state << endl; + TQMouseEvent e(type, p, button, state); + TQScrollView * sc = ::tqqt_cast<TQScrollView*>(m_widget); + if (sc && !::tqqt_cast<TQListBox*>(m_widget)) + static_cast<ScrollViewEventPropagator *>(sc)->sendEvent(TQT_TQEVENT(&e)); + else + static_cast<EventPropagator *>(m_widget)->sendEvent(TQT_TQEVENT(&e)); + ret = e.isAccepted(); + break; + } + case EventImpl::KEYDOWN_EVENT: + // do nothing; see the mapping table below + break; + case EventImpl::KEYUP_EVENT: { + if (!ev.isKeyRelatedEvent()) break; + + const KeyEventBaseImpl& domKeyEv = static_cast<const KeyEventBaseImpl &>(ev); + if (domKeyEv.isSynthetic() && !acceptsSyntheticEvents()) break; + + TQKeyEvent* const ke = domKeyEv.qKeyEvent(); + static_cast<EventPropagator *>(m_widget)->sendEvent(TQT_TQEVENT(ke)); + ret = ke->isAccepted(); + break; + } + case EventImpl::KEYPRESS_EVENT: { + if (!ev.isKeyRelatedEvent()) break; + + const KeyEventBaseImpl& domKeyEv = static_cast<const KeyEventBaseImpl &>(ev); + if (domKeyEv.isSynthetic() && !acceptsSyntheticEvents()) break; + + // See KHTMLView::dispatchKeyEvent: autorepeat is just keypress in the DOM + // but it's keyrelease+keypress in Qt. So here we do the inverse mapping as + // the one done in KHTMLView: generate two events for one DOM auto-repeat keypress. + // Similarly, DOM keypress events with non-autorepeat Qt event do nothing here, + // because the matching Qt keypress event was already sent from DOM keydown event. + + // Reverse drawing as the one in KHTMLView: + // DOM: Down Press | Press | Up + // Qt: (nothing) Press | Release(autorepeat) + Press(autorepeat) | Release + // + // Qt::KeyPress is sent for DOM keypress and not DOM keydown to allow + // sites to block a key with onkeypress, #99749 + + TQKeyEvent* const ke = domKeyEv.qKeyEvent(); + if (ke->isAutoRepeat()) { + TQKeyEvent releaseEv( TQEvent::KeyRelease, ke->key(), ke->ascii(), ke->state(), + ke->text(), ke->isAutoRepeat(), ke->count() ); + static_cast<EventPropagator *>(m_widget)->sendEvent(TQT_TQEVENT(&releaseEv)); + } + static_cast<EventPropagator *>(m_widget)->sendEvent(TQT_TQEVENT(ke)); + ret = ke->isAccepted(); + break; + } + case EventImpl::MOUSEOUT_EVENT: { + TQEvent moe( TQEvent::Leave ); + TQApplication::sendEvent(m_widget, &moe); + break; + } + case EventImpl::MOUSEOVER_EVENT: { + TQEvent moe( TQEvent::Enter ); + TQApplication::sendEvent(m_widget, &moe); + view()->part()->resetHoverText(); + break; + } + default: + break; + } + return ret; +} + +void RenderWidget::deref() +{ + if (_ref) _ref--; +// tqDebug( "deref(%p): width get count is %d", this, _ref); + if (!_ref) { + tdehtml::SharedPtr<RenderArena> guard(m_arena); //Since delete on us gets called -first-, + //before the arena free + arenaDelete(m_arena.get()); + } +} + +FindSelectionResult RenderReplaced::checkSelectionPoint(int _x, int _y, int _tx, int _ty, DOM::NodeImpl*& node, int &offset, SelPointState &) +{ +#if 0 + kdDebug(6040) << "RenderReplaced::checkSelectionPoint(_x="<<_x<<",_y="<<_y<<",_tx="<<_tx<<",_ty="<<_ty<<")" << endl + << "xPos: " << xPos() << " yPos: " << yPos() << " width: " << width() << " height: " << height() << endl + << "_ty + yPos: " << (_ty + yPos()) << " + height: " << (_ty + yPos() + height()) << "; _tx + xPos: " << (_tx + xPos()) << " + width: " << (_tx + xPos() + width()) << endl; +#endif + node = element(); + offset = 0; + + if ( _y < _ty + yPos() ) + return SelectionPointBefore; // above -> before + + if ( _y > _ty + yPos() + height() ) { + // below -> after + // Set the offset to the max + offset = 1; + return SelectionPointAfter; + } + if ( _x > _tx + xPos() + width() ) { + // to the right + // ### how to regard bidi in replaced elements? (LS) + offset = 1; + return SelectionPointAfterInLine; + } + + // The Y matches, check if we're on the left + if ( _x < _tx + xPos() ) { + // ### how to regard bidi in replaced elements? (LS) + return SelectionPointBeforeInLine; + } + + offset = _x > _tx + xPos() + width()/2; + return SelectionPointInside; +} + +#ifdef ENABLE_DUMP +void RenderWidget::dump(TQTextStream &stream, const TQString &ind) const +{ + RenderReplaced::dump(stream,ind); + if ( widget() ) + stream << " color=" << widget()->foregroundColor().name() + << " bg=" << widget()->backgroundColor().name(); + else + stream << " null widget"; +} +#endif + +#include "render_replaced.moc" + diff --git a/tdehtml/rendering/render_replaced.h b/tdehtml/rendering/render_replaced.h new file mode 100644 index 000000000..c1369bfc0 --- /dev/null +++ b/tdehtml/rendering/render_replaced.h @@ -0,0 +1,169 @@ +/* + * This file is part of the HTML widget for KDE. + * + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef render_replaced_h +#define render_replaced_h + +#include "rendering/render_block.h" +#include <tqobject.h> +#include <tqscrollview.h> + +class KHTMLView; +class TQWidget; + +namespace DOM +{ + class MouseEventImpl; +} + +namespace tdehtml { + +class RenderReplaced : public RenderBox +{ +public: + RenderReplaced(DOM::NodeImpl* node); + + virtual const char *renderName() const { return "RenderReplaced"; } + virtual bool isRenderReplaced() const { return true; } + + virtual bool childAllowed() const { return false; } + + virtual void calcMinMaxWidth(); + + virtual short intrinsicWidth() const { return m_intrinsicWidth; } + virtual int intrinsicHeight() const { return m_intrinsicHeight; } + + void setIntrinsicWidth(int w) { m_intrinsicWidth = w; } + void setIntrinsicHeight(int h) { m_intrinsicHeight = h; } + + virtual void position(InlineBox*, int, int, bool); + + // Return before, after (offset set to max), or inside the replaced element, + // at @p offset + virtual FindSelectionResult checkSelectionPoint( int _x, int _y, int _tx, int _ty, + DOM::NodeImpl*& node, int & offset, + SelPointState & ); + + /** returns the lowest possible value the caret offset may have to + * still point to a valid position. + * + * Returns 0. + */ + virtual long minOffset() const { return 0; } + /** returns the highest possible value the caret offset may have to + * still point to a valid position. + * + * Returns 0. + */ + virtual long maxOffset() const { return 0; } + +protected: + short m_intrinsicWidth; + short m_intrinsicHeight; +}; + + +class RenderWidget : public TQObject, public RenderReplaced, public tdehtml::Shared<RenderWidget> +{ + Q_OBJECT +public: + RenderWidget(DOM::NodeImpl* node); + virtual ~RenderWidget(); + + virtual void setStyle(RenderStyle *style); + virtual void paint( PaintInfo& i, int tx, int ty ); + virtual bool isWidget() const { return true; }; + + virtual bool isFrame() const { return false; } + + virtual void detach( ); + virtual void layout( ); + + virtual void updateFromElement(); + + TQWidget *widget() const { return m_widget; } + KHTMLView* view() const { return m_view; } + + void deref(); + + void cancelPendingResize(); + bool needsMask() const { return m_needsMask; } + + static void paintWidget(PaintInfo& pI, TQWidget *widget, int tx, int ty); + virtual bool handleEvent(const DOM::EventImpl& ev); + +#ifdef ENABLE_DUMP + virtual void dump(TQTextStream &stream, const TQString &ind) const; +#endif + + // for ECMA to flush all pending resizes + KDE_EXPORT static void flushWidgetResizes(); + +public slots: + void slotWidgetDestructed(); + bool isKHTMLWidget() const { return m_isKHTMLWidget; } + +protected: + virtual bool canHaveBorder() const { return false; } + + virtual bool acceptsSyntheticEvents() const { return true; } + + virtual void handleFocusOut() {} + bool event( TQEvent *e ); + + bool eventFilter(TQObject* /*o*/, TQEvent* e); + void setQWidget(TQWidget *widget); + void resizeWidget( int w, int h ); + + TQWidget *m_widget; + KHTMLView* m_view; + + //Because we mess with normal detach due to ref/deref, + //we need to keep track of the arena ourselves + //so it doesn't get yanked from us, etc. + SharedPtr<RenderArena> m_arena; + + bool m_resizePending; + bool m_discardResizes; + bool m_isKHTMLWidget; + bool m_needsMask; + +public: + virtual int borderTop() const { return canHaveBorder() ? RenderReplaced::borderTop() : 0; } + virtual int borderBottom() const { return canHaveBorder() ? RenderReplaced::borderBottom() : 0; } + virtual int borderLeft() const { return canHaveBorder() ? RenderReplaced::borderLeft() : 0; } + virtual int borderRight() const { return canHaveBorder() ? RenderReplaced::borderRight() : 0; } + + class EventPropagator : public TQWidget { + public: + void sendEvent(TQEvent *e); + }; + class ScrollViewEventPropagator : public TQScrollView { + public: + void sendEvent(TQEvent *e); + }; +}; + +extern bool allowWidgetPaintEvents; + +} + +#endif diff --git a/tdehtml/rendering/render_style.cpp b/tdehtml/rendering/render_style.cpp new file mode 100644 index 000000000..a2ae70948 --- /dev/null +++ b/tdehtml/rendering/render_style.cpp @@ -0,0 +1,1301 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org) + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * Copyright (C) 2002-2003 Dirk Mueller (mueller@kde.org) + * Copyright (C) 2002-2005 Apple Computer, Inc. + * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "xml/dom_stringimpl.h" +#include "css/cssstyleselector.h" +#include "css/css_valueimpl.h" +#include "render_style.h" + +#include "kdebug.h" + +using namespace tdehtml; +using namespace DOM; + +/* CSS says Fixed for the default padding value, but we treat variable as 0 padding anyways, and like + * this is works fine for table paddings aswell + */ +StyleSurroundData::StyleSurroundData() + : margin( Fixed ), padding( Variable ) +{ +} + +StyleSurroundData::StyleSurroundData(const StyleSurroundData& o ) + : Shared<StyleSurroundData>(), + offset( o.offset ), margin( o.margin ), padding( o.padding ), + border( o.border ) +{ +} + +bool StyleSurroundData::operator==(const StyleSurroundData& o) const +{ + return offset==o.offset && margin==o.margin && + padding==o.padding && border==o.border; +} + +StyleBoxData::StyleBoxData() + : z_index( 0 ), z_auto( true ) +{ + min_width = min_height = RenderStyle::initialMinSize(); + max_width = max_height = RenderStyle::initialMaxSize(); + box_sizing = RenderStyle::initialBoxSizing(); +} + +StyleBoxData::StyleBoxData(const StyleBoxData& o ) + : Shared<StyleBoxData>(), + width( o.width ), height( o.height ), + min_width( o.min_width ), max_width( o.max_width ), + min_height ( o.min_height ), max_height( o.max_height ), + box_sizing( o.box_sizing), + z_index( o.z_index ), z_auto( o.z_auto ) +{ +} + +bool StyleBoxData::operator==(const StyleBoxData& o) const +{ + return + width == o.width && + height == o.height && + min_width == o.min_width && + max_width == o.max_width && + min_height == o.min_height && + max_height == o.max_height && + box_sizing == o.box_sizing && + z_index == o.z_index && + z_auto == o.z_auto; +} + +StyleVisualData::StyleVisualData() + : textDecoration(RenderStyle::initialTextDecoration()), + palette( TQApplication::palette() ) +{ +} + +StyleVisualData::~StyleVisualData() { +} + +StyleVisualData::StyleVisualData(const StyleVisualData& o ) + : Shared<StyleVisualData>(), + clip( o.clip ), textDecoration(o.textDecoration), + palette( o.palette ) +{ +} + +BackgroundLayer::BackgroundLayer() +:m_image(RenderStyle::initialBackgroundImage()), + m_bgAttachment(RenderStyle::initialBackgroundAttachment()), + m_bgClip(RenderStyle::initialBackgroundClip()), + m_bgOrigin(RenderStyle::initialBackgroundOrigin()), + m_bgRepeat(RenderStyle::initialBackgroundRepeat()), + m_backgroundSize(RenderStyle::initialBackgroundSize()), + m_next(0) +{ + m_imageSet = m_attachmentSet = m_clipSet = m_originSet = + m_repeatSet = m_xPosSet = m_yPosSet = m_backgroundSizeSet = false; +} + +BackgroundLayer::BackgroundLayer(const BackgroundLayer& o) +{ + m_next = o.m_next ? new BackgroundLayer(*o.m_next) : 0; + m_image = o.m_image; + m_xPosition = o.m_xPosition; + m_yPosition = o.m_yPosition; + m_bgAttachment = o.m_bgAttachment; + m_bgClip = o.m_bgClip; + m_bgOrigin = o.m_bgOrigin; + m_bgRepeat = o.m_bgRepeat; + m_backgroundSize = o.m_backgroundSize; + m_imageSet = o.m_imageSet; + m_attachmentSet = o.m_attachmentSet; + m_clipSet = o.m_clipSet; + m_originSet = o.m_originSet; + m_repeatSet = o.m_repeatSet; + m_xPosSet = o.m_xPosSet; + m_yPosSet = o.m_yPosSet; + m_backgroundSizeSet = o.m_backgroundSizeSet; +} + +BackgroundLayer::~BackgroundLayer() +{ + delete m_next; +} + +BackgroundLayer& BackgroundLayer::operator=(const BackgroundLayer& o) { + if (m_next != o.m_next) { + delete m_next; + m_next = o.m_next ? new BackgroundLayer(*o.m_next) : 0; + } + + m_image = o.m_image; + m_xPosition = o.m_xPosition; + m_yPosition = o.m_yPosition; + m_bgAttachment = o.m_bgAttachment; + m_bgClip = o.m_bgClip; + m_bgOrigin = o.m_bgOrigin; + m_bgRepeat = o.m_bgRepeat; + m_backgroundSize = o.m_backgroundSize; + + m_imageSet = o.m_imageSet; + m_attachmentSet = o.m_attachmentSet; + m_originSet = o.m_originSet; + m_repeatSet = o.m_repeatSet; + m_xPosSet = o.m_xPosSet; + m_yPosSet = o.m_yPosSet; + m_backgroundSizeSet = o.m_backgroundSizeSet; + + return *this; +} + +bool BackgroundLayer::operator==(const BackgroundLayer& o) const { + return m_image == o.m_image && m_xPosition == o.m_xPosition && m_yPosition == o.m_yPosition && + m_bgAttachment == o.m_bgAttachment && m_bgClip == o.m_bgClip && m_bgOrigin == o.m_bgOrigin && m_bgRepeat == o.m_bgRepeat && + m_backgroundSize.width == o.m_backgroundSize.width && m_backgroundSize.height == o.m_backgroundSize.height && + m_imageSet == o.m_imageSet && m_attachmentSet == o.m_attachmentSet && m_repeatSet == o.m_repeatSet && + m_xPosSet == o.m_xPosSet && m_yPosSet == o.m_yPosSet && m_backgroundSizeSet == o.m_backgroundSizeSet && + ((m_next && o.m_next) ? *m_next == *o.m_next : m_next == o.m_next); +} + +void BackgroundLayer::fillUnsetProperties() +{ + BackgroundLayer* curr; + for (curr = this; curr && curr->isBackgroundImageSet(); curr = curr->next()); + if (curr && curr != this) { + // We need to fill in the remaining values with the pattern specified. + for (BackgroundLayer* pattern = this; curr; curr = curr->next()) { + curr->m_image = pattern->m_image; + pattern = pattern->next(); + if (pattern == curr || !pattern) + pattern = this; + } + } + + for (curr = this; curr && curr->isBackgroundXPositionSet(); curr = curr->next()); + if (curr && curr != this) { + // We need to fill in the remaining values with the pattern specified. + for (BackgroundLayer* pattern = this; curr; curr = curr->next()) { + curr->m_xPosition = pattern->m_xPosition; + pattern = pattern->next(); + if (pattern == curr || !pattern) + pattern = this; + } + } + + for (curr = this; curr && curr->isBackgroundYPositionSet(); curr = curr->next()); + if (curr && curr != this) { + // We need to fill in the remaining values with the pattern specified. + for (BackgroundLayer* pattern = this; curr; curr = curr->next()) { + curr->m_yPosition = pattern->m_yPosition; + pattern = pattern->next(); + if (pattern == curr || !pattern) + pattern = this; + } + } + + for (curr = this; curr && curr->isBackgroundAttachmentSet(); curr = curr->next()); + if (curr && curr != this) { + // We need to fill in the remaining values with the pattern specified. + for (BackgroundLayer* pattern = this; curr; curr = curr->next()) { + curr->m_bgAttachment = pattern->m_bgAttachment; + pattern = pattern->next(); + if (pattern == curr || !pattern) + pattern = this; + } + } + + for (curr = this; curr && curr->isBackgroundClipSet(); curr = curr->next()); + if (curr && curr != this) { + // We need to fill in the remaining values with the pattern specified. + for (BackgroundLayer* pattern = this; curr; curr = curr->next()) { + curr->m_bgClip = pattern->m_bgClip; + pattern = pattern->next(); + if (pattern == curr || !pattern) + pattern = this; + } + } + + for (curr = this; curr && curr->isBackgroundOriginSet(); curr = curr->next()); + if (curr && curr != this) { + // We need to fill in the remaining values with the pattern specified. + for (BackgroundLayer* pattern = this; curr; curr = curr->next()) { + curr->m_bgOrigin = pattern->m_bgOrigin; + pattern = pattern->next(); + if (pattern == curr || !pattern) + pattern = this; + } + } + + for (curr = this; curr && curr->isBackgroundRepeatSet(); curr = curr->next()); + if (curr && curr != this) { + // We need to fill in the remaining values with the pattern specified. + for (BackgroundLayer* pattern = this; curr; curr = curr->next()) { + curr->m_bgRepeat = pattern->m_bgRepeat; + pattern = pattern->next(); + if (pattern == curr || !pattern) + pattern = this; + } + } + + for (curr = this; curr && curr->isBackgroundSizeSet(); curr = curr->next()); + if (curr && curr != this) { + // We need to fill in the remaining values with the pattern specified. + for (BackgroundLayer* pattern = this; curr; curr = curr->next()) { + curr->m_backgroundSize = pattern->m_backgroundSize; + pattern = pattern->next(); + if (pattern == curr || !pattern) + pattern = this; + } + } +} + +void BackgroundLayer::cullEmptyLayers() +{ + BackgroundLayer *next; + for (BackgroundLayer *p = this; p; p = next) { + next = p->m_next; + if (next && !next->isBackgroundImageSet() && + !next->isBackgroundXPositionSet() && !next->isBackgroundYPositionSet() && + !next->isBackgroundAttachmentSet() && !next->isBackgroundClipSet() && + !next->isBackgroundOriginSet() && !next->isBackgroundRepeatSet() && + !next->isBackgroundSizeSet()) { + delete next; + p->m_next = 0; + break; + } + } +} + +StyleBackgroundData::StyleBackgroundData() +{} + +StyleBackgroundData::StyleBackgroundData(const StyleBackgroundData& o) + : Shared<StyleBackgroundData>(), m_background(o.m_background), m_outline(o.m_outline) +{} + +bool StyleBackgroundData::operator==(const StyleBackgroundData& o) const +{ + return m_background == o.m_background && m_color == o.m_color && m_outline == o.m_outline; +} + +StyleGeneratedData::StyleGeneratedData() : Shared<StyleGeneratedData>(), content(0), counter_reset(0), counter_increment(0) {} + +StyleGeneratedData::~StyleGeneratedData() +{ + if (counter_reset) counter_reset->deref(); + if (counter_increment) counter_increment->deref(); + delete content; +} + +StyleGeneratedData::StyleGeneratedData(const StyleGeneratedData& o) + : Shared<StyleGeneratedData>(), content(0), + counter_reset(o.counter_reset), counter_increment(o.counter_increment) +{ + if (o.content) content = new ContentData(*o.content); + if (counter_reset) counter_reset->ref(); + if (counter_increment) counter_increment->ref(); +} + +bool StyleGeneratedData::contentDataEquivalent(const StyleGeneratedData* otherStyle) const +{ + ContentData* c1 = content; + ContentData* c2 = otherStyle->content; + + while (c1 && c2) { + if (c1->_contentType != c2->_contentType) + return false; + if (c1->_contentType == CONTENT_TEXT) { + DOM::DOMString c1Str(c1->_content.text); + DOM::DOMString c2Str(c2->_content.text); + if (c1Str != c2Str) + return false; + } + else if (c1->_contentType == CONTENT_OBJECT) { + if (c1->_content.object != c2->_content.object) + return false; + } + else if (c1->_contentType == CONTENT_COUNTER) { + if (c1->_content.counter != c2->_content.counter) + return false; + } + else if (c1->_contentType == CONTENT_QUOTE) { + if (c1->_content.quote != c2->_content.quote) + return false; + } + + c1 = c1->_nextContent; + c2 = c2->_nextContent; + } + + return !c1 && !c2; +} + +static bool compareCounterActList(const CSSValueListImpl* ca, const CSSValueListImpl* cb) { + // weeee.... + CSSValueListImpl* a = const_cast<CSSValueListImpl*>(ca); + CSSValueListImpl* b = const_cast<CSSValueListImpl*>(cb); + + if (!a && !b) return true; + if (!a || !b) return false; + if (a->length() != b->length()) return false; + for(uint i=0; i< a->length(); i++) { + CSSValueImpl *ai = a->item(i); + CSSValueImpl *bi = b->item(i); + assert(ai && ai->cssValueType() == CSSValue::CSS_CUSTOM); + assert(bi && bi->cssValueType() == CSSValue::CSS_CUSTOM); + CounterActImpl* caa = static_cast<CounterActImpl*>(ai); + CounterActImpl* cab = static_cast<CounterActImpl*>(bi); + if (caa->value() != cab->value()) return false; + if (caa->counter() != cab->counter()) return false; + } + return true; +} + +bool StyleGeneratedData::counterDataEquivalent(const StyleGeneratedData* otherStyle) const +{ + return compareCounterActList(counter_reset, otherStyle->counter_reset) && + compareCounterActList(counter_increment, otherStyle->counter_increment); +} + +bool StyleGeneratedData::operator==(const StyleGeneratedData& o) const +{ + return contentDataEquivalent(&o) && counterDataEquivalent(&o); +} + +StyleMarqueeData::StyleMarqueeData() +{ + increment = RenderStyle::initialMarqueeIncrement(); + speed = RenderStyle::initialMarqueeSpeed(); + direction = RenderStyle::initialMarqueeDirection(); + behavior = RenderStyle::initialMarqueeBehavior(); + loops = RenderStyle::initialMarqueeLoopCount(); +} + +StyleMarqueeData::StyleMarqueeData(const StyleMarqueeData& o) +:Shared<StyleMarqueeData>(), increment(o.increment), speed(o.speed), loops(o.loops), + behavior(o.behavior), direction(o.direction) +{} + +bool StyleMarqueeData::operator==(const StyleMarqueeData& o) const +{ + return (increment == o.increment && speed == o.speed && direction == o.direction && + behavior == o.behavior && loops == o.loops); +} + +StyleCSS3NonInheritedData::StyleCSS3NonInheritedData() +:Shared<StyleCSS3NonInheritedData>() +, opacity(RenderStyle::initialOpacity()) +{ +} + +StyleCSS3NonInheritedData::StyleCSS3NonInheritedData(const StyleCSS3NonInheritedData& o) +:Shared<StyleCSS3NonInheritedData>(), + opacity(o.opacity), +#ifdef APPLE_CHANGES + flexibleBox(o.flexibleBox), +#endif + marquee(o.marquee) +{ +} + +bool StyleCSS3NonInheritedData::operator==(const StyleCSS3NonInheritedData& o) const +{ + return + opacity == o.opacity && +#ifdef APPLE_CHANGES + flexibleBox == o.flexibleBox && +#endif + marquee == o.marquee; +} + +StyleCSS3InheritedData::StyleCSS3InheritedData() +:Shared<StyleCSS3InheritedData>(), textShadow(0), wordWrap(RenderStyle::initialWordWrap()) +#ifdef APPLE_CHANGES +, userModify(READ_ONLY), textSizeAdjust(RenderStyle::initialTextSizeAdjust()) +#endif +{ + +} + +StyleCSS3InheritedData::StyleCSS3InheritedData(const StyleCSS3InheritedData& o) +:Shared<StyleCSS3InheritedData>() +{ + textShadow = o.textShadow ? new ShadowData(*o.textShadow) : 0; + wordWrap = o.wordWrap; +#ifdef APPLE_CHANGES + userModify = o.userModify; + textSizeAdjust = o.textSizeAdjust; +#endif +} + +StyleCSS3InheritedData::~StyleCSS3InheritedData() +{ + delete textShadow; +} + +bool StyleCSS3InheritedData::operator==(const StyleCSS3InheritedData& o) const +{ + return shadowDataEquivalent(o) && (wordWrap == o.wordWrap) +#ifdef APPLE_CHANGES + && (userModify == o.userModify) && (textSizeAdjust == o.textSizeAdjust) +#endif + ; +} + +bool StyleCSS3InheritedData::shadowDataEquivalent(const StyleCSS3InheritedData& o) const +{ + if (!textShadow && o.textShadow || textShadow && !o.textShadow) + return false; + if (textShadow && o.textShadow && (*textShadow != *o.textShadow)) + return false; + return true; +} + +StyleInheritedData::StyleInheritedData() + : indent( RenderStyle::initialTextIndent() ), line_height( RenderStyle::initialLineHeight() ), + style_image( RenderStyle::initialListStyleImage() ), + font(), color( RenderStyle::initialColor() ), + border_hspacing( RenderStyle::initialBorderHorizontalSpacing() ), + border_vspacing( RenderStyle::initialBorderVerticalSpacing() ), + widows( RenderStyle::initialWidows() ), orphans( RenderStyle::initialOrphans() ), + quotes(0) +{ +} + +StyleInheritedData::~StyleInheritedData() +{ + if (quotes) quotes->deref(); +} + +StyleInheritedData::StyleInheritedData(const StyleInheritedData& o ) + : Shared<StyleInheritedData>(), + indent( o.indent ), line_height( o.line_height ), style_image( o.style_image ), + font( o.font ), color( o.color ), + border_hspacing( o.border_hspacing ), + border_vspacing( o.border_vspacing ), + widows(o.widows), orphans(o.orphans) +{ + quotes = o.quotes; + if (quotes) quotes->ref(); +} + +bool StyleInheritedData::operator==(const StyleInheritedData& o) const +{ + return + indent == o.indent && + line_height == o.line_height && + border_hspacing == o.border_hspacing && + border_vspacing == o.border_vspacing && + style_image == o.style_image && + font == o.font && + color == o.color && + border_hspacing == o.border_hspacing && + border_vspacing == o.border_vspacing && + quotes == o.quotes && + widows == o.widows && + orphans == o.orphans ; + + // doesn't work because structs are not packed + //return memcmp(this, &o, sizeof(*this))==0; +} + +RenderStyle::RenderStyle() +{ +// counter++; + if (!_default) + _default = new RenderStyle(true); + + box = _default->box; + visual = _default->visual; + background = _default->background; + surround = _default->surround; + generated = _default->generated; + css3NonInheritedData = _default->css3NonInheritedData; + css3InheritedData = _default->css3InheritedData; + + inherited = _default->inherited; + + setBitDefaults(); + + pseudoStyle = 0; +} + +RenderStyle::RenderStyle(bool) +{ + setBitDefaults(); + + box.init(); + visual.init(); + background.init(); + surround.init(); + generated.init(); + css3NonInheritedData.init(); +#ifdef APPLE_CHANGES // ### yet to be merged + css3NonInheritedData.access()->flexibleBox.init(); +#endif + css3NonInheritedData.access()->marquee.init(); + css3InheritedData.init(); + inherited.init(); + + pseudoStyle = 0; +} + +RenderStyle::RenderStyle(const RenderStyle& o) + : Shared<RenderStyle>(), + inherited_flags( o.inherited_flags ), noninherited_flags( o.noninherited_flags ), + box( o.box ), visual( o.visual ), background( o.background ), surround( o.surround ), generated(o.generated), + css3NonInheritedData( o.css3NonInheritedData ), css3InheritedData( o.css3InheritedData ), + inherited( o.inherited ), pseudoStyle( 0 ) +{} + +void RenderStyle::inheritFrom(const RenderStyle* inheritParent) +{ + css3InheritedData = inheritParent->css3InheritedData; + inherited = inheritParent->inherited; + inherited_flags = inheritParent->inherited_flags; + + // Simulate ":after,:before { white-space: pre-line }" + if (styleType() == AFTER || styleType() == BEFORE) + setWhiteSpace(PRE_LINE); +} + +RenderStyle::~RenderStyle() +{ + RenderStyle *ps = pseudoStyle; + RenderStyle *prev = 0; + + while (ps) { + prev = ps; + ps = ps->pseudoStyle; + // to prevent a double deletion. + // this works only because the styles below aren't really shared + // Dirk said we need another construct as soon as these are shared + prev->pseudoStyle = 0; + prev->deref(); + } +} + +bool RenderStyle::operator==(const RenderStyle& o) const +{ +// compare everything except the pseudoStyle pointer + return (inherited_flags == o.inherited_flags && + noninherited_flags == o.noninherited_flags && + box == o.box && + visual == o.visual && + background == o.background && + surround == o.surround && + generated == o.generated && + css3NonInheritedData == o.css3NonInheritedData && + css3InheritedData == o.css3InheritedData && + inherited == o.inherited); +} + +enum EPseudoBit { NO_BIT = 0x0, + FIRST_LINE_BIT = 0x1, FIRST_LETTER_BIT = 0x2, SELECTION_BIT = 0x4, + BEFORE_BIT = 0x8, AFTER_BIT = 0x10, MARKER_BIT = 0x20, + REPLACED_BIT = 0x40 + }; + +static int pseudoBit(RenderStyle::PseudoId pseudo) +{ + switch (pseudo) { + case RenderStyle::BEFORE: + return BEFORE_BIT; + case RenderStyle::AFTER: + return AFTER_BIT; + case RenderStyle::MARKER: + return MARKER_BIT; + case RenderStyle::REPLACED: + return REPLACED_BIT; + case RenderStyle::FIRST_LINE: + return FIRST_LINE_BIT; + case RenderStyle::FIRST_LETTER: + return FIRST_LETTER_BIT; + case RenderStyle::SELECTION: + return SELECTION_BIT; + default: + return NO_BIT; + } +} + +bool RenderStyle::hasPseudoStyle(PseudoId pseudo) const +{ + return (pseudoBit(pseudo) & noninherited_flags.f._pseudoBits) != 0; +} + +void RenderStyle::setHasPseudoStyle(PseudoId pseudo, bool b) +{ + if (b) + noninherited_flags.f._pseudoBits |= pseudoBit(pseudo); + else + noninherited_flags.f._pseudoBits &= ~(pseudoBit(pseudo)); +} + +RenderStyle* RenderStyle::getPseudoStyle(PseudoId pid) const +{ + if (!hasPseudoStyle(pid)) return 0; + + RenderStyle *ps = 0; + if (noninherited_flags.f._styleType==NOPSEUDO) + for (ps = pseudoStyle; ps; ps = ps->pseudoStyle) + if (ps->noninherited_flags.f._styleType==pid) + break; + return ps; +} + +RenderStyle* RenderStyle::addPseudoStyle(PseudoId pid) +{ + if (hasPseudoStyle(pid)) return getPseudoStyle(pid); + + RenderStyle *ps = 0; + + switch (pid) { + case FIRST_LETTER: // pseudo-elements (FIRST_LINE has a special handling) + case SELECTION: + case BEFORE: + case AFTER: + ps = new RenderStyle(); + break; + default: + ps = new RenderStyle(*this); // use the real copy constructor to get an identical copy + } + ps->ref(); + ps->noninherited_flags.f._styleType = pid; + ps->pseudoStyle = pseudoStyle; + + pseudoStyle = ps; + + setHasPseudoStyle(pid, true); + + return ps; +} + +void RenderStyle::removePseudoStyle(PseudoId pid) +{ + RenderStyle *ps = pseudoStyle; + RenderStyle *prev = this; + + while (ps) { + if (ps->noninherited_flags.f._styleType==pid) { + prev->pseudoStyle = ps->pseudoStyle; + ps->deref(); + return; + } + prev = ps; + ps = ps->pseudoStyle; + } + + setHasPseudoStyle(pid, false); +} + + +bool RenderStyle::inheritedNotEqual( RenderStyle *other ) const +{ + return + ( + inherited_flags != other->inherited_flags || + inherited != other->inherited || + css3InheritedData != other->css3InheritedData + ); +} + +/* + compares two styles. The result gives an idea of the action that + needs to be taken when replacing the old style with a new one. + + CbLayout: The containing block of the object needs a relayout. + Layout: the RenderObject needs a relayout after the style change + Visible: The change is visible, but no relayout is needed + NonVisible: The object does need neither repaint nor relayout after + the change. + + ### TODO: + A lot can be optimised here based on the display type, lots of + optimisations are unimplemented, and currently result in the + worst case result causing a relayout of the containing block. +*/ +RenderStyle::Diff RenderStyle::diff( const RenderStyle *other ) const +{ + // we anyway assume they are the same +// EDisplay _display : 5; + + // NonVisible: +// ECursor _cursor_style : 4; +// EUserInput _user_input : 2; as long as :enabled is not impl'd + +// ### this needs work to know more exactly if we need a relayout +// or just a repaint + +// non-inherited attributes +// DataRef<StyleBoxData> box; +// DataRef<StyleVisualData> visual; +// DataRef<StyleSurroundData> surround; + +// inherited attributes +// DataRef<StyleInheritedData> inherited; + + if ( *box.get() != *other->box.get() || + *visual.get() != *other->visual.get() || + (*surround.get() != *other->surround.get() + && (other->position() == STATIC || other->position() != position())) || + !(inherited->indent == other->inherited->indent) || + !(inherited->line_height == other->inherited->line_height) || + !(inherited->style_image == other->inherited->style_image) || + !(inherited->font == other->inherited->font) || + !(inherited->border_hspacing == other->inherited->border_hspacing) || + !(inherited->border_vspacing == other->inherited->border_vspacing) || + !(inherited_flags.f._visuallyOrdered == other->inherited_flags.f._visuallyOrdered) || + !(inherited_flags.f._htmlHacks == other->inherited_flags.f._htmlHacks) || + !(noninherited_flags.f._textOverflow == other->noninherited_flags.f._textOverflow) ) + return CbLayout; + + // changes causing Layout changes: + +// only for tables: +// _border_collapse +// EEmptyCell _empty_cells : 2 ; +// ECaptionSide _caption_side : 2; +// ETableLayout _table_layout : 1; +// EPosition _position : 2; +// EFloat _floating : 2; + if ( ((int)noninherited_flags.f._display) >= TABLE ) { + if ( !(inherited_flags.f._empty_cells == other->inherited_flags.f._empty_cells) || + !(inherited_flags.f._caption_side == other->inherited_flags.f._caption_side) || + !(inherited_flags.f._border_collapse == other->inherited_flags.f._border_collapse) || + !(noninherited_flags.f._table_layout == other->noninherited_flags.f._table_layout) || + !(noninherited_flags.f._position == other->noninherited_flags.f._position) || + !(noninherited_flags.f._floating == other->noninherited_flags.f._floating) || + !(noninherited_flags.f._flowAroundFloats == other->noninherited_flags.f._flowAroundFloats) || + !(noninherited_flags.f._unicodeBidi == other->noninherited_flags.f._unicodeBidi) ) + return CbLayout; + } + +// only for lists: +// EListStyleType _list_style_type : 5 ; +// EListStylePosition _list_style_position :1; + if (noninherited_flags.f._display == LIST_ITEM ) { + if ( !(inherited_flags.f._list_style_type == other->inherited_flags.f._list_style_type) || + !(inherited_flags.f._list_style_position == other->inherited_flags.f._list_style_position) ) + return Layout; + } + +// ### These could be better optimised +// ETextAlign _text_align : 3; +// ETextTransform _text_transform : 4; +// EDirection _direction : 1; +// EWhiteSpace _white_space : 2; +// EClear _clear : 2; + if ( !(inherited_flags.f._text_align == other->inherited_flags.f._text_align) || + !(inherited_flags.f._text_transform == other->inherited_flags.f._text_transform) || + !(inherited_flags.f._direction == other->inherited_flags.f._direction) || + !(inherited_flags.f._white_space == other->inherited_flags.f._white_space) || + !(noninherited_flags.f._clear == other->noninherited_flags.f._clear) + ) + return Layout; + + // Overflow returns a layout hint. + if (noninherited_flags.f._overflowX != other->noninherited_flags.f._overflowX || + noninherited_flags.f._overflowY != other->noninherited_flags.f._overflowY) + return Layout; + +// only for inline: +// EVerticalAlign _vertical_align : 4; + + if ( !(noninherited_flags.f._display == INLINE) && + !(noninherited_flags.f._vertical_align == other->noninherited_flags.f._vertical_align) ) + return Layout; + + if (*surround.get() != *other->surround.get()) { + assert( other->position() != STATIC ); // this style is positioned or relatively positioned + if ( surround->hasSamePBMData(*other->surround.get()) && // padding/border/margin are identical + (other->position() == RELATIVE || + !(other->left().isVariable() && other->right().isVariable()) && // X isn't static + !(other->top().isVariable() && other->bottom().isVariable()) )) // neither is Y + // therefore only the offset is different + return Position; + return Layout; + } + + // Visible: +// EVisibility _visibility : 2; +// int _text_decorations : 4; +// DataRef<StyleBackgroundData> background; + if (inherited->color != other->inherited->color || + !(inherited_flags.f._visibility == other->inherited_flags.f._visibility) || + !(inherited_flags.f._text_decorations == other->inherited_flags.f._text_decorations) || + !(noninherited_flags.f._hasClip == other->noninherited_flags.f._hasClip) || + visual->textDecoration != other->visual->textDecoration || + *background.get() != *other->background.get() || + css3NonInheritedData->opacity != other->css3NonInheritedData->opacity || + !css3InheritedData->shadowDataEquivalent(*other->css3InheritedData.get()) + ) + return Visible; + + RenderStyle::Diff ch = Equal; + // Check for visible pseudo-changes: + if (hasPseudoStyle(FIRST_LINE) != other->hasPseudoStyle(FIRST_LINE)) + ch = Visible; + else + if (hasPseudoStyle(FIRST_LINE) && other->hasPseudoStyle(FIRST_LINE)) + ch = getPseudoStyle(FIRST_LINE)->diff(other->getPseudoStyle(FIRST_LINE)); + + if (ch != Equal) return ch; + + // Check for visible pseudo-changes: + if (hasPseudoStyle(SELECTION) != other->hasPseudoStyle(SELECTION)) + ch = Visible; + else + if (hasPseudoStyle(SELECTION) && other->hasPseudoStyle(SELECTION)) + ch = getPseudoStyle(SELECTION)->diff(other->getPseudoStyle(SELECTION)); + + return ch; +} + + +RenderStyle* RenderStyle::_default = 0; + +void RenderStyle::cleanup() +{ + delete _default; + _default = 0; +} + +void RenderStyle::setPaletteColor(TQPalette::ColorGroup g, TQColorGroup::ColorRole r, const TQColor& c) +{ + visual.access()->palette.setColor(g,r,c); +} + +void RenderStyle::adjustBackgroundLayers() +{ + if (backgroundLayers()->next()) { + // First we cull out layers that have no properties set. + accessBackgroundLayers()->cullEmptyLayers(); + + // Next we repeat patterns into layers that don't have some properties set. + accessBackgroundLayers()->fillUnsetProperties(); + } +} + +void RenderStyle::setClip( Length top, Length right, Length bottom, Length left ) +{ + StyleVisualData *data = visual.access(); + data->clip.top = top; + data->clip.right = right; + data->clip.bottom = bottom; + data->clip.left = left; +} + +void RenderStyle::setQuotes(DOM::QuotesValueImpl* q) +{ + DOM::QuotesValueImpl *t = inherited->quotes; + inherited.access()->quotes = q; + if (q) q->ref(); + if (t) t->deref(); +} + +TQString RenderStyle::openQuote(int level) const +{ + if (inherited->quotes) + return inherited->quotes->openQuote(level); + else + return "\""; // 0 is default quotes +} + +TQString RenderStyle::closeQuote(int level) const +{ + if (inherited->quotes) + return inherited->quotes->closeQuote(level); + else + return "\""; // 0 is default quotes +} + +void RenderStyle::addContent(CachedObject* o) +{ + if (!o) + return; // The object is null. Nothing to do. Just bail. + + StyleGeneratedData *t_generated = generated.access(); + + ContentData* lastContent = t_generated->content; + while (lastContent && lastContent->_nextContent) + lastContent = lastContent->_nextContent; + + ContentData* newContentData = new ContentData; + + if (lastContent) + lastContent->_nextContent = newContentData; + else + t_generated->content = newContentData; + + // o->ref(); + newContentData->_content.object = o; + newContentData->_contentType = CONTENT_OBJECT; +} + +void RenderStyle::addContent(DOM::DOMStringImpl* s) +{ + if (!s) + return; // The string is null. Nothing to do. Just bail. + + StyleGeneratedData *t_generated = generated.access(); + + ContentData* lastContent = t_generated->content; + while (lastContent && lastContent->_nextContent) + lastContent = lastContent->_nextContent; + + if (lastContent) { + if (lastContent->_contentType == CONTENT_TEXT) { + // We can augment the existing string and share this ContentData node. + DOMStringImpl* oldStr = lastContent->_content.text; + DOMStringImpl* newStr = oldStr->copy(); + newStr->ref(); + oldStr->deref(); + newStr->append(s); + lastContent->_content.text = newStr; + return; + } + } + + ContentData* newContentData = new ContentData; + + if (lastContent) + lastContent->_nextContent = newContentData; + else + t_generated->content = newContentData; + + newContentData->_content.text = s; + newContentData->_content.text->ref(); + newContentData->_contentType = CONTENT_TEXT; + +} + +void RenderStyle::addContent(DOM::CounterImpl* c) +{ + if (!c) + return; + + StyleGeneratedData *t_generated = generated.access(); + + ContentData* lastContent = t_generated->content; + while (lastContent && lastContent->_nextContent) + lastContent = lastContent->_nextContent; + + ContentData* newContentData = new ContentData; + + if (lastContent) + lastContent->_nextContent = newContentData; + else + t_generated->content = newContentData; + + c->ref(); + newContentData->_content.counter = c; + newContentData->_contentType = CONTENT_COUNTER; +} + +void RenderStyle::addContent(EQuoteContent q) +{ + if (q == NO_QUOTE) + return; + + StyleGeneratedData *t_generated = generated.access(); + + ContentData* lastContent = t_generated->content; + while (lastContent && lastContent->_nextContent) + lastContent = lastContent->_nextContent; + + ContentData* newContentData = new ContentData; + + if (lastContent) + lastContent->_nextContent = newContentData; + else + t_generated->content = newContentData; + + newContentData->_content.quote = q; + newContentData->_contentType = CONTENT_QUOTE; +} + +// content: normal is the same as having no content at all +void RenderStyle::setContentNormal() { + if (generated->content != 0) { + delete generated->content; + generated.access()->content = 0; + } +} + +// content: none, add an empty content node +void RenderStyle::setContentNone() { + setContentNormal(); + generated.access()->content = new ContentData; +} + +void RenderStyle::setContentData(ContentData *data) { + if (data != generated->content) { + if (data) + generated.access()->content = new ContentData(*data); + else + generated.access()->content = 0; + } +} + +ContentData::ContentData(const ContentData& o) : _contentType(o._contentType) +{ + switch (_contentType) { + case CONTENT_OBJECT: + _content.object = o._content.object; + break; + case CONTENT_TEXT: + _content.text = o._content.text; + _content.text->ref(); + break; + case CONTENT_COUNTER: + _content.counter = o._content.counter; + _content.counter->ref(); + break; + case CONTENT_QUOTE: + _content.quote = o._content.quote; + break; + case CONTENT_NONE: + default: + break; + } + + _nextContent = o._nextContent ? new ContentData(*o._nextContent) : 0; +} + +ContentData::~ContentData() +{ + clearContent(); +} + +void ContentData::clearContent() +{ + delete _nextContent; + _nextContent = 0; + + switch (_contentType) + { + case CONTENT_OBJECT: + _content.object = 0; + break; + case CONTENT_TEXT: + _content.text->deref(); + _content.text = 0; + break; + case CONTENT_COUNTER: + _content.counter->deref(); + _content.counter = 0; + break; + case CONTENT_QUOTE: + _content.quote = NO_QUOTE; + break; + default: + ; + } +} + +void RenderStyle::setTextShadow(ShadowData* val, bool add) +{ + StyleCSS3InheritedData* css3Data = css3InheritedData.access(); + if (!add) { + delete css3Data->textShadow; + css3Data->textShadow = val; + return; + } + + ShadowData* last = css3Data->textShadow; + while (last->next) last = last->next; + last->next = val; +} + +ShadowData::ShadowData(const ShadowData& o) +:x(o.x), y(o.y), blur(o.blur), color(o.color) +{ + next = o.next ? new ShadowData(*o.next) : 0; +} + +bool ShadowData::operator==(const ShadowData& o) const +{ + if ((next && !o.next) || (!next && o.next) || + (next && o.next && *next != *o.next)) + return false; + + return x == o.x && y == o.y && blur == o.blur && color == o.color; +} + +static bool hasCounter(const DOM::DOMString& c, CSSValueListImpl *l) +{ + int len = l->length(); + for(int i=0; i<len; i++) { + CounterActImpl* ca = static_cast<CounterActImpl*>(l->item(i)); + Q_ASSERT(ca != 0); + if (ca->m_counter == c) return true; + } + return false; +} + +bool RenderStyle::hasCounterReset(const DOM::DOMString& c) const +{ + if (generated->counter_reset) + return hasCounter(c, generated->counter_reset); + else + return false; +} + +bool RenderStyle::hasCounterIncrement(const DOM::DOMString& c) const +{ + if (generated->counter_increment) + return hasCounter(c, generated->counter_increment); + else + return false; +} + +static short readCounter(const DOM::DOMString& c, CSSValueListImpl *l) +{ + int len = l->length(); + for(int i=0; i<len; i++) { + CounterActImpl* ca = static_cast<CounterActImpl*>(l->item(i)); + Q_ASSERT(ca != 0); + if (ca->m_counter == c) return ca->m_value; + } + return 0; +} + +short RenderStyle::counterReset(const DOM::DOMString& c) const +{ + if (generated->counter_reset) + return readCounter(c, generated->counter_reset); + else + return 0; +} + +short RenderStyle::counterIncrement(const DOM::DOMString& c) const +{ + if (generated->counter_increment) + return readCounter(c, generated->counter_increment); + else + return 0; +} + +void RenderStyle::setCounterReset(CSSValueListImpl *l) +{ + CSSValueListImpl *t = generated->counter_reset; + generated.access()->counter_reset = l; + if (l) l->ref(); + if (t) t->deref(); +} + +void RenderStyle::setCounterIncrement(CSSValueListImpl *l) +{ + CSSValueListImpl *t = generated->counter_increment; + generated.access()->counter_increment = l; + if (l) l->ref(); + if (t) t->deref(); +} + +#ifdef ENABLE_DUMP + +static TQString describeFont( const TQFont &f) +{ + TQString res = "'" + f.family() + "' "; + + if ( f.pointSize() > 0) + res += TQString::number( f.pointSize() ) + "pt"; + else + res += TQString::number( f.pixelSize() ) + "px"; + + if ( f.bold() ) + res += " bold"; + if ( f.italic() ) + res += " italic"; + if ( f.underline() ) + res += " underline"; + if ( f.overline() ) + res += " overline"; + if ( f.strikeOut() ) + res += " strikeout"; + return res; +} + +TQString RenderStyle::createDiff( const RenderStyle &parent ) const +{ + TQString res; + if ( color().isValid() && parent.color() != color() ) + res += " [color=" + color().name() + "]"; + if ( backgroundColor().isValid() && parent.backgroundColor() != backgroundColor() ) + res += " [bgcolor=" + backgroundColor().name() + "]"; + if ( parent.font() != font() ) + res += " [font=" + describeFont( font() ) + "]"; + + return res; +} +#endif + +RenderPageStyle::RenderPageStyle() : next(0), m_pageType(ANY_PAGE) +{ +} + +RenderPageStyle::~RenderPageStyle() +{ + delete next; +} + +RenderPageStyle* RenderPageStyle::getPageStyle(PageType type) +{ + RenderPageStyle *ps = 0; + for (ps = this; ps; ps = ps->next) + if (ps->m_pageType==type) + break; + return ps; +} + +RenderPageStyle* RenderPageStyle::addPageStyle(PageType type) +{ + RenderPageStyle *ps = getPageStyle(type); + + if (!ps) + { + ps = new RenderPageStyle(*this); // use the real copy constructor to get an identical copy + ps->m_pageType = type; + + ps->next = next; + next = ps; + } + + return ps; +} + +void RenderPageStyle::removePageStyle(PageType type) +{ + RenderPageStyle *ps = next; + RenderPageStyle *prev = this; + + while (ps) { + if (ps->m_pageType==type) { + prev->next = ps->next; + delete ps; + return; + } + prev = ps; + ps = ps->next; + } +} diff --git a/tdehtml/rendering/render_style.h b/tdehtml/rendering/render_style.h new file mode 100644 index 000000000..6e1b9cbc8 --- /dev/null +++ b/tdehtml/rendering/render_style.h @@ -0,0 +1,1524 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 2000-2003 Lars Knoll (knoll@kde.org) + * (C) 2000 Antti Koivisto (koivisto@kde.org) + * (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003-2005 Apple Computer, Inc. + * (C) 2004-2006 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDERSTYLE_H +#define RENDERSTYLE_H + +/* + * WARNING: + * -------- + * + * The order of the values in the enums have to agree with the order specified + * in cssvalues.in, otherwise some optimizations in the parser will fail, + * and produce invaliud results. + */ + +#include <tqcolor.h> +#include <tqfont.h> +#include <tqfontmetrics.h> +#include <tqptrlist.h> +#include <tqpalette.h> +#include <tqapplication.h> + +#include "dom/dom_misc.h" +#include "dom/dom_string.h" +#include "misc/tdehtmllayout.h" +#include "misc/shared.h" +#include "rendering/font.h" + +#include <assert.h> + +#define SET_VAR(group,variable,value) \ + if (!(group->variable == value)) \ + group.access()->variable = value; + +#ifndef ENABLE_DUMP +#ifndef NDEBUG +#define ENABLE_DUMP 1 +#endif +#endif + +namespace DOM { + class DOMStringImpl; + class ShadowValueImpl; + class QuotesValueImpl; + class CounterImpl; + class CSSValueListImpl; + class CounterActImpl; +} + +namespace tdehtml { + + class CachedImage; + class CachedObject; + +template <class DATA> +class DataRef +{ +public: + + DataRef() + { + data=0; + } + DataRef( const DataRef<DATA> &d ) + { + data = d.data; + data->ref(); + } + + ~DataRef() + { + if(data) data->deref(); + } + + const DATA* operator->() const + { + return data; + } + + const DATA* get() const + { + return data; + } + + + DATA* access() + { + if (!data->hasOneRef()) + { + data->deref(); + data = new DATA(*data); + data->ref(); + } + return data; + } + + void init() + { + data = new DATA; + data->ref(); + } + + DataRef<DATA>& operator=(const DataRef<DATA>& d) + { + if (data==d.data) + return *this; + if (data) + data->deref(); + data = d.data; + + data->ref(); + + return *this; + } + + bool operator == ( const DataRef<DATA> &o ) const { + return (*data == *(o.data) ); + } + bool operator != ( const DataRef<DATA> &o ) const { + return (*data != *(o.data) ); + } + +private: + DATA* data; +}; + + +//------------------------------------------------ + +//------------------------------------------------ +// Box model attributes. Not inherited. + +struct LengthBox +{ + LengthBox() + { + } + LengthBox( LengthType t ) + : left( t ), right ( t ), top( t ), bottom( t ) {} + + Length left; + Length right; + Length top; + Length bottom; + Length& operator=(Length& len) + { + left=len; + right=len; + top=len; + bottom=len; + return len; + } + + bool operator==(const LengthBox& o) const + { + return left==o.left && right==o.right && top==o.top && bottom==o.bottom; + } + + + bool nonZero() const { return left.value() || right.value() || top.value() || bottom.value(); } +}; + + + +enum EPosition { + STATIC, RELATIVE, ABSOLUTE, FIXED +}; + +enum EFloat { + FNONE = 0, FLEFT = 0x01, FRIGHT = 0x02, FLEFT_ALIGN = 0x05, FRIGHT_ALIGN = 0x06 +}; + +enum EWordWrap { + WWNORMAL = 0, WWBREAKWORD = 0x01 +}; + +//------------------------------------------------ +// Border attributes. Not inherited. + + +// These have been defined in the order of their precedence for border-collapsing. Do +// not change this order! +enum EBorderStyle { + BNATIVE, BNONE, BHIDDEN, INSET, GROOVE, RIDGE, OUTSET, DOTTED, DASHED, SOLID, DOUBLE +}; + +class BorderValue +{ +public: + BorderValue() : width( 3 ), style( BNONE ) {} + + TQColor color; + unsigned short width : 12; + EBorderStyle style : 6; + + bool nonZero(bool checkStyle = true) const { + return width != 0 && !(checkStyle && style == BNONE); + } + + bool isTransparent() const { + return color.isValid() && tqAlpha(color.rgb()) == 0; + } + + bool operator==(const BorderValue& o) const + { + return width==o.width && style==o.style && color==o.color; + } + + bool operator!=(const BorderValue& o) const + { + return !(*this == o); + } +}; + +class OutlineValue : public BorderValue +{ + public: + OutlineValue() + { + _offset = 0; + _auto = false; + } + + bool operator==(const OutlineValue& o) const + { + return width==o.width && style==o.style && color==o.color && _offset == o._offset && _auto == o._auto; + } + + bool operator!=(const OutlineValue& o) const + { + return !(*this == o); + } + + int _offset; + bool _auto; +}; + +enum EBorderPrecedence { BOFF, BTABLE, BCOLGROUP, BCOL, BROWGROUP, BROW, BCELL }; + +struct CollapsedBorderValue +{ + CollapsedBorderValue() :border(0), precedence(BOFF) {} + CollapsedBorderValue(const BorderValue* b, EBorderPrecedence p) :border(b), precedence(p) {} + + int width() const { return border && border->nonZero() ? border->width : 0; } + EBorderStyle style() const { return border ? border->style : BHIDDEN; } + bool exists() const { return border; } + TQColor color() const { return border ? border->color : TQColor(); } + bool isTransparent() const { return border ? border->isTransparent() : true; } + + bool operator==(const CollapsedBorderValue& o) const + { + if (!border) return !o.border; + if (!o.border) return false; + return *border == *o.border && precedence == o.precedence; + } + + const BorderValue* border; + EBorderPrecedence precedence; +}; + +class BorderData : public Shared<BorderData> +{ +public: + BorderValue left; + BorderValue right; + BorderValue top; + BorderValue bottom; + + bool hasBorder() const + { + return left.nonZero() || right.nonZero() || top.nonZero() || bottom.nonZero(); + } + + unsigned short borderLeftWidth() const { + if (left.style == BNONE || left.style == BHIDDEN || left.style == BNATIVE) + return 0; + return left.width; + } + + unsigned short borderRightWidth() const { + if (right.style == BNONE || right.style == BHIDDEN || right.style == BNATIVE) + return 0; + return right.width; + } + + unsigned short borderTopWidth() const { + if (top.style == BNONE || top.style == BHIDDEN || top.style == BNATIVE) + return 0; + return top.width; + } + + unsigned short borderBottomWidth() const { + if (bottom.style == BNONE || bottom.style == BHIDDEN || bottom.style == BNATIVE) + return 0; + return bottom.width; + } + + bool operator==(const BorderData& o) const + { + return left==o.left && right==o.right && top==o.top && bottom==o.bottom; + } + +}; + +class StyleSurroundData : public Shared<StyleSurroundData> +{ +public: + StyleSurroundData(); + + StyleSurroundData(const StyleSurroundData& o ); + bool operator==(const StyleSurroundData& o) const; + bool operator!=(const StyleSurroundData& o) const { + return !(*this == o); + } + bool hasSamePBMData(const StyleSurroundData& o) const { + return (margin == o.margin) && (padding == o.padding) && (border == o.border); + } + + LengthBox offset; + LengthBox margin; + LengthBox padding; + BorderData border; +}; + + +//------------------------------------------------ +// Box attributes. Not inherited. + +enum EBoxSizing { + BORDER_BOX, CONTENT_BOX +}; + +class StyleBoxData : public Shared<StyleBoxData> +{ +public: + StyleBoxData(); + + StyleBoxData(const StyleBoxData& o ); + + + // copy and assignment +// StyleBoxData(const StyleBoxData &other); +// const StyleBoxData &operator = (const StyleBoxData &other); + + bool operator==(const StyleBoxData& o) const; + bool operator!=(const StyleBoxData& o) const { + return !(*this == o); + } + + Length width; + Length height; + + Length min_width; + Length max_width; + + Length min_height; + Length max_height; + + Length vertical_align; + + EBoxSizing box_sizing; + + signed int z_index :31; + bool z_auto : 1; +}; + +//------------------------------------------------ +// Random visual rendering model attributes. Not inherited. + +enum EOverflow { + OVISIBLE, OHIDDEN, OSCROLL, OAUTO, OMARQUEE +}; + +enum EVerticalAlign { + BASELINE, MIDDLE, SUB, SUPER, TEXT_TOP, + TEXT_BOTTOM, TOP, BOTTOM, BASELINE_MIDDLE, LENGTH +}; + +enum EClear{ + CNONE = 0, CLEFT = 1, CRIGHT = 2, CBOTH = 3 +}; + +enum ETableLayout { + TAUTO, TFIXED +}; + +enum EUnicodeBidi { + UBNormal, Embed, Override +}; + +class StyleVisualData : public Shared<StyleVisualData> +{ +public: + StyleVisualData(); + + ~StyleVisualData(); + + StyleVisualData(const StyleVisualData& o ); + + bool operator==( const StyleVisualData &o ) const { + return ( clip == o.clip && + palette == o.palette ); + } + bool operator!=( const StyleVisualData &o ) const { + return !(*this == o); + } + + LengthBox clip; + unsigned textDecoration : 4; // Text decorations defined *only* by this element. + + TQPalette palette; //widget styling with IE attributes + +}; + +//------------------------------------------------ +enum EBackgroundBox { + BGBORDER, BGPADDING, BGCONTENT +}; + +enum EBackgroundRepeat { + REPEAT, REPEAT_X, REPEAT_Y, NO_REPEAT +}; + +struct LengthSize { + Length width; + Length height; +}; + +struct BackgroundLayer { +public: + BackgroundLayer(); + ~BackgroundLayer(); + + CachedImage* backgroundImage() const { return m_image; } + Length backgroundXPosition() const { return m_xPosition; } + Length backgroundYPosition() const { return m_yPosition; } + bool backgroundAttachment() const { return m_bgAttachment; } + EBackgroundBox backgroundClip() const { return m_bgClip; } + EBackgroundBox backgroundOrigin() const { return m_bgOrigin; } + EBackgroundRepeat backgroundRepeat() const { return m_bgRepeat; } + LengthSize backgroundSize() const { return m_backgroundSize; } + + BackgroundLayer* next() const { return m_next; } + BackgroundLayer* next() { return m_next; } + + bool isBackgroundImageSet() const { return m_imageSet; } + bool isBackgroundXPositionSet() const { return m_xPosSet; } + bool isBackgroundYPositionSet() const { return m_yPosSet; } + bool isBackgroundAttachmentSet() const { return m_attachmentSet; } + bool isBackgroundClipSet() const { return m_clipSet; } + bool isBackgroundOriginSet() const { return m_originSet; } + bool isBackgroundRepeatSet() const { return m_repeatSet; } + bool isBackgroundSizeSet() const { return m_backgroundSizeSet; } + + void setBackgroundImage(CachedImage* i) { m_image = i; m_imageSet = true; } + void setBackgroundXPosition(const Length& l) { m_xPosition = l; m_xPosSet = true; } + void setBackgroundYPosition(const Length& l) { m_yPosition = l; m_yPosSet = true; } + void setBackgroundAttachment(bool b) { m_bgAttachment = b; m_attachmentSet = true; } + void setBackgroundClip(EBackgroundBox b) { m_bgClip = b; m_clipSet = true; } + void setBackgroundOrigin(EBackgroundBox b) { m_bgOrigin = b; m_originSet = true; } + void setBackgroundRepeat(EBackgroundRepeat r) { m_bgRepeat = r; m_repeatSet = true; } + void setBackgroundSize(const LengthSize& b) { m_backgroundSize = b; m_backgroundSizeSet = true; } + + void clearBackgroundImage() { m_imageSet = false; } + void clearBackgroundXPosition() { m_xPosSet = false; } + void clearBackgroundYPosition() { m_yPosSet = false; } + void clearBackgroundAttachment() { m_attachmentSet = false; } + void clearBackgroundClip() { m_clipSet = false; } + void clearBackgroundOrigin() { m_originSet = false; } + void clearBackgroundRepeat() { m_repeatSet = false; } + void clearBackgroundSize() { m_backgroundSizeSet = false; } + + void setNext(BackgroundLayer* n) { if (m_next != n) { delete m_next; m_next = n; } } + + BackgroundLayer& operator=(const BackgroundLayer& o); + BackgroundLayer(const BackgroundLayer& o); + + bool operator==(const BackgroundLayer& o) const; + bool operator!=(const BackgroundLayer& o) const { + return !(*this == o); + } + + bool containsImage(CachedImage* c) const { if (c == m_image) return true; if (m_next) return m_next->containsImage(c); return false; } + + bool hasImage() const { + if (m_image) + return true; + return m_next ? m_next->hasImage() : false; + } + bool hasFixedImage() const { + if (m_image && !m_bgAttachment) + return true; + return m_next ? m_next->hasFixedImage() : false; + } + + void fillUnsetProperties(); + void cullEmptyLayers(); + + CachedImage* m_image; + + Length m_xPosition; + Length m_yPosition; + + bool m_bgAttachment : 1; + EBackgroundBox m_bgClip : 2; + EBackgroundBox m_bgOrigin : 2; + EBackgroundRepeat m_bgRepeat : 2; + + LengthSize m_backgroundSize; + + bool m_imageSet : 1; + bool m_attachmentSet : 1; + bool m_clipSet : 1; + bool m_originSet : 1; + bool m_repeatSet : 1; + bool m_xPosSet : 1; + bool m_yPosSet : 1; + bool m_backgroundSizeSet : 1; + + BackgroundLayer* m_next; +}; + +class StyleBackgroundData : public Shared<StyleBackgroundData> +{ +public: + StyleBackgroundData(); + ~StyleBackgroundData() {} + StyleBackgroundData(const StyleBackgroundData& o ); + + bool operator==(const StyleBackgroundData& o) const; + bool operator!=(const StyleBackgroundData &o) const { + return !(*this == o); + } + + BackgroundLayer m_background; + TQColor m_color; + OutlineValue m_outline; +}; + +enum EQuoteContent { + NO_QUOTE = 0, OPEN_QUOTE, CLOSE_QUOTE, NO_OPEN_QUOTE, NO_CLOSE_QUOTE +}; + +enum ContentType { + CONTENT_NONE = 0, CONTENT_NORMAL, CONTENT_OBJECT, + CONTENT_TEXT, CONTENT_COUNTER, CONTENT_QUOTE +}; + +struct ContentData { + ContentData() : _contentType( CONTENT_NONE ), _nextContent(0) {} + ContentData(const ContentData& o); + ~ContentData(); + void clearContent(); + + DOM::DOMStringImpl* contentText() + { if (_contentType == CONTENT_TEXT) return _content.text; return 0; } + CachedObject* contentObject() + { if (_contentType == CONTENT_OBJECT) return _content.object; return 0; } + DOM::CounterImpl* contentCounter() + { if (_contentType == CONTENT_COUNTER) return _content.counter; return 0; } + EQuoteContent contentQuote() + { if (_contentType == CONTENT_QUOTE) return _content.quote; return NO_QUOTE; } + + ContentType _contentType; + + union { + CachedObject* object; + DOM::DOMStringImpl* text; + DOM::CounterImpl* counter; + EQuoteContent quote; + } _content ; + + ContentData* _nextContent; +}; + +class StyleGeneratedData : public Shared<StyleGeneratedData> +{ +public: + StyleGeneratedData(); + ~StyleGeneratedData(); + StyleGeneratedData(const StyleGeneratedData& o ); + + bool operator==(const StyleGeneratedData& o) const; + bool operator!=(const StyleGeneratedData &o) const { + return !(*this == o); + } + + bool contentDataEquivalent(const StyleGeneratedData* otherStyle) const; + bool counterDataEquivalent(const StyleGeneratedData* otherStyle) const; + + ContentData *content; + DOM::CSSValueListImpl *counter_reset; + DOM::CSSValueListImpl *counter_increment; +}; + +//------------------------------------------------ +// CSS3 Marquee Properties + +enum EMarqueeBehavior { MNONE, MSCROLL, MSLIDE, MALTERNATE, MUNFURL }; +enum EMarqueeDirection { MAUTO = 0, MLEFT = 1, MRIGHT = -1, MUP = 2, MDOWN = -2, MFORWARD = 3, MBACKWARD = -3 }; + +class StyleMarqueeData : public Shared<StyleMarqueeData> +{ +public: + StyleMarqueeData(); + StyleMarqueeData(const StyleMarqueeData& o); + + bool operator==(const StyleMarqueeData& o) const; + bool operator!=(const StyleMarqueeData& o) const { + return !(*this == o); + } + + Length increment; + int speed; + + int loops; // -1 means infinite. + + EMarqueeBehavior behavior : 3; + EMarqueeDirection direction : 3; +}; + +// This struct holds information about shadows for the text-shadow and box-shadow properties. +struct ShadowData { + ShadowData(int _x, int _y, int _blur, const TQColor& _color) + :x(_x), y(_y), blur(_blur), color(_color), next(0) {} + ShadowData(const ShadowData& o); + + ~ShadowData() { delete next; } + + bool operator==(const ShadowData& o) const; + bool operator!=(const ShadowData &o) const { + return !(*this == o); + } + + int x; + int y; + int blur; + TQColor color; + ShadowData* next; +}; + +// This struct is for rarely used non-inherited CSS3 properties. By grouping them together, +// we save space, and only allocate this object when someone actually uses +// a non-inherited CSS3 property. +class StyleCSS3NonInheritedData : public Shared<StyleCSS3NonInheritedData> +{ +public: + StyleCSS3NonInheritedData(); + ~StyleCSS3NonInheritedData() {} + StyleCSS3NonInheritedData(const StyleCSS3NonInheritedData& o); + + bool operator==(const StyleCSS3NonInheritedData& o) const; + bool operator!=(const StyleCSS3NonInheritedData &o) const { + return !(*this == o); + } + + float opacity; // Whether or not we're transparent. +#ifdef APPLE_CHANGES // ### we don't have those (yet) + DataRef<StyleFlexibleBoxData> flexibleBox; // Flexible box properties +#endif + DataRef<StyleMarqueeData> marquee; // Marquee properties +}; + +// This struct is for rarely used inherited CSS3 properties. By grouping them together, +// we save space, and only allocate this object when someone actually uses +// an inherited CSS3 property. +class StyleCSS3InheritedData : public Shared<StyleCSS3InheritedData> +{ + public: + StyleCSS3InheritedData(); + ~StyleCSS3InheritedData(); + StyleCSS3InheritedData(const StyleCSS3InheritedData& o); + + bool operator==(const StyleCSS3InheritedData& o) const; + bool operator!=(const StyleCSS3InheritedData &o) const { + return !(*this == o); + } + bool shadowDataEquivalent(const StyleCSS3InheritedData& o) const; + + ShadowData* textShadow; // Our text shadow information for shadowed text drawing. +#ifdef APPLE_CHANGES + EUserModify userModify : 2; // Flag used for editing state + bool textSizeAdjust : 1; // An Apple extension. Not really CSS3 but not worth making a new struct over. +#endif + EWordWrap wordWrap : 1; + private: + StyleCSS3InheritedData &operator=(const StyleCSS3InheritedData &); +}; + +//------------------------------------------------ +// Inherited attributes. +// +// the inherited-decoration and inherited-shadow attributes +// are inherited from the +// first parent which is block level +// + +enum EWhiteSpace { + NORMAL, PRE, NOWRAP, PRE_WRAP, PRE_LINE, KHTML_NOWRAP +}; + +enum ETextAlign { + TAAUTO, LEFT, RIGHT, CENTER, JUSTIFY, KHTML_LEFT, KHTML_RIGHT, KHTML_CENTER +}; + +enum ETextTransform { + CAPITALIZE, UPPERCASE, LOWERCASE, TTNONE +}; + +enum EDirection { + LTR, RTL +}; + +enum ETextDecoration { + TDNONE = 0x0 , UNDERLINE = 0x1, OVERLINE = 0x2, LINE_THROUGH= 0x4, BLINK = 0x8 +}; + +enum EPageBreak { + PBAUTO, PBALWAYS, PBAVOID, + /* reserved for later use: */ + PBLEFT, PBRIGHT +}; + +class StyleInheritedData : public Shared<StyleInheritedData> +{ + StyleInheritedData& operator=(const StyleInheritedData&); +public: + StyleInheritedData(); + ~StyleInheritedData(); + StyleInheritedData(const StyleInheritedData& o ); + + bool operator==(const StyleInheritedData& o) const; + bool operator != ( const StyleInheritedData &o ) const { + return !(*this == o); + } + + Length indent; + // could be packed in a short but doesn't + // make a difference currently because of padding + Length line_height; + + CachedImage *style_image; + + tdehtml::Font font; + TQColor color; + + short border_hspacing; + short border_vspacing; + + // Paged media properties. + short widows; + short orphans; + + DOM::QuotesValueImpl* quotes; +}; + + +enum EEmptyCell { + SHOW, HIDE +}; + +enum ECaptionSide { + CAPTOP, CAPBOTTOM, CAPLEFT, CAPRIGHT +}; + + +enum EListStyleType { + // Symbols: + LDISC, LCIRCLE, LSQUARE, LBOX, LDIAMOND, + // Numeric: + LDECIMAL, DECIMAL_LEADING_ZERO, ARABIC_INDIC, LAO, PERSIAN, URDU, THAI, TIBETAN, + // Algorithmic: + LOWER_ROMAN, UPPER_ROMAN, HEBREW, ARMENIAN, GEORGIAN, + // Ideographic: + CJK_IDEOGRAPHIC, JAPANESE_FORMAL, JAPANESE_INFORMAL, + SIMP_CHINESE_FORMAL, SIMP_CHINESE_INFORMAL, TRAD_CHINESE_FORMAL, TRAD_CHINESE_INFORMAL, + // Alphabetic: + LOWER_GREEK, UPPER_GREEK, LOWER_ALPHA, LOWER_LATIN, UPPER_ALPHA, UPPER_LATIN, + HIRAGANA, KATAKANA, HIRAGANA_IROHA, KATAKANA_IROHA, + // Special: + LNONE +}; + +inline bool isListStyleCounted(EListStyleType type) +{ + switch(type) { + case LDISC: case LCIRCLE: case LSQUARE: case LBOX: case LDIAMOND: + case LNONE: + return false; + default: + return true; + } +} + +enum EListStylePosition { OUTSIDE, INSIDE }; + +enum EVisibility { VISIBLE, HIDDEN, COLLAPSE }; + +enum ECursor { + CURSOR_AUTO, CURSOR_CROSS, CURSOR_DEFAULT, CURSOR_POINTER, CURSOR_PROGRESS, CURSOR_MOVE, + CURSOR_E_RESIZE, CURSOR_NE_RESIZE, CURSOR_NW_RESIZE, CURSOR_N_RESIZE, CURSOR_SE_RESIZE, CURSOR_SW_RESIZE, + CURSOR_S_RESIZE, CURSOR_W_RESIZE, CURSOR_TEXT, CURSOR_WAIT, CURSOR_HELP +}; + +enum EUserInput { + UI_ENABLED, UI_DISABLED, UI_NONE +}; + +//------------------------------------------------ + +enum EDisplay { + INLINE, BLOCK, LIST_ITEM, RUN_IN, + COMPACT, INLINE_BLOCK, TABLE, INLINE_TABLE, + TABLE_ROW_GROUP, TABLE_HEADER_GROUP, TABLE_FOOTER_GROUP, TABLE_ROW, + TABLE_COLUMN_GROUP, TABLE_COLUMN, TABLE_CELL, + TABLE_CAPTION, NONE +}; + +class RenderStyle : public Shared<RenderStyle> +{ + friend class CSSStyleSelector; +public: + KDE_EXPORT static void cleanup(); + + // pseudo elements + enum PseudoId { + NOPSEUDO, FIRST_LINE, FIRST_LETTER, SELECTION, + BEFORE, AFTER, REPLACED, MARKER + }; + +protected: + +// !START SYNC!: Keep this in sync with the copy constructor in render_style.cpp + + // inherit + struct InheritedFlags { + // 64 bit inherited, update unused when adding to the struct, or the operator will break. + bool operator==( const InheritedFlags &other ) const + { return _iflags ==other._iflags; } + bool operator!=( const InheritedFlags &other ) const + { return _iflags != other._iflags; } + + union { + struct { + EEmptyCell _empty_cells : 1 ; + ECaptionSide _caption_side : 2; + EListStyleType _list_style_type : 6; + EListStylePosition _list_style_position :1; + + EVisibility _visibility : 2; + ETextAlign _text_align : 4; + ETextTransform _text_transform : 2; + unsigned _text_decorations : 4; + ECursor _cursor_style : 5; + + EDirection _direction : 1; + bool _border_collapse : 1 ; + EWhiteSpace _white_space : 3; + // non CSS2 inherited + bool _visuallyOrdered : 1; + bool _htmlHacks :1; + EUserInput _user_input : 2; + + bool _page_break_inside : 1; // AUTO/AVOID + + unsigned int unused : 27; + } f; + TQ_UINT64 _iflags; + }; + } inherited_flags; + +// don't inherit + struct NonInheritedFlags { + // 64 bit non-inherited, update unused when adding to the struct, or the operator will break. + bool operator==( const NonInheritedFlags &other ) const + { return _niflags == other._niflags; } + bool operator!=( const NonInheritedFlags &other ) const + { return _niflags != other._niflags; } + + union { + struct { + EDisplay _display : 5; + EDisplay _originalDisplay: 5; + EOverflow _overflowX : 4 ; + EOverflow _overflowY : 4 ; + EVerticalAlign _vertical_align : 4; + EClear _clear : 2; + EPosition _position : 2; + EFloat _floating : 3; + ETableLayout _table_layout : 1; + bool _flowAroundFloats :1; + + EPageBreak _page_break_before : 3; + EPageBreak _page_break_after : 3; + + PseudoId _styleType : 4; + bool _hasClip : 1; + unsigned _pseudoBits : 8; + EUnicodeBidi _unicodeBidi : 2; + + // non CSS2 non-inherited + bool _textOverflow : 1; // Whether or not lines that spill out should be truncated with "..." + + unsigned int unused : 11; + } f; + TQ_UINT64 _niflags; + }; + } noninherited_flags; + +// non-inherited attributes + DataRef<StyleBoxData> box; + DataRef<StyleVisualData> visual; + DataRef<StyleBackgroundData> background; + DataRef<StyleSurroundData> surround; + DataRef<StyleGeneratedData> generated; + DataRef<StyleCSS3NonInheritedData> css3NonInheritedData; + +// inherited attributes + DataRef<StyleCSS3InheritedData> css3InheritedData; + DataRef<StyleInheritedData> inherited; + +// list of associated pseudo styles + RenderStyle* pseudoStyle; + +// !END SYNC! + +// static default style + static RenderStyle* _default; + +private: + RenderStyle(const RenderStyle*) {} + +protected: + void setBitDefaults() + { + inherited_flags.f._empty_cells = initialEmptyCells(); + inherited_flags.f._caption_side = initialCaptionSide(); + inherited_flags.f._list_style_type = initialListStyleType(); + inherited_flags.f._list_style_position = initialListStylePosition(); + inherited_flags.f._visibility = initialVisibility(); + inherited_flags.f._text_align = initialTextAlign(); + inherited_flags.f._text_transform = initialTextTransform(); + inherited_flags.f._text_decorations = initialTextDecoration(); + inherited_flags.f._cursor_style = initialCursor(); + inherited_flags.f._direction = initialDirection(); + inherited_flags.f._border_collapse = initialBorderCollapse(); + inherited_flags.f._white_space = initialWhiteSpace(); + inherited_flags.f._visuallyOrdered = false; + inherited_flags.f._htmlHacks=false; + inherited_flags.f._user_input = UI_NONE; + inherited_flags.f._page_break_inside = true; + inherited_flags.f.unused = 0; + + noninherited_flags._niflags = 0L; // for safety: without this, the equality method sometimes + // makes use of uninitialised bits according to valgrind + + noninherited_flags.f._display = noninherited_flags.f._originalDisplay = initialDisplay(); + noninherited_flags.f._overflowX = initialOverflowX(); + noninherited_flags.f._overflowY = initialOverflowY(); + noninherited_flags.f._vertical_align = initialVerticalAlign(); + noninherited_flags.f._clear = initialClear(); + noninherited_flags.f._position = initialPosition(); + noninherited_flags.f._floating = initialFloating(); + noninherited_flags.f._table_layout = initialTableLayout(); + noninherited_flags.f._flowAroundFloats= initialFlowAroundFloats(); + noninherited_flags.f._page_break_before = initialPageBreak(); + noninherited_flags.f._page_break_after = initialPageBreak(); + noninherited_flags.f._styleType = NOPSEUDO; + noninherited_flags.f._hasClip = false; + noninherited_flags.f._pseudoBits = 0; + noninherited_flags.f._unicodeBidi = initialUnicodeBidi(); + noninherited_flags.f._textOverflow = initialTextOverflow(); + noninherited_flags.f.unused = 0; + } + +public: + + RenderStyle(); + // used to create the default style. + RenderStyle(bool); + RenderStyle(const RenderStyle&); + + ~RenderStyle(); + + void inheritFrom(const RenderStyle* inheritParent); + + PseudoId styleType() const { return noninherited_flags.f._styleType; } + void setStyleType(PseudoId pi) { noninherited_flags.f._styleType = pi; } + bool isGenerated() const { + if (styleType() == AFTER || styleType() == BEFORE || styleType() == MARKER || styleType() == REPLACED) + return true; + else + return false; + } + + bool hasPseudoStyle(PseudoId pi) const; + void setHasPseudoStyle(PseudoId pi, bool b=true); + RenderStyle* getPseudoStyle(PseudoId pi) const; + RenderStyle* addPseudoStyle(PseudoId pi); + void removePseudoStyle(PseudoId pi); + + bool operator==(const RenderStyle& other) const; + bool isFloating() const { return !(noninherited_flags.f._floating == FNONE); } + bool hasMargin() const { return surround->margin.nonZero(); } + bool hasBorder() const { return surround->border.hasBorder(); } + bool hasOffset() const { return surround->offset.nonZero(); } + + bool hasBackground() const { + if (backgroundColor().isValid() && tqAlpha(backgroundColor().rgb()) > 0) + return true; + else + return background->m_background.hasImage(); + } + bool hasFixedBackgroundImage() const { return background->m_background.hasFixedImage(); } + + bool visuallyOrdered() const { return inherited_flags.f._visuallyOrdered; } + void setVisuallyOrdered(bool b) { inherited_flags.f._visuallyOrdered = b; } + +// attribute getter methods + + EDisplay display() const { return noninherited_flags.f._display; } + EDisplay originalDisplay() const { return noninherited_flags.f._originalDisplay; } + + Length left() const { return surround->offset.left; } + Length right() const { return surround->offset.right; } + Length top() const { return surround->offset.top; } + Length bottom() const { return surround->offset.bottom; } + + EPosition position() const { return noninherited_flags.f._position; } + EFloat floating() const { return noninherited_flags.f._floating; } + + Length width() const { return box->width; } + Length height() const { return box->height; } + Length minWidth() const { return box->min_width; } + Length maxWidth() const { return box->max_width; } + Length minHeight() const { return box->min_height; } + Length maxHeight() const { return box->max_height; } + + const BorderData& border() const { return surround->border; } + const BorderValue& borderLeft() const { return surround->border.left; } + const BorderValue& borderRight() const { return surround->border.right; } + const BorderValue& borderTop() const { return surround->border.top; } + const BorderValue& borderBottom() const { return surround->border.bottom; } + + unsigned short borderLeftWidth() const { return surround->border.borderLeftWidth(); } + EBorderStyle borderLeftStyle() const { return surround->border.left.style; } + const TQColor& borderLeftColor() const { return surround->border.left.color; } + bool borderLeftIsTransparent() const { return surround->border.left.isTransparent(); } + unsigned short borderRightWidth() const { return surround->border.borderRightWidth(); } + EBorderStyle borderRightStyle() const { return surround->border.right.style; } + const TQColor& borderRightColor() const { return surround->border.right.color; } + bool borderRightIsTransparent() const { return surround->border.right.isTransparent(); } + unsigned short borderTopWidth() const { return surround->border.borderTopWidth(); } + EBorderStyle borderTopStyle() const { return surround->border.top.style; } + const TQColor& borderTopColor() const { return surround->border.top.color; } + bool borderTopIsTransparent() const { return surround->border.top.isTransparent(); } + unsigned short borderBottomWidth() const { return surround->border.borderBottomWidth(); } + EBorderStyle borderBottomStyle() const { return surround->border.bottom.style; } + const TQColor& borderBottomColor() const { return surround->border.bottom.color; } + bool borderBottomIsTransparent() const { return surround->border.bottom.isTransparent(); } + + unsigned short outlineSize() const { return outlineWidth() + outlineOffset(); } + unsigned short outlineWidth() const + { if(background->m_outline.style == BNONE || background->m_outline.style == BHIDDEN) return 0; + else return background->m_outline.width; } + EBorderStyle outlineStyle() const { return background->m_outline.style; } + bool outlineStyleIsAuto() const { return background->m_outline._auto; } + const TQColor & outlineColor() const { return background->m_outline.color; } + + EOverflow overflowX() const { return noninherited_flags.f._overflowX; } + EOverflow overflowY() const { return noninherited_flags.f._overflowY; } + bool hidesOverflow() const { + // either both overflow are visible or none are + return overflowX() != OVISIBLE; + } + + EVisibility visibility() const { return inherited_flags.f._visibility; } + EVerticalAlign verticalAlign() const { return noninherited_flags.f._vertical_align; } + Length verticalAlignLength() const { return box->vertical_align; } + + Length clipLeft() const { return visual->clip.left; } + Length clipRight() const { return visual->clip.right; } + Length clipTop() const { return visual->clip.top; } + Length clipBottom() const { return visual->clip.bottom; } + LengthBox clip() const { return visual->clip; } + bool hasClip() const { return noninherited_flags.f._hasClip; } + + EUnicodeBidi unicodeBidi() const { return noninherited_flags.f._unicodeBidi; } + + EClear clear() const { return noninherited_flags.f._clear; } + ETableLayout tableLayout() const { return noninherited_flags.f._table_layout; } + + const TQFont & font() const { return inherited->font.f; } + // use with care. call font->update() after modifications + const Font &htmlFont() { return inherited->font; } + const TQFontMetrics & fontMetrics() const { return inherited->font.fm; } + + const TQColor & color() const { return inherited->color; } + Length textIndent() const { return inherited->indent; } + ETextAlign textAlign() const { return inherited_flags.f._text_align; } + ETextTransform textTransform() const { return inherited_flags.f._text_transform; } + int textDecorationsInEffect() const { return inherited_flags.f._text_decorations; } + int textDecoration() const { return visual->textDecoration; } + int wordSpacing() const { return inherited->font.wordSpacing; } + int letterSpacing() const { return inherited->font.letterSpacing; } + + EDirection direction() const { return inherited_flags.f._direction; } + Length lineHeight() const { return inherited->line_height; } + + EWhiteSpace whiteSpace() const { return inherited_flags.f._white_space; } + bool autoWrap() const { + if (whiteSpace() == NORMAL || whiteSpace() == PRE_WRAP || whiteSpace() == PRE_LINE) + return true; + // nowrap | pre + return false; + } + bool preserveLF() const { + if (whiteSpace() == PRE || whiteSpace() == PRE_WRAP || whiteSpace() == PRE_LINE) + return true; + // normal | nowrap + return false; + } + bool preserveWS() const { + if (whiteSpace() == PRE || whiteSpace() == PRE_WRAP) + return true; + // normal | nowrap | pre-line + return false; + } + + const TQColor & backgroundColor() const { return background->m_color; } + CachedImage *backgroundImage() const { return background->m_background.m_image; } + EBackgroundRepeat backgroundRepeat() const { return background->m_background.m_bgRepeat; } + bool backgroundAttachment() const { return background->m_background.m_bgAttachment; } + Length backgroundXPosition() const { return background->m_background.m_xPosition; } + Length backgroundYPosition() const { return background->m_background.m_yPosition; } + BackgroundLayer* accessBackgroundLayers() { return &(background.access()->m_background); } + const BackgroundLayer* backgroundLayers() const { return &(background->m_background); } + + // returns true for collapsing borders, false for separate borders + bool borderCollapse() const { return inherited_flags.f._border_collapse; } + short borderHorizontalSpacing() const { return inherited->border_hspacing; } + short borderVerticalSpacing() const { return inherited->border_vspacing; } + EEmptyCell emptyCells() const { return inherited_flags.f._empty_cells; } + ECaptionSide captionSide() const { return inherited_flags.f._caption_side; } + + EListStyleType listStyleType() const { return inherited_flags.f._list_style_type; } + CachedImage *listStyleImage() const { return inherited->style_image; } + EListStylePosition listStylePosition() const { return inherited_flags.f._list_style_position; } + + Length marginTop() const { return surround->margin.top; } + Length marginBottom() const { return surround->margin.bottom; } + Length marginLeft() const { return surround->margin.left; } + Length marginRight() const { return surround->margin.right; } + + Length paddingTop() const { return surround->padding.top; } + Length paddingBottom() const { return surround->padding.bottom; } + Length paddingLeft() const { return surround->padding.left; } + Length paddingRight() const { return surround->padding.right; } + + ECursor cursor() const { return inherited_flags.f._cursor_style; } + + short widows() const { return inherited->widows; } + short orphans() const { return inherited->orphans; } + bool pageBreakInside() const { return inherited_flags.f._page_break_inside; } + EPageBreak pageBreakBefore() const { return noninherited_flags.f._page_break_before; } + EPageBreak pageBreakAfter() const { return noninherited_flags.f._page_break_after; } + + DOM::QuotesValueImpl* quotes() const { return inherited->quotes; } + TQString openQuote(int level) const; + TQString closeQuote(int level) const; + + // CSS3 Getter Methods + EBoxSizing boxSizing() const { return box->box_sizing; } + int outlineOffset() const { + if (background->m_outline.style == BNONE || background->m_outline.style == BHIDDEN) return 0; + return background->m_outline._offset; + } + ShadowData* textShadow() const { return css3InheritedData->textShadow; } + EWordWrap wordWrap() const { return css3InheritedData->wordWrap; } + float opacity() { return css3NonInheritedData->opacity; } + EUserInput userInput() const { return inherited_flags.f._user_input; } + + Length marqueeIncrement() { return css3NonInheritedData->marquee->increment; } + int marqueeSpeed() { return css3NonInheritedData->marquee->speed; } + int marqueeLoopCount() { return css3NonInheritedData->marquee->loops; } + EMarqueeBehavior marqueeBehavior() { return css3NonInheritedData->marquee->behavior; } + EMarqueeDirection marqueeDirection() { return css3NonInheritedData->marquee->direction; } + bool textOverflow() const { return noninherited_flags.f._textOverflow; } + // End CSS3 Getters + +// attribute setter methods + + void setDisplay(EDisplay v) { noninherited_flags.f._display = v; } + void setOriginalDisplay(EDisplay v) { noninherited_flags.f._originalDisplay = v; } + void setPosition(EPosition v) { noninherited_flags.f._position = v; } + void setFloating(EFloat v) { noninherited_flags.f._floating = v; } + + void setLeft(Length v) { SET_VAR(surround,offset.left,v) } + void setRight(Length v) { SET_VAR(surround,offset.right,v) } + void setTop(Length v) { SET_VAR(surround,offset.top,v) } + void setBottom(Length v){ SET_VAR(surround,offset.bottom,v) } + + void setWidth(Length v) { SET_VAR(box,width,v) } + void setHeight(Length v) { SET_VAR(box,height,v) } + + void setMinWidth(Length v) { SET_VAR(box,min_width,v) } + void setMaxWidth(Length v) { SET_VAR(box,max_width,v) } + void setMinHeight(Length v) { SET_VAR(box,min_height,v) } + void setMaxHeight(Length v) { SET_VAR(box,max_height,v) } + + void resetBorderTop() { SET_VAR(surround, border.top, BorderValue()) } + void resetBorderRight() { SET_VAR(surround, border.right, BorderValue()) } + void resetBorderBottom() { SET_VAR(surround, border.bottom, BorderValue()) } + void resetBorderLeft() { SET_VAR(surround, border.left, BorderValue()) } + void resetOutline() { SET_VAR(background, m_outline, OutlineValue()) } + + void setBackgroundColor(const TQColor& v) { SET_VAR(background, m_color, v) } + + void setBorderLeftWidth(unsigned short v) { SET_VAR(surround,border.left.width,v) } + void setBorderLeftStyle(EBorderStyle v) { SET_VAR(surround,border.left.style,v) } + void setBorderLeftColor(const TQColor & v) { SET_VAR(surround,border.left.color,v) } + void setBorderRightWidth(unsigned short v) { SET_VAR(surround,border.right.width,v) } + void setBorderRightStyle(EBorderStyle v) { SET_VAR(surround,border.right.style,v) } + void setBorderRightColor(const TQColor & v) { SET_VAR(surround,border.right.color,v) } + void setBorderTopWidth(unsigned short v) { SET_VAR(surround,border.top.width,v) } + void setBorderTopStyle(EBorderStyle v) { SET_VAR(surround,border.top.style,v) } + void setBorderTopColor(const TQColor & v) { SET_VAR(surround,border.top.color,v) } + void setBorderBottomWidth(unsigned short v) { SET_VAR(surround,border.bottom.width,v) } + void setBorderBottomStyle(EBorderStyle v) { SET_VAR(surround,border.bottom.style,v) } + void setBorderBottomColor(const TQColor & v) { SET_VAR(surround,border.bottom.color,v) } + void setOutlineWidth(unsigned short v) { SET_VAR(background,m_outline.width,v) } + void setOutlineStyle(EBorderStyle v, bool isAuto = false) + { + SET_VAR(background,m_outline.style,v) + SET_VAR(background,m_outline._auto, isAuto) + } + void setOutlineColor(const TQColor & v) { SET_VAR(background,m_outline.color,v) } + + void setOverflowX(EOverflow v) { noninherited_flags.f._overflowX = v; } + void setOverflowY(EOverflow v) { noninherited_flags.f._overflowY = v; } + void setVisibility(EVisibility v) { inherited_flags.f._visibility = v; } + void setVerticalAlign(EVerticalAlign v) { noninherited_flags.f._vertical_align = v; } + void setVerticalAlignLength(Length l) { SET_VAR(box, vertical_align, l ) } + + void setClipLeft(Length v) { SET_VAR(visual,clip.left,v) } + void setClipRight(Length v) { SET_VAR(visual,clip.right,v) } + void setClipTop(Length v) { SET_VAR(visual,clip.top,v) } + void setClipBottom(Length v) { SET_VAR(visual,clip.bottom,v) } + void setClip( Length top, Length right, Length bottom, Length left ); + void setHasClip( bool b ) { noninherited_flags.f._hasClip = b; } + + void setUnicodeBidi( EUnicodeBidi b ) { noninherited_flags.f._unicodeBidi = b; } + + void setClear(EClear v) { noninherited_flags.f._clear = v; } + void setTableLayout(ETableLayout v) { noninherited_flags.f._table_layout = v; } + bool setFontDef(const tdehtml::FontDef & v) { + // bah, this doesn't compare pointers. broken! (Dirk) + if (!(inherited->font.fontDef == v)) { + inherited.access()->font = Font( v ); + return true; + } + return false; + } + + void setColor(const TQColor & v) { SET_VAR(inherited,color,v) } + void setTextIndent(Length v) { SET_VAR(inherited,indent,v) } + void setTextAlign(ETextAlign v) { inherited_flags.f._text_align = v; } + void setTextTransform(ETextTransform v) { inherited_flags.f._text_transform = v; } + void addToTextDecorationsInEffect(int v) { inherited_flags.f._text_decorations |= v; } + void setTextDecorationsInEffect(int v) { inherited_flags.f._text_decorations = v; } + void setTextDecoration(unsigned v) { SET_VAR(visual, textDecoration, v); } + void setDirection(EDirection v) { inherited_flags.f._direction = v; } + void setLineHeight(Length v) { SET_VAR(inherited,line_height,v) } + + void setWhiteSpace(EWhiteSpace v) { inherited_flags.f._white_space = v; } + + void setWordSpacing(int v) { SET_VAR(inherited,font.wordSpacing,v) } + void setLetterSpacing(int v) { SET_VAR(inherited,font.letterSpacing,v) } + + void clearBackgroundLayers() { background.access()->m_background = BackgroundLayer(); } + void inheritBackgroundLayers(const BackgroundLayer& parent) { background.access()->m_background = parent; } + void adjustBackgroundLayers(); + + void setBorderCollapse(bool collapse) { inherited_flags.f._border_collapse = collapse; } + void setBorderHorizontalSpacing(short v) { SET_VAR(inherited,border_hspacing,v) } + void setBorderVerticalSpacing(short v) { SET_VAR(inherited,border_vspacing,v) } + + void setEmptyCells(EEmptyCell v) { inherited_flags.f._empty_cells = v; } + void setCaptionSide(ECaptionSide v) { inherited_flags.f._caption_side = v; } + + void setListStyleType(EListStyleType v) { inherited_flags.f._list_style_type = v; } + void setListStyleImage(CachedImage *v) { SET_VAR(inherited,style_image,v)} + void setListStylePosition(EListStylePosition v) { inherited_flags.f._list_style_position = v; } + + void resetMargin() { SET_VAR(surround, margin, LengthBox(Fixed)) } + void setMarginTop(Length v) { SET_VAR(surround,margin.top,v) } + void setMarginBottom(Length v) { SET_VAR(surround,margin.bottom,v) } + void setMarginLeft(Length v) { SET_VAR(surround,margin.left,v) } + void setMarginRight(Length v) { SET_VAR(surround,margin.right,v) } + + void resetPadding() { SET_VAR(surround, padding, LengthBox(Variable)) } + void setPaddingTop(Length v) { SET_VAR(surround,padding.top,v) } + void setPaddingBottom(Length v) { SET_VAR(surround,padding.bottom,v) } + void setPaddingLeft(Length v) { SET_VAR(surround,padding.left,v) } + void setPaddingRight(Length v) { SET_VAR(surround,padding.right,v) } + + void setCursor( ECursor c ) { inherited_flags.f._cursor_style = c; } + + bool htmlHacks() const { return inherited_flags.f._htmlHacks; } + void setHtmlHacks(bool b=true) { inherited_flags.f._htmlHacks = b; } + + bool flowAroundFloats() const { return noninherited_flags.f._flowAroundFloats; } + void setFlowAroundFloats(bool b=true) { noninherited_flags.f._flowAroundFloats = b; } + + int zIndex() const { return box->z_auto? 0 : box->z_index; } + void setZIndex(int v) { SET_VAR(box,z_auto,false ); SET_VAR(box, z_index, v); } + bool hasAutoZIndex() const { return box->z_auto; } + void setHasAutoZIndex() { SET_VAR(box, z_auto, true ); } + + void setWidows(short w) { SET_VAR(inherited, widows, w); } + void setOrphans(short o) { SET_VAR(inherited, orphans, o); } + void setPageBreakInside(bool b) { inherited_flags.f._page_break_inside = b; } + void setPageBreakBefore(EPageBreak b) { noninherited_flags.f._page_break_before = b; } + void setPageBreakAfter(EPageBreak b) { noninherited_flags.f._page_break_after = b; } + + void setQuotes(DOM::QuotesValueImpl* q); + + // CSS3 Setters + void setBoxSizing( EBoxSizing b ) { SET_VAR(box,box_sizing,b); } + void setOutlineOffset(unsigned short v) { SET_VAR(background,m_outline._offset,v) } + void setWordWrap(EWordWrap w) { SET_VAR(css3InheritedData, wordWrap, w); } + void setTextShadow(ShadowData* val, bool add=false); + void setOpacity(float f) { SET_VAR(css3NonInheritedData, opacity, f); } + void setUserInput(EUserInput ui) { inherited_flags.f._user_input = ui; } + + void setMarqueeIncrement(const Length& f) { SET_VAR(css3NonInheritedData.access()->marquee, increment, f); } + void setMarqueeSpeed(int f) { SET_VAR(css3NonInheritedData.access()->marquee, speed, f); } + void setMarqueeDirection(EMarqueeDirection d) { SET_VAR(css3NonInheritedData.access()->marquee, direction, d); } + void setMarqueeBehavior(EMarqueeBehavior b) { SET_VAR(css3NonInheritedData.access()->marquee, behavior, b); } + void setMarqueeLoopCount(int i) { SET_VAR(css3NonInheritedData.access()->marquee, loops, i); } + void setTextOverflow(bool b) { noninherited_flags.f._textOverflow = b; } + // End CSS3 Setters + + TQPalette palette() const { return visual->palette; } + void setPaletteColor(TQPalette::ColorGroup g, TQColorGroup::ColorRole r, const TQColor& c); + void resetPalette() // Called when the desktop color scheme changes. + { + const_cast<StyleVisualData *>(visual.get())->palette = TQApplication::palette(); + } + + bool useNormalContent() const { return generated->content == 0; } + ContentData* contentData() const { return generated->content; } + bool contentDataEquivalent(const RenderStyle* otherStyle) const + { + return generated->contentDataEquivalent(otherStyle->generated.get()); + } + void addContent(DOM::DOMStringImpl* s); + void addContent(CachedObject* o); + void addContent(DOM::CounterImpl* c); + void addContent(EQuoteContent q); + void setContentNone(); + void setContentNormal(); + void setContentData(ContentData* content); + + DOM::CSSValueListImpl* counterReset() const { return generated->counter_reset; } + DOM::CSSValueListImpl* counterIncrement() const { return generated->counter_increment; } + void setCounterReset(DOM::CSSValueListImpl* v); + void setCounterIncrement(DOM::CSSValueListImpl* v); + bool hasCounterReset(const DOM::DOMString& c) const; + bool hasCounterIncrement(const DOM::DOMString& c) const; + short counterReset(const DOM::DOMString& c) const; + short counterIncrement(const DOM::DOMString& c) const; + + + bool inheritedNotEqual( RenderStyle *other ) const; + + enum Diff { Equal, NonVisible = Equal, Visible, Position, Layout, CbLayout }; + Diff diff( const RenderStyle *other ) const; + + bool isDisplayReplacedType() { + return display() == INLINE_BLOCK ||/* display() == INLINE_BOX ||*/ display() == INLINE_TABLE; + } + bool isDisplayInlineType() { + return display() == INLINE || isDisplayReplacedType(); + } + bool isOriginalDisplayInlineType() { + return originalDisplay() == INLINE || originalDisplay() == INLINE_BLOCK || + /*originalDisplay() == INLINE_BOX ||*/ originalDisplay() == INLINE_TABLE; + } + + +#ifdef ENABLE_DUMP + TQString createDiff( const RenderStyle &parent ) const; +#endif + + // Initial values for all the properties + static bool initialBackgroundAttachment() { return true; } + static EBackgroundBox initialBackgroundClip() { return BGBORDER; } + static EBackgroundBox initialBackgroundOrigin() { return BGPADDING; } + static EBackgroundRepeat initialBackgroundRepeat() { return REPEAT; } + static LengthSize initialBackgroundSize() { return LengthSize(); } + static bool initialBorderCollapse() { return false; } + static EBorderStyle initialBorderStyle() { return BNONE; } + static ECaptionSide initialCaptionSide() { return CAPTOP; } + static EClear initialClear() { return CNONE; } + static EDirection initialDirection() { return LTR; } + static EDisplay initialDisplay() { return INLINE; } + static EEmptyCell initialEmptyCells() { return SHOW; } + static EFloat initialFloating() { return FNONE; } + static EWordWrap initialWordWrap() { return WWNORMAL; } + static EListStylePosition initialListStylePosition() { return OUTSIDE; } + static EListStyleType initialListStyleType() { return LDISC; } + static EOverflow initialOverflowX() { return OVISIBLE; } + static EOverflow initialOverflowY() { return OVISIBLE; } + static EPageBreak initialPageBreak() { return PBAUTO; } + static bool initialPageBreakInside() { return true; } + static EPosition initialPosition() { return STATIC; } + static ETableLayout initialTableLayout() { return TAUTO; } + static EUnicodeBidi initialUnicodeBidi() { return UBNormal; } + static DOM::QuotesValueImpl* initialQuotes() { return 0; } + static EBoxSizing initialBoxSizing() { return CONTENT_BOX; } + static ETextTransform initialTextTransform() { return TTNONE; } + static EVisibility initialVisibility() { return VISIBLE; } + static EWhiteSpace initialWhiteSpace() { return NORMAL; } + static Length initialBackgroundXPosition() { return Length(); } + static Length initialBackgroundYPosition() { return Length(); } + static short initialBorderHorizontalSpacing() { return 0; } + static short initialBorderVerticalSpacing() { return 0; } + static ECursor initialCursor() { return CURSOR_AUTO; } + static TQColor initialColor() { return Qt::black; } + static CachedImage* initialBackgroundImage() { return 0; } + static CachedImage* initialListStyleImage() { return 0; } + static unsigned short initialBorderWidth() { return 3; } + static int initialLetterWordSpacing() { return 0; } + static Length initialSize() { return Length(); } + static Length initialMinSize() { return Length(0, Fixed); } + static Length initialMaxSize() { return Length(UNDEFINED, Fixed); } + static Length initialOffset() { return Length(); } + static Length initialMargin() { return Length(Fixed); } + static Length initialPadding() { return Length(Variable); } + static Length initialTextIndent() { return Length(Fixed); } + static EVerticalAlign initialVerticalAlign() { return BASELINE; } + static int initialWidows() { return 2; } + static int initialOrphans() { return 2; } + static Length initialLineHeight() { return Length(-100, Percent); } + static ETextAlign initialTextAlign() { return TAAUTO; } + static ETextDecoration initialTextDecoration() { return TDNONE; } + static bool initialFlowAroundFloats() { return false; } + static int initialOutlineOffset() { return 0; } + static float initialOpacity() { return 1.0f; } + static int initialMarqueeLoopCount() { return -1; } + static int initialMarqueeSpeed() { return 85; } + static Length initialMarqueeIncrement() { return Length(6, Fixed); } + static EMarqueeBehavior initialMarqueeBehavior() { return MSCROLL; } + static EMarqueeDirection initialMarqueeDirection() { return MAUTO; } + static bool initialTextOverflow() { return false; } +}; + +class RenderPageStyle { + friend class CSSStyleSelector; +public: + enum PageType { NO_PAGE = 0, ANY_PAGE, FIRST_PAGE, LEFT_PAGES, RIGHT_PAGES }; + + RenderPageStyle(); + ~RenderPageStyle(); + + PageType pageType() { return m_pageType; } + + RenderPageStyle* getPageStyle(PageType type); + RenderPageStyle* addPageStyle(PageType type); + void removePageStyle(PageType type); + + Length marginTop() const { return margin.top; } + Length marginBottom() const { return margin.bottom; } + Length marginLeft() const { return margin.left; } + Length marginRight() const { return margin.right; } + + Length pageWidth() const { return m_pageWidth; } + Length pageHeight() const { return m_pageHeight; } + + void setMarginTop(Length v) { margin.top = v; } + void setMarginBottom(Length v) { margin.bottom = v; } + void setMarginLeft(Length v) { margin.left = v; } + void setMarginRight(Length v) { margin.right = v; } + + void setPageWidth(Length v) { m_pageWidth = v; } + void setPageHeight(Length v) { m_pageHeight = v; } + +protected: + RenderPageStyle *next; + PageType m_pageType; + + LengthBox margin; + Length m_pageWidth; + Length m_pageHeight; +}; + +} // namespace + +#endif + diff --git a/tdehtml/rendering/render_table.cpp b/tdehtml/rendering/render_table.cpp new file mode 100644 index 000000000..ef7fe1031 --- /dev/null +++ b/tdehtml/rendering/render_table.cpp @@ -0,0 +1,3070 @@ +/** + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1997 Martin Jones (mjones@kde.org) + * (C) 1997 Torben Weis (weis@kde.org) + * (C) 1998 Waldo Bastian (bastian@kde.org) + * (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2003 Apple Computer, Inc. + * (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +//#define TABLE_DEBUG +//#define TABLE_PRINT +//#define DEBUG_LAYOUT +//#define BOX_DEBUG +#include "rendering/render_table.h" +#include "rendering/render_replaced.h" +#include "rendering/render_canvas.h" +#include "rendering/table_layout.h" +#include "html/html_tableimpl.h" +#include "html/html_formimpl.h" +#include "misc/htmltags.h" +#include "misc/htmlattrs.h" +#include "rendering/render_line.h" +#include "xml/dom_docimpl.h" + +#include <kglobal.h> + +#include <tqapplication.h> +#include <tqstyle.h> + +#include <kdebug.h> +#include <assert.h> + +using namespace tdehtml; +using namespace DOM; + +RenderTable::RenderTable(DOM::NodeImpl* node) + : RenderBlock(node) +{ + + tCaption = 0; + head = foot = firstBody = 0; + tableLayout = 0; + m_currentBorder = 0; + + has_col_elems = false; + hspacing = vspacing = 0; + padding = 0; + needSectionRecalc = false; + padding = 0; + + columnPos.resize( 2 ); + columnPos.fill( 0 ); + columns.resize( 1 ); + columns.fill( ColumnStruct() ); + + columnPos[0] = 0; +} + +RenderTable::~RenderTable() +{ + delete tableLayout; +} + +void RenderTable::setStyle(RenderStyle *_style) +{ + ETableLayout oldTableLayout = style() ? style()->tableLayout() : TAUTO; + if ( _style->display() == INLINE ) _style->setDisplay( INLINE_TABLE ); + if ( _style->display() != INLINE_TABLE ) _style->setDisplay(TABLE); + if ( !_style->flowAroundFloats() ) _style->setFlowAroundFloats(true); + RenderBlock::setStyle(_style); + + // init RenderObject attributes + setInline(style()->display()==INLINE_TABLE && !isPositioned()); + setReplaced(style()->display()==INLINE_TABLE); + + // In the collapsed border model, there is no cell spacing. + hspacing = collapseBorders() ? 0 : style()->borderHorizontalSpacing(); + vspacing = collapseBorders() ? 0 : style()->borderVerticalSpacing(); + columnPos[0] = hspacing; + + if ( !tableLayout || style()->tableLayout() != oldTableLayout ) { + delete tableLayout; + + // According to the CSS2 spec, you only use fixed table layout if an + // explicit width is specified on the table. Auto width implies auto table layout. + if (style()->tableLayout() == TFIXED && !style()->width().isVariable()) { + tableLayout = new FixedTableLayout(this); +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << "using fixed table layout" << endl; +#endif + } else + tableLayout = new AutoTableLayout(this); + } +} + +short RenderTable::lineHeight(bool b) const +{ + // Inline tables are replaced elements. Otherwise, just pass off to + // the base class. + if (isReplaced()) + return height()+marginTop()+marginBottom(); + return RenderBlock::lineHeight(b); +} + +short RenderTable::baselinePosition(bool b) const +{ + // Inline tables are replaced elements. Otherwise, just pass off to + // the base class. + if (isReplaced()) + return height()+marginTop()+marginBottom(); + return RenderBlock::baselinePosition(b); +} + + +void RenderTable::addChild(RenderObject *child, RenderObject *beforeChild) +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(Table)::addChild( " << child->renderName() << ", " << + (beforeChild ? beforeChild->renderName() : "0") << " )" << endl; +#endif + bool wrapInAnonymousSection = false; + + switch(child->style()->display()) + { + case TABLE_CAPTION: + if (child->isRenderBlock()) + tCaption = static_cast<RenderBlock *>(child); + break; + case TABLE_COLUMN: + case TABLE_COLUMN_GROUP: + has_col_elems = true; + break; + case TABLE_HEADER_GROUP: + if ( !head ) { + if (child->isTableSection()) + head = static_cast<RenderTableSection *>(child); + } + else if ( !firstBody ) + if (child->isTableSection()) + firstBody = static_cast<RenderTableSection *>(child); + break; + case TABLE_FOOTER_GROUP: + if ( !foot ) { + if (child->isTableSection()) + foot = static_cast<RenderTableSection *>(child); + break; + } + // fall through + case TABLE_ROW_GROUP: + if(!firstBody) + if (child->isTableSection()) + firstBody = static_cast<RenderTableSection *>(child); + break; + case TABLE_CELL: + case TABLE_ROW: + wrapInAnonymousSection = true; + break; + case BLOCK: +// case BOX: + case COMPACT: + case INLINE: + case INLINE_BLOCK: +// case INLINE_BOX: + case INLINE_TABLE: + case LIST_ITEM: + case NONE: + case RUN_IN: + case TABLE: + // The special TABLE > FORM quirk allows the form to sit directly under the table + if (child->element() && child->element()->isHTMLElement() && child->element()->id() == ID_FORM) + wrapInAnonymousSection = !static_cast<HTMLFormElementImpl*>(child->element())->isMalformed(); + else + wrapInAnonymousSection = true; + break; + } + + if (!wrapInAnonymousSection) { + RenderContainer::addChild(child, beforeChild); + return; + } + + if (!beforeChild && lastChild() && lastChild()->isTableSection() && lastChild()->isAnonymous()) { + lastChild()->addChild(child); + return; + } + + RenderObject *lastBox = beforeChild; + RenderObject *nextToLastBox = beforeChild; + while (lastBox && lastBox->parent()->isAnonymous() && + !lastBox->isTableSection() && lastBox->style()->display() != TABLE_CAPTION) { + nextToLastBox = lastBox; + lastBox = lastBox->parent(); + } + if (lastBox && lastBox->isAnonymous()) { + lastBox->addChild(child, nextToLastBox); + return; + } + + if (beforeChild && !beforeChild->isTableSection()) + beforeChild = 0; + RenderTableSection* section = new (renderArena()) RenderTableSection(document() /* anonymous */); + RenderStyle* newStyle = new RenderStyle(); + newStyle->inheritFrom(style()); + newStyle->setDisplay(TABLE_ROW_GROUP); + section->setStyle(newStyle); + addChild(section, beforeChild); + section->addChild(child); +} + +void RenderTable::calcWidth() +{ + if ( isPositioned() ) { + calcAbsoluteHorizontal(); + } + + RenderBlock *cb = containingBlock(); + int availableWidth = cb->lineWidth( m_y ); + + LengthType widthType = style()->width().type(); + if(widthType > Relative && style()->width().value() > 0) { + // Percent or fixed table + // Percent is calculated from contentWidth, not available width + m_width = calcBoxWidth(style()->width().minWidth( cb->contentWidth() )); + } else { + // Subtract out any fixed margins from our available width for auto width tables. + int marginTotal = 0; + if (!style()->marginLeft().isVariable()) + marginTotal += style()->marginLeft().width(availableWidth); + if (!style()->marginRight().isVariable()) + marginTotal += style()->marginRight().width(availableWidth); + + // Subtract out our margins to get the available content width. + int availContentWidth = kMax(0, availableWidth - marginTotal); + + // Ensure we aren't bigger than our max width or smaller than our min width. + m_width = kMin(availContentWidth, m_maxWidth); + } + + m_width = kMax (m_width, m_minWidth); + + // Finally, with our true width determined, compute our margins for real. + m_marginRight=0; + m_marginLeft=0; + + calcHorizontalMargins(style()->marginLeft(),style()->marginRight(),availableWidth); +} + +void RenderTable::layout() +{ + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + KHTMLAssert( !needSectionRecalc ); + + if (posChildNeedsLayout() && !normalChildNeedsLayout() && !selfNeedsLayout()) { + // All we have to is lay out our positioned objects. + layoutPositionedObjects(true); + setNeedsLayout(false); + return; + } + + if (markedForRepaint()) { + repaintDuringLayout(); + setMarkedForRepaint(false); + } + + m_height = 0; + initMaxMarginValues(); + + int oldWidth = m_width; + calcWidth(); + m_overflowWidth = m_width; + + if (tCaption && (oldWidth != m_width || tCaption->style()->height().isPercent())) + tCaption->setChildNeedsLayout(true); + + // the optimization below doesn't work since the internal table + // layout could have changed. we need to add a flag to the table + // layout that tells us if something has changed in the min max + // calculations to do it correctly. +// if ( oldWidth != m_width || columns.size() + 1 != columnPos.size() ) + tableLayout->layout(); + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(Table)::layout1() width=" << width() << ", marginLeft=" << marginLeft() << " marginRight=" << marginRight() << endl; +#endif + + setCellWidths(); + + // layout child objects + int calculatedHeight = 0; + + RenderObject *child = firstChild(); + while( child ) { + // FIXME: What about a form that has a display value that makes it a table section? + if ( child->needsLayout() && !(child->element() && child->element()->id() == ID_FORM) ) + child->layout(); + if ( child->isTableSection() ) { + static_cast<RenderTableSection *>(child)->calcRowHeight(); + calculatedHeight += static_cast<RenderTableSection *>(child)->layoutRows( 0 ); + } + child = child->nextSibling(); + } + + // ### collapse caption margin + if(tCaption && tCaption->style()->captionSide() != CAPBOTTOM) { + tCaption->setPos(tCaption->marginLeft(), tCaption->marginTop()+m_height); + m_height += tCaption->height() + tCaption->marginTop() + tCaption->marginBottom(); + } + + int bpTop = borderTop() + (collapseBorders() ? 0 : paddingTop()); + int bpBottom = borderBottom() + (collapseBorders() ? 0 : paddingBottom()); + + m_height += bpTop; + + int oldHeight = m_height; + if (isPositioned()) + m_height += calculatedHeight + bpBottom; + calcHeight(); + int newHeight = m_height; + m_height = oldHeight; + + Length h = style()->height(); + int th = -(bpTop + bpBottom); // Tables size as though CSS height includes border/padding. + if (isPositioned()) + th += newHeight; + else if (h.isFixed()) + th += h.value(); + else if (h.isPercent()) + th += calcPercentageHeight(h); + + // layout rows + if ( th > calculatedHeight ) { + // we have to redistribute that height to get the constraint correctly + // just force the first body to the height needed + // ### FIXME This should take height constraints on all table sections into account and distribute + // accordingly. For now this should be good enough + if (firstBody) { + firstBody->calcRowHeight(); + firstBody->layoutRows( th - calculatedHeight ); + } + else if (!style()->htmlHacks()) { + // Completely empty tables (with no sections or anything) should at least honor specified height + // in strict mode. + m_height += th; + } + } + + int bl = borderLeft(); + if (!collapseBorders()) + bl += paddingLeft(); + + // position the table sections + if ( head ) { + head->setPos(bl, m_height); + m_height += head->height(); + } + RenderObject *body = firstBody; + while ( body ) { + if ( body != head && body != foot && body->isTableSection() ) { + body->setPos(bl, m_height); + m_height += body->height(); + } + body = body->nextSibling(); + } + if ( foot ) { + foot->setPos(bl, m_height); + m_height += foot->height(); + } + + m_height += bpBottom; + + if(tCaption && tCaption->style()->captionSide()==CAPBOTTOM) { + tCaption->setPos(tCaption->marginLeft(), tCaption->marginTop()+m_height); + m_height += tCaption->height() + tCaption->marginTop() + tCaption->marginBottom(); + } + + if (canvas()->pagedMode()) { + RenderObject *child = firstChild(); + // relayout taking real position into account + while( child ) { + if ( !(child->element() && child->element()->id() == ID_FORM) ) { + child->setNeedsLayout(true); + child->layout(); + if (child->containsPageBreak()) setContainsPageBreak(true); + if (child->needsPageClear()) setNeedsPageClear(true); + } + child = child->nextSibling(); + } + } + + //kdDebug(0) << "table height: " << m_height << endl; + + // table can be containing block of positioned elements. + // ### only pass true if width or height changed. + layoutPositionedObjects( true ); + + m_overflowHeight = m_height; + + setNeedsLayout(false); +} + +void RenderTable::setCellWidths() +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(Table, this=0x" << this << ")::setCellWidths()" << endl; +#endif + + RenderObject *child = firstChild(); + while( child ) { + if ( child->isTableSection() ) + static_cast<RenderTableSection *>(child)->setCellWidths(); + child = child->nextSibling(); + } +} + +void RenderTable::paint( PaintInfo& pI, int _tx, int _ty) +{ + if(needsLayout()) return; + + _tx += xPos(); + _ty += yPos(); + +#ifdef TABLE_PRINT + kdDebug( 6040 ) << "RenderTable::paint() w/h = (" << width() << "/" << height() << ")" << endl; +#endif + if (!overhangingContents() && !isRelPositioned() && !isPositioned()) + { + int os = 2*maximalOutlineSize(pI.phase); + if((_ty > pI.r.y() + pI.r.height() + os) || (_ty + height() < pI.r.y() - os)) return; + if((_tx > pI.r.x() + pI.r.width() + os) || (_tx + width() < pI.r.x() - os)) return; + } + +#ifdef TABLE_PRINT + kdDebug( 6040 ) << "RenderTable::paint(2) " << _tx << "/" << _ty << " (" << _y << "/" << _h << ")" << endl; +#endif + + if (pI.phase == PaintActionOutline) + paintOutline(pI.p, _tx, _ty, width(), height(), style()); + + if(( pI.phase == PaintActionElementBackground || pI.phase == PaintActionChildBackground ) + && shouldPaintBackgroundOrBorder() && style()->visibility() == VISIBLE) + paintBoxDecorations(pI, _tx, _ty); + + if ( pI.phase == PaintActionElementBackground ) + return; + + PaintAction oldphase = pI.phase; + if ( pI.phase == PaintActionChildBackgrounds ) + pI.phase = PaintActionChildBackground; + + for( RenderObject *child = firstChild(); child; child = child->nextSibling()) + if ( child->isTableSection() || child == tCaption ) + child->paint( pI, _tx, _ty ); + + if (collapseBorders() && + (pI.phase == PaintActionElementBackground || pI.phase == PaintActionChildBackground) + && style()->visibility() == VISIBLE) { + // Collect all the unique border styles that we want to paint in a sorted list. Once we + // have all the styles sorted, we then do individual passes, painting each style of border + // from lowest precedence to highest precedence. + pI.phase = PaintActionCollapsedTableBorders; + TQValueList<CollapsedBorderValue> borderStyles; + collectBorders(borderStyles); +#if 0 + TQString m; + for (uint i = 0; i < borderStyles.count(); i++) + m += TQString("%1 ").arg((*borderStyles.at(i)).width()); + kdDebug(6040) << m << endl; +#endif + TQValueListIterator<CollapsedBorderValue> it = borderStyles.begin(); + TQValueListIterator<CollapsedBorderValue> end = borderStyles.end(); + for (; it != end; ++it) { + m_currentBorder = &*it; + for (RenderObject *child = firstChild(); child; child = child->nextSibling()) { + if (child->isTableSection()) + child->paint(pI, _tx, _ty); + } + } + m_currentBorder = 0; + } + + pI.phase = oldphase; +#ifdef BOX_DEBUG + outlineBox(p, _tx, _ty, "blue"); +#endif +} + +void RenderTable::paintBoxDecorations(PaintInfo &pI, int _tx, int _ty) +{ + int w = width(); + int h = height(); + + // Account for the caption. + if (tCaption) { + int captionHeight = (tCaption->height() + tCaption->marginBottom() + tCaption->marginTop()); + h -= captionHeight; + if (tCaption->style()->captionSide() != CAPBOTTOM) + _ty += captionHeight; + } + + int my = kMax(_ty,pI.r.y()); + int mh; + if (_ty<pI.r.y()) + mh= kMax(0,h-(pI.r.y()-_ty)); + else + mh = kMin(pI.r.height(),h); + + paintBackground(pI.p, style()->backgroundColor(), style()->backgroundLayers(), my, mh, _tx, _ty, w, h); + + if (style()->hasBorder() && !collapseBorders()) + paintBorder(pI.p, _tx, _ty, w, h, style()); +} + +void RenderTable::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + if ( needSectionRecalc ) + recalcSections(); + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(Table " << this << ")::calcMinMaxWidth()" << endl; +#endif + + tableLayout->calcMinMaxWidth(); + + if (tCaption) { + tCaption->calcWidth(); + if (tCaption->marginLeft()+tCaption->marginRight()+tCaption->minWidth() > m_minWidth) + m_minWidth = tCaption->marginLeft()+tCaption->marginRight()+tCaption->minWidth(); + } + + setMinMaxKnown(); +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << " END: (Table " << this << ")::calcMinMaxWidth() min = " << m_minWidth << " max = " << m_maxWidth << endl; +#endif +} + +void RenderTable::close() +{ +// kdDebug( 6040 ) << "RenderTable::close()" << endl; + setNeedsLayoutAndMinMaxRecalc(); +} + +void RenderTable::splitColumn( int pos, int firstSpan ) +{ + // we need to add a new columnStruct + int oldSize = columns.size(); + columns.resize( oldSize + 1 ); + int oldSpan = columns[pos].span; +// tqDebug("splitColumn( %d,%d ), oldSize=%d, oldSpan=%d", pos, firstSpan, oldSize, oldSpan ); + KHTMLAssert( oldSpan > firstSpan ); + columns[pos].span = firstSpan; + memmove( columns.data()+pos+1, columns.data()+pos, (oldSize-pos)*sizeof(ColumnStruct) ); + columns[pos+1].span = oldSpan - firstSpan; + + // change width of all rows. + RenderObject *child = firstChild(); + while ( child ) { + if ( child->isTableSection() ) { + RenderTableSection *section = static_cast<RenderTableSection *>(child); + int size = section->grid.size(); + int row = 0; + if ( section->cCol > pos ) + section->cCol++; + while ( row < size ) { + section->grid[row].row->resize( oldSize+1 ); + RenderTableSection::Row &r = *section->grid[row].row; + memmove( r.data()+pos+1, r.data()+pos, (oldSize-pos)*sizeof( RenderTableCell * ) ); +// tqDebug("moving from %d to %d, num=%d", pos, pos+1, (oldSize-pos-1) ); + r[pos+1] = r[pos] ? (RenderTableCell *)-1 : 0; + row++; + } + } + child = child->nextSibling(); + } + columnPos.resize( numEffCols()+1 ); + setNeedsLayoutAndMinMaxRecalc(); +} + +void RenderTable::appendColumn( int span ) +{ + // easy case. + int pos = columns.size(); +// tqDebug("appendColumn( %d ), size=%d", span, pos ); + int newSize = pos + 1; + columns.resize( newSize ); + columns[pos].span = span; + //tqDebug("appending column at %d, span %d", pos, span ); + + // change width of all rows. + RenderObject *child = firstChild(); + while ( child ) { + if ( child->isTableSection() ) { + RenderTableSection *section = static_cast<RenderTableSection *>(child); + int size = section->grid.size(); + int row = 0; + while ( row < size ) { + section->grid[row].row->resize( newSize ); + section->cellAt( row, pos ) = 0; + row++; + } + + } + child = child->nextSibling(); + } + columnPos.resize( numEffCols()+1 ); + setNeedsLayoutAndMinMaxRecalc(); +} + +RenderTableCol *RenderTable::colElement( int col ) { + if ( !has_col_elems ) + return 0; + RenderObject *child = firstChild(); + int cCol = 0; + while ( child ) { + if ( child->isTableCol() ) { + RenderTableCol *colElem = static_cast<RenderTableCol *>(child); + int span = colElem->span(); + if ( !colElem->firstChild() ) { + cCol += span; + if ( cCol > col ) + return colElem; + } + + RenderObject *next = child->firstChild(); + if ( !next ) + next = child->nextSibling(); + if ( !next && child->parent()->isTableCol() ) + next = child->parent()->nextSibling(); + child = next; + } else if (child == tCaption) { + child = child->nextSibling(); + } else + break; + } + return 0; +} + +void RenderTable::recalcSections() +{ + tCaption = 0; + head = foot = firstBody = 0; + has_col_elems = false; + + RenderObject *child = firstChild(); + // We need to get valid pointers to caption, head, foot and firstbody again + while ( child ) { + switch(child->style()->display()) { + case TABLE_CAPTION: + if ( !tCaption && child->isRenderBlock() ) { + tCaption = static_cast<RenderBlock*>(child); + tCaption->setNeedsLayout(true); + } + break; + case TABLE_COLUMN: + case TABLE_COLUMN_GROUP: + has_col_elems = true; + break; + case TABLE_HEADER_GROUP: + if (child->isTableSection()) { + RenderTableSection *section = static_cast<RenderTableSection *>(child); + if (!head) + head = section; + else if (!firstBody) + firstBody = section; + if (section->needCellRecalc) + section->recalcCells(); + } + break; + case TABLE_FOOTER_GROUP: + if (child->isTableSection()) { + RenderTableSection *section = static_cast<RenderTableSection *>(child); + if (!foot) + foot = section; + else if (!firstBody) + firstBody = section; + if (section->needCellRecalc) + section->recalcCells(); + } + break; + case TABLE_ROW_GROUP: + if (child->isTableSection()) { + RenderTableSection *section = static_cast<RenderTableSection *>(child); + if (!firstBody) + firstBody = section; + if (section->needCellRecalc) + section->recalcCells(); + } + break; + default: + break; + } + child = child->nextSibling(); + } + needSectionRecalc = false; + setNeedsLayout(true); +} + +RenderObject* RenderTable::removeChildNode(RenderObject* child) +{ + setNeedSectionRecalc(); + return RenderContainer::removeChildNode( child ); +} + +int RenderTable::borderLeft() const +{ + if (collapseBorders()) { + // FIXME: For strict mode, returning 0 is correct, since the table border half spills into the margin, + // but I'm working to get this changed. For now, follow the spec. + return 0; + } + return RenderBlock::borderLeft(); +} + +int RenderTable::borderRight() const +{ + if (collapseBorders()) { + // FIXME: For strict mode, returning 0 is correct, since the table border half spills into the margin, + // but I'm working to get this changed. For now, follow the spec. + return 0; + } + return RenderBlock::borderRight(); +} + +int RenderTable::borderTop() const +{ + if (collapseBorders()) { + // FIXME: For strict mode, returning 0 is correct, since the table border half spills into the margin, + // but I'm working to get this changed. For now, follow the spec. + return 0; + } + return RenderBlock::borderTop(); +} + +int RenderTable::borderBottom() const +{ + if (collapseBorders()) { + // FIXME: For strict mode, returning 0 is correct, since the table border half spills into the margin, + // but I'm working to get this changed. For now, follow the spec. + return 0; + } + return RenderBlock::borderBottom(); +} + +RenderTableSection* RenderTable::sectionAbove(const RenderTableSection* section, bool skipEmptySections) const +{ + if (section == head) + return 0; + RenderObject *prevSection = (section == foot ? lastChild() : const_cast<RenderTableSection *>(section))->previousSibling(); + while (prevSection) { + if (prevSection->isTableSection() && prevSection != head && prevSection != foot && (!skipEmptySections || static_cast<RenderTableSection*>(prevSection)->numRows())) + break; + prevSection = prevSection->previousSibling(); + } + if (!prevSection && head && (!skipEmptySections || head->numRows())) + prevSection = head; + return static_cast<RenderTableSection*>(prevSection); +} + +RenderTableSection* RenderTable::sectionBelow(const RenderTableSection* section, bool skipEmptySections) const +{ + if (section == foot) + return 0; + RenderObject *nextSection = (section == head ? firstChild() : const_cast<RenderTableSection *>(section))->nextSibling(); + while (nextSection) { + if (nextSection->isTableSection() && nextSection != head && nextSection != foot && (!skipEmptySections || static_cast<RenderTableSection*>(nextSection)->numRows())) + break; + nextSection = nextSection->nextSibling(); + } + if (!nextSection && foot && (!skipEmptySections || foot->numRows())) + nextSection = foot; + return static_cast<RenderTableSection*>(nextSection); +} + +RenderTableCell* RenderTable::cellAbove(const RenderTableCell* cell) const +{ + // Find the section and row to look in + int r = cell->row(); + RenderTableSection* section = 0; + int rAbove = 0; + if (r > 0) { + // cell is not in the first row, so use the above row in its own section + section = cell->section(); + rAbove = r-1; + } else { + section = sectionAbove(cell->section(), true); + if (section) + rAbove = section->numRows() - 1; + } + + // Look up the cell in the section's grid, which requires effective col index + if (section) { + int effCol = colToEffCol(cell->col()); + RenderTableCell* aboveCell; + // If we hit a span back up to a real cell. + do { + aboveCell = section->cellAt(rAbove, effCol); + effCol--; + } while (aboveCell == (RenderTableCell *)-1 && effCol >=0); + return (aboveCell == (RenderTableCell *)-1) ? 0 : aboveCell; + } else { + return 0; + } +} + +RenderTableCell* RenderTable::cellBelow(const RenderTableCell* cell) const +{ + // Find the section and row to look in + int r = cell->row() + cell->rowSpan() - 1; + RenderTableSection* section = 0; + int rBelow = 0; + if (r < cell->section()->numRows()-1) { + // The cell is not in the last row, so use the next row in the section. + section = cell->section(); + rBelow= r+1; + } else { + section = sectionBelow(cell->section(), true); + if (section) + rBelow = 0; + } + + // Look up the cell in the section's grid, which requires effective col index + if (section) { + int effCol = colToEffCol(cell->col()); + RenderTableCell* belowCell; + // If we hit a colspan back up to a real cell. + do { + belowCell = section->cellAt(rBelow, effCol); + effCol--; + } while (belowCell == (RenderTableCell *)-1 && effCol >=0); + return (belowCell == (RenderTableCell *)-1) ? 0 : belowCell; + } else { + return 0; + } +} + +RenderTableCell* RenderTable::cellLeft(const RenderTableCell* cell) const +{ + RenderTableSection* section = cell->section(); + int effCol = colToEffCol(cell->col()); + if (effCol == 0) + return 0; + + // If we hit a colspan back up to a real cell. + RenderTableCell* prevCell; + do { + prevCell = section->cellAt(cell->row(), effCol-1); + effCol--; + } while (prevCell == (RenderTableCell *)-1 && effCol >=0); + return (prevCell == (RenderTableCell *)-1) ? 0 : prevCell; +} + +RenderTableCell* RenderTable::cellRight(const RenderTableCell* cell) const +{ + int effCol = colToEffCol(cell->col()+cell->colSpan()); + if (effCol >= numEffCols()) + return 0; + RenderTableCell* result = cell->section()->cellAt(cell->row(), effCol); + return (result == (RenderTableCell*)-1) ? 0 : result; +} + +#ifdef ENABLE_DUMP +void RenderTable::dump(TQTextStream &stream, const TQString &ind) const +{ + RenderBlock::dump(stream, ind); + + if (tCaption) + stream << " tCaption"; + if (head) + stream << " head"; + if (foot) + stream << " foot"; + + stream << " [cspans:"; + for ( unsigned int i = 0; i < columns.size(); i++ ) + stream << " " << columns[i].span; + stream << "]"; +} + +#endif + +FindSelectionResult RenderTable::checkSelectionPoint( int _x, int _y, int _tx, int _ty, DOM::NodeImpl*& node, int & offset, SelPointState &state ) +{ + int off = offset; + DOM::NodeImpl* nod = node; + + FindSelectionResult pos; + TableSectionIterator it(this); + for (; *it; ++it) { + pos = (*it)->checkSelectionPoint(_x, _y, _tx + m_x, _ty + m_y, nod, off, state); + switch(pos) { + case SelectionPointBeforeInLine: + case SelectionPointInside: + //kdDebug(6030) << "RenderTable::checkSelectionPoint " << this << " returning SelectionPointInside offset=" << offset << endl; + node = nod; + offset = off; + return SelectionPointInside; + case SelectionPointBefore: + //x,y is before this element -> stop here + if ( state.m_lastNode ) { + node = state.m_lastNode; + offset = state.m_lastOffset; + //kdDebug(6030) << "RenderTable::checkSelectionPoint " << this << " before this child " + // << node << "-> returning SelectionPointInside, offset=" << offset << endl; + return SelectionPointInside; + } else { + node = nod; + offset = off; + //kdDebug(6030) << "RenderTable::checkSelectionPoint " << this << " before us -> returning SelectionPointBefore " << node << "/" << offset << endl; + return SelectionPointBefore; + } + break; + case SelectionPointAfter: + if (state.m_afterInLine) break; + // fall through + case SelectionPointAfterInLine: + if (pos == SelectionPointAfterInLine) state.m_afterInLine = true; + //kdDebug(6030) << "RenderTable::checkSelectionPoint: selection after: " << nod << " offset: " << off << " afterInLine: " << state.m_afterInLine << endl; + state.m_lastNode = nod; + state.m_lastOffset = off; + // No "return" here, obviously. We must keep looking into the children. + break; + } + } + // If we are after the last child, return lastNode/lastOffset + // But lastNode can be 0L if there is no child, for instance. + if ( state.m_lastNode ) + { + node = state.m_lastNode; + offset = state.m_lastOffset; + } + // Fallback + return SelectionPointAfter; +} + +// -------------------------------------------------------------------------- + +RenderTableSection::RenderTableSection(DOM::NodeImpl* node) + : RenderBox(node) +{ + // init RenderObject attributes + setInline(false); // our object is not Inline + cCol = 0; + cRow = -1; + needCellRecalc = false; +} + +RenderTableSection::~RenderTableSection() +{ + clearGrid(); +} + +void RenderTableSection::detach() +{ + // recalc cell info because RenderTable has unguarded pointers + // stored that point to this RenderTableSection. + if (table()) + table()->setNeedSectionRecalc(); + + RenderBox::detach(); +} + +void RenderTableSection::setStyle(RenderStyle* _style) +{ + // we don't allow changing this one + if (style()) + _style->setDisplay(style()->display()); + else if (_style->display() != TABLE_FOOTER_GROUP && _style->display() != TABLE_HEADER_GROUP) + _style->setDisplay(TABLE_ROW_GROUP); + + RenderBox::setStyle(_style); +} + +void RenderTableSection::addChild(RenderObject *child, RenderObject *beforeChild) +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(TableSection)::addChild( " << child->renderName() << ", beforeChild=" << + (beforeChild ? beforeChild->renderName() : "0") << " )" << endl; +#endif + if ( !child->isTableRow() ) { + // TBODY > FORM quirk (???) + if (child->element() && child->element()->isHTMLElement() && child->element()->id() == ID_FORM && + static_cast<HTMLFormElementImpl*>(child->element())->isMalformed()) + { + RenderContainer::addChild(child, beforeChild); + return; + } + + RenderObject* last = beforeChild; + if (!last) + last = lastChild(); + if (last && last->isAnonymous()) { + last->addChild(child); + return; + } + + // If beforeChild is inside an anonymous cell/row, insert into the cell or into + // the anonymous row containing it, if there is one. + RenderObject* lastBox = last; + while (lastBox && lastBox->parent()->isAnonymous() && !lastBox->isTableRow()) + lastBox = lastBox->parent(); + if (lastBox && lastBox->isAnonymous()) { + lastBox->addChild(child, beforeChild); + return; + } + + RenderObject* row = new (renderArena()) RenderTableRow(document() /* anonymous table */); + RenderStyle* newStyle = new RenderStyle(); + newStyle->inheritFrom(style()); + newStyle->setDisplay(TABLE_ROW); + row->setStyle(newStyle); + addChild(row, beforeChild); + row->addChild(child); + return; + } + + if (beforeChild) + setNeedCellRecalc(); + + cRow++; + cCol = 0; + + ensureRows( cRow+1 ); + KHTMLAssert( child->isTableRow() ); + grid[cRow].rowRenderer = static_cast<RenderTableRow*>(child); + + if (!beforeChild) { + grid[cRow].height = child->style()->height(); + if ( grid[cRow].height.isRelative() ) + grid[cRow].height = Length(); + } + + + RenderContainer::addChild(child,beforeChild); +} + +void RenderTableSection::ensureRows( int numRows ) +{ + int nRows = grid.size(); + int nCols = table()->numEffCols(); + if ( numRows > nRows ) { + grid.resize( numRows ); + for ( int r = nRows; r < numRows; r++ ) { + grid[r].row = new Row( nCols ); + grid[r].row->fill( 0 ); + grid[r].rowRenderer = 0; + grid[r].baseLine = 0; + grid[r].height = Length(); + } + } + +} + +void RenderTableSection::addCell( RenderTableCell *cell, RenderTableRow *row ) +{ + int rSpan = cell->rowSpan(); + int cSpan = cell->colSpan(); + TQMemArray<RenderTable::ColumnStruct> &columns = table()->columns; + int nCols = columns.size(); + + // ### mozilla still seems to do the old HTML way, even for strict DTD + // (see the annotation on table cell layouting in the CSS specs and the testcase below: + // <TABLE border> + // <TR><TD>1 <TD rowspan="2">2 <TD>3 <TD>4 + // <TR><TD colspan="2">5 + // </TABLE> + while ( cCol < nCols && cellAt( cRow, cCol ) ) + cCol++; + +// tqDebug("adding cell at %d/%d span=(%d/%d)", cRow, cCol, rSpan, cSpan ); + + if ( rSpan == 1 ) { + // we ignore height settings on rowspan cells + Length height = cell->style()->height(); + if ( height.value() > 0 || (height.isRelative() && height.value() >= 0) ) { + Length cRowHeight = grid[cRow].height; + switch( height.type() ) { + case Percent: + if ( !cRowHeight.isPercent() || + (cRowHeight.isPercent() && cRowHeight.value() < height.value() ) ) + grid[cRow].height = height; + break; + case Fixed: + if ( cRowHeight.type() < Percent || + ( cRowHeight.isFixed() && cRowHeight.value() < height.value() ) ) + grid[cRow].height = height; + break; + case Relative: +#if 0 + // we treat this as variable. This is correct according to HTML4, as it only specifies length for the height. + if ( cRowHeight.type == Variable || + ( cRowHeight.type == Relative && cRowHeight.value < height.value ) ) + grid[cRow].height = height; + break; +#endif + default: + break; + } + } + } + + // make sure we have enough rows + ensureRows( cRow + rSpan ); + + grid[cRow].rowRenderer = row; + + int col = cCol; + // tell the cell where it is + RenderTableCell *set = cell; + while ( cSpan ) { + int currentSpan; + if ( cCol >= nCols ) { + table()->appendColumn( cSpan ); + currentSpan = cSpan; + } else { + if ( cSpan < columns[cCol].span ) + table()->splitColumn( cCol, cSpan ); + currentSpan = columns[cCol].span; + } + int r = 0; + while ( r < rSpan ) { + if ( !cellAt( cRow + r, cCol ) ) { +// tqDebug(" adding cell at %d, %d", cRow + r, cCol ); + cellAt( cRow + r, cCol ) = set; + } + r++; + } + cCol++; + cSpan -= currentSpan; + set = (RenderTableCell *)-1; + } + if ( cell ) { + cell->setRow( cRow ); + cell->setCol( table()->effColToCol( col ) ); + } +} + + + +void RenderTableSection::setCellWidths() +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(Table, this=0x" << this << ")::setCellWidths()" << endl; +#endif + TQMemArray<int> &columnPos = table()->columnPos; + + int rows = grid.size(); + for ( int i = 0; i < rows; i++ ) { + Row &row = *grid[i].row; + int cols = row.size(); + for ( int j = 0; j < cols; j++ ) { + RenderTableCell *cell = row[j]; +// tqDebug("cell[%d,%d] = %p", i, j, cell ); + if ( !cell || cell == (RenderTableCell *)-1 ) + continue; + int endCol = j; + int cspan = cell->colSpan(); + while ( cspan && endCol < cols ) { + cspan -= table()->columns[endCol].span; + endCol++; + } + int w = columnPos[endCol] - columnPos[j] - table()->borderHSpacing(); +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << "setting width of cell " << cell << " " << cell->row() << "/" << cell->col() << " to " << w << " colspan=" << cell->colSpan() << " start=" << j << " end=" << endCol << endl; +#endif + int oldWidth = cell->width(); + if ( w != oldWidth ) { + cell->setNeedsLayout(true); + cell->setWidth( w ); + } + } + } +} + +short RenderTableSection::width() const +{ + return table()->width(); +} + + +void RenderTableSection::calcRowHeight() +{ + int indx; + RenderTableCell *cell; + + int totalRows = grid.size(); + int vspacing = table()->borderVSpacing(); + + rowPos.resize( totalRows + 1 ); + rowPos[0] = vspacing + borderTop(); + + for ( int r = 0; r < totalRows; r++ ) { + rowPos[r+1] = 0; + + int baseline=0; + int bdesc = 0; +// tqDebug("height of row %d is %d/%d", r, grid[r].height.value, grid[r].height.type ); + int ch = grid[r].height.minWidth( 0 ); + int pos = rowPos[r] + ch + (grid[r].rowRenderer ? vspacing : 0); + + if ( pos > rowPos[r+1] ) + rowPos[r+1] = pos; + + Row *row = grid[r].row; + int totalCols = row->size(); + int totalRows = grid.size(); + bool pagedMode = canvas()->pagedMode(); + + grid[r].needFlex = false; + + for ( int c = 0; c < totalCols; c++ ) { + cell = cellAt(r, c); + if ( !cell || cell == (RenderTableCell *)-1 ) + continue; + if ( r < totalRows - 1 && cellAt(r+1, c) == cell ) + continue; + + if ( ( indx = r - cell->rowSpan() + 1 ) < 0 ) + indx = 0; + + if (cell->cellPercentageHeight() != -1) { + cell->setCellPercentageHeight(-1); + cell->setChildNeedsLayout(true, false); + if (cell->hasFlexedAnonymous()) { + for (RenderObject* o = cell->firstChild(); o ; o = o->nextSibling()) + if (o->isAnonymousBlock()) + o->setChildNeedsLayout(true, false); + } + if (pagedMode) cell->setNeedsLayout(true); + cell->layoutIfNeeded(); + } + + ch = cell->style()->height().width(0); + if ( cell->height() > ch) + ch = cell->height(); + + if (!cell->style()->height().isVariable()) + grid[r].needFlex = true; + + pos = rowPos[indx] + ch + (grid[r].rowRenderer ? vspacing : 0); + + if ( pos > rowPos[r+1] ) + rowPos[r+1] = pos; + + // find out the baseline + EVerticalAlign va = cell->style()->verticalAlign(); + if (va == BASELINE || va == TEXT_BOTTOM || va == TEXT_TOP + || va == SUPER || va == SUB) + { + int b=cell->baselinePosition(); + if (b > cell->borderTop() + cell->paddingTop()) { + if (b>baseline) + baseline=b; + + int td = rowPos[ indx ] + ch - b; + if (td>bdesc) + bdesc = td; + } + } + } + + //do we have baseline aligned elements? + if (baseline) { + // increase rowheight if baseline requires + int bRowPos = baseline + bdesc + (grid[r].rowRenderer ? vspacing : 0); + if (rowPos[r+1]<bRowPos) + rowPos[r+1]=bRowPos; + + grid[r].baseLine = baseline; + } + + if ( rowPos[r+1] < rowPos[r] ) + rowPos[r+1] = rowPos[r]; +// tqDebug("rowpos(%d)=%d", r, rowPos[r] ); + } +} + +int RenderTableSection::layoutRows( int toAdd ) +{ + int rHeight; + int rindx; + int totalRows = grid.size(); + int hspacing = table()->borderHSpacing(); + int vspacing = table()->borderVSpacing(); + + // Set the width of our section now. The rows will also be this width. + m_width = table()->contentWidth(); + + if (markedForRepaint()) { + repaintDuringLayout(); + setMarkedForRepaint(false); + } + + if (toAdd && totalRows && (rowPos[totalRows] || !nextSibling())) { + + int totalHeight = rowPos[totalRows] + toAdd; +// tqDebug("layoutRows: totalHeight = %d", totalHeight ); + + int dh = toAdd; + int totalPercent = 0; + int numVariable = 0; + for ( int r = 0; r < totalRows; r++ ) { + if ( grid[r].height.isVariable() && !emptyRow(r)) + numVariable++; + else if ( grid[r].height.isPercent() ) + totalPercent += grid[r].height.value(); + } + if ( totalPercent ) { +// tqDebug("distributing %d over percent rows totalPercent=%d", dh, totalPercent ); + // try to satisfy percent + int add = 0; + if ( totalPercent > 100 ) + totalPercent = 100; + int rh = rowPos[1]-rowPos[0]; + for ( int r = 0; r < totalRows; r++ ) { + if ( totalPercent > 0 && grid[r].height.isPercent() ) { + int toAdd = kMin( dh, (totalHeight * grid[r].height.value() / 100)-rh ); + // If toAdd is negative, then we don't want to shrink the row (this bug + // affected Outlook Web Access). + toAdd = kMax(0, toAdd); + add += toAdd; + dh -= toAdd; + totalPercent -= grid[r].height.value(); +// tqDebug( "adding %d to row %d", toAdd, r ); + } + if ( r < totalRows-1 ) + rh = rowPos[r+2] - rowPos[r+1]; + rowPos[r+1] += add; + } + } + if ( numVariable ) { + // distribute over non-empty variable rows +// tqDebug("distributing %d over variable rows numVariable=%d", dh, numVariable ); + int add = 0; + int toAdd = dh/numVariable; + for ( int r = 0; r < totalRows; r++ ) { + if ( grid[r].height.isVariable() && !emptyRow(r)) { + add += toAdd; + } + rowPos[r+1] += add; + } + dh -= add; + } + if (dh>0 && rowPos[totalRows]) { + // if some left overs, distribute weighted. + int tot=rowPos[totalRows]; + int add=0; + int prev=rowPos[0]; + for ( int r = 0; r < totalRows; r++ ) { + //weight with the original height + add+=dh*(rowPos[r+1]-prev)/tot; + prev=rowPos[r+1]; + rowPos[r+1]+=add; + } + dh -= add; + } + if (dh > totalRows) { + // distribute to tables with all empty rows + int add=0; + int toAdd = dh/totalRows; + for ( int r = 0; r < totalRows; r++ ) { + add += toAdd; + rowPos[r+1] += add; + } + dh -= add; + } + // Finally distribute round-off values + if (dh > 0) { + // There is not enough for every row + int add=0; + for ( int r = 0; r < totalRows; r++ ) { + if (add < dh) add++; + rowPos[r+1] += add; + } + dh -= add; + } + assert (dh == 0); + } + + int leftOffset = borderLeft() + hspacing; + + int nEffCols = table()->numEffCols(); + for ( int r = 0; r < totalRows; r++ ) + { + Row *row = grid[r].row; + int totalCols = row->size(); + +#ifdef APPLE_CHANGES + // in WC, rows and cells share the same coordinate space, so that rows can have + // dimensions in the layer system. This is of dubious value, and a heavy maintenance burden + // (RenderObject's coordinates can't be used deterministically anymore) so we'll consider other options. + + // Set the row's x/y position and width/height. + if (grid[r].rowRenderer) { + grid[r].rowRenderer->setPos(0, rowPos[r]); + grid[r].rowRenderer->setWidth(m_width); + grid[r].rowRenderer->setHeight(rowPos[r+1] - rowPos[r] - vspacing); + } +#endif + + for ( int c = 0; c < nEffCols; c++ ) + { + RenderTableCell *cell = cellAt(r, c); + if (!cell || cell == (RenderTableCell *)-1 ) + continue; + if ( r < totalRows - 1 && cell == cellAt(r+1, c) ) + continue; + + if ( ( rindx = r-cell->rowSpan()+1 ) < 0 ) + rindx = 0; + + rHeight = rowPos[r+1] - rowPos[rindx] - vspacing; + + // Force percent height children to lay themselves out again. + // This will cause, e.g., textareas to grow to + // fill the area. FIXME: <div>s and blocks still don't + // work right. We'll need to have an efficient way of + // invalidating all percent height objects in a render subtree. + // For now, we just handle immediate children. -dwh + + bool flexAllChildren = grid[r].needFlex || (!table()->style()->height().isVariable() && rHeight != cell->height()); + cell->setHasFlexedAnonymous(false); + if ( flexAllChildren && flexCellChildren(cell) ) { + cell->setCellPercentageHeight(kMax(0, + rHeight - cell->borderTop() - cell->paddingTop() - + cell->borderBottom() - cell->paddingBottom())); + cell->layoutIfNeeded(); + + } + { +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << "setting position " << r << "/" << c << ": " + << table()->columnPos[c] /*+ padding */ << "/" << rowPos[rindx] << " height=" << rHeight<< endl; +#endif + + EVerticalAlign va = cell->style()->verticalAlign(); + int te=0; + switch (va) + { + case SUB: + case SUPER: + case TEXT_TOP: + case TEXT_BOTTOM: + case BASELINE: + te = getBaseline(r) - cell->baselinePosition() ; + break; + case TOP: + te = 0; + break; + case MIDDLE: + te = (rHeight - cell->height())/2; + break; + case BOTTOM: + te = rHeight - cell->height(); + break; + default: + break; + } + te = kMax( 0, te ); +#ifdef DEBUG_LAYOUT + // kdDebug( 6040 ) << "CELL " << cell << " te=" << te << ", be=" << rHeight - cell->height() - te << ", rHeight=" << rHeight << ", valign=" << va << endl; +#endif + cell->setCellTopExtra( te ); + cell->setCellBottomExtra( rHeight - cell->height() - te); + } + if (style()->direction()==RTL) { + cell->setPos( + table()->columnPos[(int)totalCols] - + table()->columnPos[table()->colToEffCol(cell->col()+cell->colSpan())] + + leftOffset, + rowPos[rindx] ); + } else { + cell->setPos( table()->columnPos[c] + leftOffset, rowPos[rindx] ); + } + } + } + + m_height = rowPos[totalRows]; + return m_height; +} + +bool RenderTableSection::flexCellChildren(RenderObject* p) const +{ + if (!p) + return false; + RenderObject* o = p->firstChild(); + bool didFlex = false; + while (o) { + if (!o->isText() && o->style()->height().isPercent()) { + if (o->isWidget()) { + // cancel resizes from transitory relayouts + static_cast<RenderWidget *>(o)->cancelPendingResize(); + } + o->setNeedsLayout(true, false); + p->setChildNeedsLayout(true, false); + didFlex = true; + } else if (o->isAnonymousBlock() && flexCellChildren( o )) { + p->setChildNeedsLayout(true, false); + if (p->isTableCell()) + static_cast<RenderTableCell*>(p)->setHasFlexedAnonymous(); + didFlex = true; + } + o = o->nextSibling(); + } + return didFlex; +} + +inline static RenderTableRow *firstTableRow(RenderObject *row) +{ + while (row && !row->isTableRow()) + row = row->nextSibling(); + return static_cast<RenderTableRow *>(row); +} + +inline static RenderTableRow *nextTableRow(RenderObject *row) +{ + row = row ? row->nextSibling() : row; + while (row && !row->isTableRow()) + row = row->nextSibling(); + return static_cast<RenderTableRow *>(row); +} + +int RenderTableSection::lowestPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int bottom = RenderBox::lowestPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return bottom; + + for (RenderObject *row = firstChild(); row; row = row->nextSibling()) { + for (RenderObject *cell = row->firstChild(); cell; cell = cell->nextSibling()) + if (cell->isTableCell()) { + int bp = cell->yPos() + cell->lowestPosition(false); + bottom = kMax(bottom, bp); + } + } + + return bottom; +} + +int RenderTableSection::rightmostPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int right = RenderBox::rightmostPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return right; + + for (RenderObject *row = firstChild(); row; row = row->nextSibling()) { + for (RenderObject *cell = row->firstChild(); cell; cell = cell->nextSibling()) + if (cell->isTableCell()) { + int rp = cell->xPos() + cell->rightmostPosition(false); + right = kMax(right, rp); + } + } + + return right; +} + +int RenderTableSection::leftmostPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int left = RenderBox::leftmostPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return left; + + for (RenderObject *row = firstChild(); row; row = row->nextSibling()) { + for (RenderObject *cell = row->firstChild(); cell; cell = cell->nextSibling()) + if (cell->isTableCell()) { + int lp = cell->xPos() + cell->leftmostPosition(false); + left = kMin(left, lp); + } + } + + return left; +} + +int RenderTableSection::highestPosition(bool includeOverflowInterior, bool includeSelf) const +{ + int top = RenderBox::highestPosition(includeOverflowInterior, includeSelf); + if (!includeOverflowInterior && hasOverflowClip()) + return top; + + for (RenderObject *row = firstChild(); row; row = row->nextSibling()) { + for (RenderObject *cell = row->firstChild(); cell; cell = cell->nextSibling()) + if (cell->isTableCell()) { + int hp = cell->yPos() + cell->highestPosition(false); + top = kMin(top, hp); + } + } + + return top; +} + +// Search from first_row to last_row for the row containing y +static unsigned int findRow(unsigned int first_row, unsigned int last_row, + const TQMemArray<int> &rowPos, int y) +{ + unsigned int under = first_row; + unsigned int over = last_row; + int offset = (over - under)/2; + while (over-under > 1) { + if (rowPos[under+offset] <= y) + under = under+offset; + else + over = under+offset; + offset = (over - under)/2; + } + + assert(under == first_row || rowPos[under] <= y); + assert(over == last_row || rowPos[over] > y); + + return under; +} + +static void findRowCover(unsigned int &startrow, unsigned int &endrow, + const TQMemArray<int> &rowPos, + int min_y, int max_y) +{ + assert(max_y >= min_y); + unsigned int totalRows = endrow; + + unsigned int index = 0; + // Initial binary search boost: + if (totalRows >= 8) { + int offset = (endrow - startrow)/2; + while (endrow - startrow > 1) { + index = startrow+offset; + if (rowPos[index] <= min_y ) + // index is below both min_y and max_y + startrow = index; + else + if (rowPos[index] > max_y) + // index is above both min_y and max_y + endrow = index; + else + // index is within the selection + break; + offset = (endrow - startrow)/2; + } + } + + // Binary search for startrow + startrow = findRow(startrow, endrow, rowPos, min_y); + // Binary search for endrow + endrow = findRow(startrow, endrow, rowPos, max_y) + 1; + if (endrow > totalRows) endrow = totalRows; +} + +void RenderTableSection::paint( PaintInfo& pI, int tx, int ty ) +{ + unsigned int totalRows = grid.size(); + unsigned int totalCols = table()->columns.size(); + + tx += m_x; + ty += m_y; + + if (pI.phase == PaintActionOutline) + paintOutline(pI.p, tx, ty, width(), height(), style()); + + CollapsedBorderValue *cbs = table()->currentBorderStyle(); + int cbsw2 = cbs ? cbs->width()/2 : 0; + int cbsw21 = cbs ? (cbs->width()+1)/2 : 0; + + int x = pI.r.x(), y = pI.r.y(), w = pI.r.width(), h = pI.r.height(); + // check which rows and cols are visible and only paint these + int os = 2*maximalOutlineSize(pI.phase); + unsigned int startrow = 0; + unsigned int endrow = totalRows; + findRowCover(startrow, endrow, rowPos, y - os - ty - kMax(cbsw21, os), y + h + os - ty + kMax(cbsw2, os)); + + // A binary search is probably not worthwhile for coloumns + unsigned int startcol = 0; + unsigned int endcol = totalCols; + if ( style()->direction() == LTR ) { + for ( ; startcol < totalCols; startcol++ ) { + if ( tx + table()->columnPos[startcol+1] + kMax(cbsw21, os) > x - os ) + break; + } + for ( ; endcol > 0; endcol-- ) { + if ( tx + table()->columnPos[endcol-1] - kMax(cbsw2, os) < x + w + os ) + break; + } + } + if ( startcol < endcol ) { + // draw the cells + for ( unsigned int r = startrow; r < endrow; r++ ) { + // paint the row + if (grid[r].rowRenderer) { + int height = rowPos[r+1] - rowPos[r] - table()->borderVSpacing(); + grid[r].rowRenderer->paintRow(pI, tx, ty + rowPos[r], width(), height); + } + + unsigned int c = startcol; + Row *row = grid[r].row; + Row *nextrow = (r < endrow - 1) ? grid[r+1].row : 0; + // since a cell can be -1 (indicating a colspan) we might have to search backwards to include it + while ( c && (*row)[c] == (RenderTableCell *)-1 ) + c--; + for ( ; c < endcol; c++ ) { + RenderTableCell *cell = (*row)[c]; + if ( !cell || cell == (RenderTableCell *)-1 || nextrow && (*nextrow)[c] == cell ) + continue; +#ifdef TABLE_PRINT + kdDebug( 6040 ) << "painting cell " << r << "/" << c << endl; +#endif + if (pI.phase == PaintActionElementBackground || pI.phase == PaintActionChildBackground) { + // We need to handle painting a stack of backgrounds. This stack (from bottom to top) consists of + // the column group, column, row group, row, and then the cell. + RenderObject* col = table()->colElement(c); + RenderObject* colGroup = 0; + if (col) { + RenderStyle *style = col->parent()->style(); + if (style->display() == TABLE_COLUMN_GROUP) + colGroup = col->parent(); + } + RenderObject* row = cell->parent(); + + // ### + // Column groups and columns first. + // FIXME: Columns and column groups do not currently support opacity, and they are being painted "too late" in + // the stack, since we have already opened a transparency layer (potentially) for the table row group. + // Note that we deliberately ignore whether or not the cell has a layer, since these backgrounds paint "behind" the + // cell. + cell->paintBackgroundsBehindCell(pI, tx, ty, colGroup); + cell->paintBackgroundsBehindCell(pI, tx, ty, col); + + // Paint the row group next. + cell->paintBackgroundsBehindCell(pI, tx, ty, this); + + // Paint the row next, but only if it doesn't have a layer. If a row has a layer, it will be responsible for + // painting the row background for the cell. + if (!row->layer()) + cell->paintBackgroundsBehindCell(pI, tx, ty, row); + } + + if ((!cell->layer() && !cell->parent()->layer()) || pI.phase == PaintActionCollapsedTableBorders) + cell->paint(pI, tx, ty); + } + } + } +} + +void RenderTableSection::recalcCells() +{ + cCol = 0; + cRow = -1; + clearGrid(); + grid.resize( 0 ); + + for (RenderObject *row = firstChild(); row; row = row->nextSibling()) { + if (row->isTableRow()) { + cRow++; + cCol = 0; + ensureRows( cRow+1 ); + grid[cRow].rowRenderer = static_cast<RenderTableRow*>(row); + + for (RenderObject *cell = row->firstChild(); cell; cell = cell->nextSibling()) + if (cell->isTableCell()) + addCell( static_cast<RenderTableCell *>(cell), static_cast<RenderTableRow *>(row) ); + } + } + needCellRecalc = false; + setNeedsLayout(true); +} + +void RenderTableSection::clearGrid() +{ + int rows = grid.size(); + while ( rows-- ) { + delete grid[rows].row; + } +} + +bool RenderTableSection::emptyRow(int rowNum) { + Row &r = *grid[rowNum].row; + const int s = r.size(); + RenderTableCell *cell; + for(int i=0; i<s; i++) { + cell = r[i]; + if (!cell || cell==(RenderTableCell*)-1) + continue; + return false; + } + return true; +} + +RenderObject* RenderTableSection::removeChildNode(RenderObject* child) +{ + setNeedCellRecalc(); + return RenderContainer::removeChildNode( child ); +} + +bool RenderTableSection::canClear(RenderObject */*child*/, PageBreakLevel level) +{ + // We cannot clear rows yet. + return parent()->canClear(this, level); +} + +void RenderTableSection::addSpaceAt(int pos, int dy) +{ + const int nEffCols = table()->numEffCols(); + const int totalRows = numRows(); + for ( int r = 0; r < totalRows; r++ ) { + if (rowPos[r] >= pos) { + rowPos[r] += dy; + int rindx; + for ( int c = 0; c < nEffCols; c++ ) + { + RenderTableCell *cell = cellAt(r, c); + if (!cell || cell == (RenderTableCell *)-1 ) + continue; + if ( r > 0 && cell == cellAt(r-1, c) ) + continue; + + if ( ( rindx = r-cell->rowSpan()+1 ) < 0 ) + rindx = 0; + + cell->setPos(cell->xPos(), rowPos[r]); + } + } + } + if (rowPos[totalRows] >= pos) + rowPos[totalRows] += dy; + m_height = rowPos[totalRows]; + + setContainsPageBreak(true); +} + + +#ifdef ENABLE_DUMP +void RenderTableSection::dump(TQTextStream &stream, const TQString &ind) const +{ + RenderContainer::dump(stream,ind); + + stream << " grid=(" << grid.size() << "," << table()->numEffCols() << ")"; + for ( unsigned int r = 0; r < grid.size(); r++ ) { + for ( int c = 0; c < table()->numEffCols(); c++ ) { + if ( cellAt( r, c ) && cellAt( r, c ) != (RenderTableCell *)-1 ) + stream << " (" << cellAt( r, c )->row() << "," << cellAt( r, c )->col() << "," + << cellAt(r, c)->rowSpan() << "," << cellAt(r, c)->colSpan() << ") "; + else + stream << " null cell"; + } + } +} +#endif + +static RenderTableCell *seekCell(RenderTableSection *section, int row, int col) +{ + if (row < 0 || col < 0 || row >= section->numRows()) return 0; + // since a cell can be -1 (indicating a colspan) we might have to search backwards to include it + while ( col && section->cellAt( row, col ) == (RenderTableCell *)-1 ) + col--; + + return section->cellAt(row, col); +} + +/** Looks for the first element suitable for text selection, beginning from + * the last. + * @param base search is restricted within this node. This node must have + * a renderer. + * @return the element or @p base if no suitable element found. + */ +static NodeImpl *findLastSelectableNode(NodeImpl *base) +{ + NodeImpl *last = base; + // Look for last text/cdata node that has a renderer, + // or last childless replaced element + while ( last && !(last->renderer() + && ((last->nodeType() == Node::TEXT_NODE || last->nodeType() == Node::CDATA_SECTION_NODE) + || (last->renderer()->isReplaced() && !last->renderer()->lastChild())))) + { + NodeImpl *next = last->lastChild(); + if ( !next ) next = last->previousSibling(); + while ( last && last != base && !next ) + { + last = last->parentNode(); + if ( last && last != base ) + next = last->previousSibling(); + } + last = next; + } + + return last ? last : base; +} + +FindSelectionResult RenderTableSection::checkSelectionPoint( int _x, int _y, int _tx, int _ty, DOM::NodeImpl*& node, int & offset, SelPointState &state ) +{ + // Table sections need extra treatment for selections. The rows are scanned + // from top to bottom, and within each row, only the cell that matches + // the given position best is descended into. + + unsigned int totalRows = grid.size(); + unsigned int totalCols = table()->columns.size(); + +// absolutePosition(_tx, _ty, false); + + _tx += m_x; + _ty += m_y; + +// bool save_last = false; // true to save last investigated cell + + if (needsLayout() || _y < _ty) return SelectionPointBefore; +// else if (_y >= _ty + height()) save_last = true; + + // Find the row containing the pointer + int row_idx = findRow(0, totalRows, rowPos, _y - _ty); + + int col_idx; + if ( style()->direction() == LTR ) { + for ( col_idx = (int)totalCols - 1; col_idx >= 0; col_idx-- ) { + if ( _tx + table()->columnPos[col_idx] < _x ) + break; + } + if (col_idx < 0) col_idx = 0; + } else { + for ( col_idx = 0; col_idx < (int)totalCols; col_idx++ ) { + if ( _tx + table()->columnPos[col_idx] > _x ) + break; + } + if (col_idx >= (int)totalCols) col_idx = (int)totalCols + 1; + } + + FindSelectionResult pos = SelectionPointBefore; + + RenderTableCell *cell = seekCell(this, row_idx, col_idx); + // ### dunno why cell can be 0, maybe due to weird spans? (LS) + if (cell) { + SelPointState localState; + pos = cell->checkSelectionPoint(_x, _y, _tx, _ty, node, offset, localState); + } + + if (pos != SelectionPointBefore) return pos; + + // store last column of last line + row_idx--; + col_idx = totalCols - 1; + cell = seekCell(this, row_idx, col_idx); + + // end of section? take previous section + RenderTableSection *sec = this; + if (!cell) { + sec = *--TableSectionIterator(sec); + if (!sec) return pos; + + cell = seekCell(sec, sec->grid.size() - 1, col_idx); + if (!cell) return pos; + } + + // take last child of previous cell, and store this one as last node + NodeImpl *element = cell->element(); + if (!element) return SelectionPointBefore; + + element = findLastSelectableNode(element); + + state.m_lastNode = element; + state.m_lastOffset = element->maxOffset(); + return SelectionPointBefore; +} + +// Hit Testing +bool RenderTableSection::nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction action, bool inside) +{ + // Table sections cannot ever be hit tested. Effectively they do not exist. + // Just forward to our children always. + tx += m_x; + ty += m_y; + + for (RenderObject* child = lastChild(); child; child = child->previousSibling()) { + // FIXME: We have to skip over inline flows, since they can show up inside table rows + // at the moment (a demoted inline <form> for example). If we ever implement a + // table-specific hit-test method (which we should do for performance reasons anyway), + // then we can remove this check. + if (!child->layer() && !child->isInlineFlow() && child->nodeAtPoint(info, x, y, tx, ty, action, inside)) { + return true; + } + } + + return false; +} + + +// ------------------------------------------------------------------------- + +RenderTableRow::RenderTableRow(DOM::NodeImpl* node) + : RenderContainer(node) +{ + // init RenderObject attributes + setInline(false); // our object is not Inline +} + +RenderObject* RenderTableRow::removeChildNode(RenderObject* child) +{ + RenderTableSection *s = section(); + if (s) + s->setNeedCellRecalc(); + + return RenderContainer::removeChildNode( child ); +} + +void RenderTableRow::detach() +{ + RenderTableSection *s = section(); + if (s) + s->setNeedCellRecalc(); + + RenderContainer::detach(); +} + +void RenderTableRow::setStyle(RenderStyle* newStyle) +{ + if (section() && style() && style()->height() != newStyle->height()) + section()->setNeedCellRecalc(); + + newStyle->setDisplay(TABLE_ROW); + RenderContainer::setStyle(newStyle); +} + +void RenderTableRow::addChild(RenderObject *child, RenderObject *beforeChild) +{ +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(TableRow)::addChild( " << child->renderName() << " )" << ", " << + (beforeChild ? beforeChild->renderName() : "0") << " )" << endl; +#endif + + if ( !child->isTableCell() ) { + // TR > FORM quirk (???) + if (child->element() && child->element()->isHTMLElement() && child->element()->id() == ID_FORM && + static_cast<HTMLFormElementImpl*>(child->element())->isMalformed()) + { + RenderContainer::addChild(child, beforeChild); + return; + } + + RenderObject* last = beforeChild; + if (!last) + last = lastChild(); + if (last && last->isAnonymous() && last->isTableCell()) { + last->addChild(child); + return; + } + + // If beforeChild is inside an anonymous cell, insert into the cell. + if (last && !last->isTableCell() && last->parent() && last->parent()->isAnonymous()) { + last->parent()->addChild(child, beforeChild); + return; + } + + RenderTableCell* cell = new (renderArena()) RenderTableCell(document() /* anonymous object */); + RenderStyle* newStyle = new RenderStyle(); + newStyle->inheritFrom(style()); + newStyle->setDisplay(TABLE_CELL); + cell->setStyle(newStyle); + addChild(cell, beforeChild); + cell->addChild(child); + return; + } + + RenderTableCell* cell = static_cast<RenderTableCell*>(child); + + section()->addCell( cell, this ); + + RenderContainer::addChild(cell,beforeChild); + + if ( beforeChild || nextSibling() ) + section()->setNeedCellRecalc(); +} + +void RenderTableRow::layout() +{ + KHTMLAssert( needsLayout() ); + KHTMLAssert( minMaxKnown() ); + + RenderObject *child = firstChild(); + const bool pagedMode = canvas()->pagedMode(); + while( child ) { + if ( child->isTableCell() ) { + RenderTableCell *cell = static_cast<RenderTableCell *>(child); + if (pagedMode) { + cell->setNeedsLayout(true); + int oldHeight = child->height(); + cell->layout(); + if (oldHeight > 0 && child->containsPageBreak() && child->height() != oldHeight) + section()->addSpaceAt(child->yPos()+1, child->height() - oldHeight); + } else + if ( child->needsLayout() ) { + if (markedForRepaint()) + cell->setMarkedForRepaint( true ); + cell->calcVerticalMargins(); + cell->layout(); + cell->setCellTopExtra(0); + cell->setCellBottomExtra(0); + if (child->containsPageBreak()) setContainsPageBreak(true); + } + } + child = child->nextSibling(); + } + setMarkedForRepaint(false); + setNeedsLayout(false); +} + +int RenderTableRow::offsetLeft() const +{ + RenderObject *child = firstChild(); + while (child && !child->isTableCell()) + child = child->nextSibling(); + + if (!child) + return 0; + + return child->offsetLeft(); +} + +int RenderTableRow::offsetTop() const +{ + RenderObject *child = firstChild(); + while (child && !child->isTableCell()) + child = child->nextSibling(); + + if (!child) + return 0; + + return child->offsetTop() - + static_cast<RenderTableCell*>(child)->cellTopExtra(); +} + +int RenderTableRow::offsetHeight() const +{ + RenderObject *child = firstChild(); + while (child && !child->isTableCell()) + child = child->nextSibling(); + + if (!child) + return 0; + + return child->offsetHeight() + + static_cast<RenderTableCell*>(child)->cellTopExtra() + + static_cast<RenderTableCell*>(child)->cellBottomExtra(); +} + +short RenderTableRow::offsetWidth() const +{ + RenderObject *fc = firstChild(); + RenderObject *lc = lastChild(); + while (fc && !fc->isTableCell()) + fc = fc->nextSibling(); + while (lc && !lc->isTableCell()) + lc = lc->previousSibling(); + if (!lc || !fc) + return 0; + + return lc->xPos()+lc->width()-fc->xPos(); +} + +void RenderTableRow::paintRow( PaintInfo& pI, int tx, int ty, int w, int h ) +{ + if (pI.phase == PaintActionOutline) + paintOutline(pI.p, tx, ty, w, h, style()); +} + +void RenderTableRow::paint(PaintInfo& i, int tx, int ty) +{ + KHTMLAssert(layer()); + if (!layer()) + return; + + for (RenderObject* child = firstChild(); child; child = child->nextSibling()) { + if (child->isTableCell()) { + // Paint the row background behind the cell. + if (i.phase == PaintActionElementBackground || i.phase == PaintActionChildBackground) { + RenderTableCell* cell = static_cast<RenderTableCell*>(child); + cell->paintBackgroundsBehindCell(i, tx, ty, this); + } + if (!child->layer()) + child->paint(i, tx, ty); + } + } +} + +// Hit Testing +bool RenderTableRow::nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction action, bool inside) +{ + // Table rows cannot ever be hit tested. Effectively they do not exist. + // Just forward to our children always. + for (RenderObject* child = lastChild(); child; child = child->previousSibling()) { + // FIXME: We have to skip over inline flows, since they can show up inside table rows + // at the moment (a demoted inline <form> for example). If we ever implement a + // table-specific hit-test method (which we should do for performance reasons anyway), + // then we can remove this check. + if (!child->layer() && !child->isInlineFlow() && child->nodeAtPoint(info, x, y, tx, ty, action, inside)) { + return true; + } + } + + return false; +} + +// ------------------------------------------------------------------------- + +RenderTableCell::RenderTableCell(DOM::NodeImpl* _node) + : RenderBlock(_node) +{ + _col = -1; + _row = -1; + updateFromElement(); + setShouldPaintBackgroundOrBorder(true); + _topExtra = 0; + _bottomExtra = 0; + m_percentageHeight = -1; + m_hasFlexedAnonymous = false; + m_widthChanged = false; +} + +void RenderTableCell::detach() +{ + if (parent() && section()) + section()->setNeedCellRecalc(); + + RenderBlock::detach(); +} + +void RenderTableCell::updateFromElement() +{ + DOM::NodeImpl *node = element(); + if ( node && (node->id() == ID_TD || node->id() == ID_TH) ) { + DOM::HTMLTableCellElementImpl *tc = static_cast<DOM::HTMLTableCellElementImpl *>(node); + cSpan = tc->colSpan(); + rSpan = tc->rowSpan(); + } else { + cSpan = rSpan = 1; + } +} + +Length RenderTableCell::styleOrColWidth() +{ + Length w = style()->width(); + if (colSpan() > 1 || !w.isVariable()) + return w; + RenderTableCol* col = table()->colElement(_col); + if (col) + w = col->style()->width(); + return w; +} + +void RenderTableCell::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(TableCell)::calcMinMaxWidth() known=" << minMaxKnown() << endl; +#endif + + if (section()->needCellRecalc) + section()->recalcCells(); + + RenderBlock::calcMinMaxWidth(); + if (element() && style()->whiteSpace() == NORMAL) { + // See if nowrap was set. + Length w = styleOrColWidth(); + DOMString nowrap = static_cast<ElementImpl*>(element())->getAttribute(ATTR_NOWRAP); + if (!nowrap.isNull() && w.isFixed() && + m_minWidth < w.value() ) + // Nowrap is set, but we didn't actually use it because of the + // fixed width set on the cell. Even so, it is a WinIE/Moz trait + // to make the minwidth of the cell into the fixed width. They do this + // even in strict mode, so do not make this a quirk. Affected the top + // of hiptop.com. + m_minWidth = w.value(); + } + + setMinMaxKnown(); +} + +void RenderTableCell::calcWidth() +{ +} + +void RenderTableCell::setWidth( int width ) +{ + if ( width != m_width ) { + m_width = width; + m_widthChanged = true; + } +} + +void RenderTableCell::layout() +{ + layoutBlock( m_widthChanged ); + m_widthChanged = false; +} + +void RenderTableCell::close() +{ + RenderBlock::close(); + +#ifdef DEBUG_LAYOUT + kdDebug( 6040 ) << renderName() << "(RenderTableCell)::close() total height =" << m_height << endl; +#endif +} + +bool RenderTableCell::requiresLayer() const { + // table-cell display is never positioned (css 2.1-9.7), so the only time a layer is needed + // is when overflow != visible (or when there is opacity when we support it) + return /* style()->opacity() < 1.0f || */ hasOverflowClip() || isRelPositioned(); +} + +void RenderTableCell::repaintRectangle(int x, int y, int w, int h, Priority p, bool f) +{ + RenderBlock::repaintRectangle(x, y, w, h + _topExtra + _bottomExtra, p, f); +} + +bool RenderTableCell::absolutePosition(int &xPos, int &yPos, bool f) const +{ + bool result = RenderBlock::absolutePosition(xPos, yPos, f); + xPos -= parent()->xPos(); // Rows are in the same coordinate space, so don't add their offset in. + yPos -= parent()->yPos(); + return result; +} + +int RenderTableCell::pageTopAfter(int y) const +{ + return section()->pageTopAfter(y+m_y + _topExtra) - (m_y + _topExtra); +} + +short RenderTableCell::baselinePosition( bool ) const +{ + RenderObject* o = firstChild(); + int offset = paddingTop() + borderTop(); + if (!o) return offset + contentHeight(); + while (o->firstChild()) { + if (!o->isInline()) + offset += o->paddingTop() + o->borderTop(); + o = o->firstChild(); + } + + if (!o->isInline()) + return paddingTop() + borderTop() + contentHeight(); + + offset += o->baselinePosition( true ); + return offset; +} + + +void RenderTableCell::setStyle( RenderStyle *newStyle ) +{ + if (parent() && section() && style() && style()->height() != newStyle->height()) + section()->setNeedCellRecalc(); + + newStyle->setDisplay(TABLE_CELL); + RenderBlock::setStyle( newStyle ); + setShouldPaintBackgroundOrBorder(true); + + if (newStyle->whiteSpace() == KHTML_NOWRAP) { + // Figure out if we are really nowrapping or if we should just + // use normal instead. If the width of the cell is fixed, then + // we don't actually use NOWRAP. + if (newStyle->width().isFixed()) + newStyle->setWhiteSpace(NORMAL); + else + newStyle->setWhiteSpace(NOWRAP); + } +} + +bool RenderTableCell::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inside) +{ + int tx = _tx + m_x; + int ty = _ty + m_y; + + // also include the top and bottom extra space + inside |= style()->visibility() != HIDDEN + && (_y >= ty) && (_y < ty + height() + _topExtra + _bottomExtra) + && (_x >= tx) && (_x < tx + width()); + + return RenderBlock::nodeAtPoint(info, _x, _y, _tx, _ty, hitTestAction, inside); +} + +// The following rules apply for resolving conflicts and figuring out which border +// to use. +// (1) Borders with the 'border-style' of 'hidden' take precedence over all other conflicting +// borders. Any border with this value suppresses all borders at this location. +// (2) Borders with a style of 'none' have the lowest priority. Only if the border properties of all +// the elements meeting at this edge are 'none' will the border be omitted (but note that 'none' is +// the default value for the border style.) +// (3) If none of the styles are 'hidden' and at least one of them is not 'none', then narrow borders +// are discarded in favor of wider ones. If several have the same 'border-width' then styles are preferred +// in this order: 'double', 'solid', 'dashed', 'dotted', 'ridge', 'outset', 'groove', and the lowest: 'inset'. +// (4) If border styles differ only in color, then a style set on a cell wins over one on a row, +// which wins over a row group, column, column group and, lastly, table. It is undefined which color +// is used when two elements of the same type disagree. +static CollapsedBorderValue compareBorders(const CollapsedBorderValue& border1, + const CollapsedBorderValue& border2) +{ + // Sanity check the values passed in. If either is null, return the other. + if (!border2.exists()) return border1; + if (!border1.exists()) return border2; + + // Rule #1 above. + if (border1.style() == BHIDDEN || border2.style() == BHIDDEN) + return CollapsedBorderValue(); // No border should exist at this location. + + // Rule #2 above. A style of 'none' has lowest priority and always loses to any other border. + if (border2.style() == BNONE) return border1; + if (border1.style() == BNONE) return border2; + + // The first part of rule #3 above. Wider borders win. + if (border1.width() != border2.width()) + return border1.width() > border2.width() ? border1 : border2; + + // The borders have equal width. Sort by border style. + if (border1.style() != border2.style()) + return border1.style() > border2.style() ? border1 : border2; + + // The border have the same width and style. Rely on precedence (cell over row over row group, etc.) + return border1.precedence >= border2.precedence ? border1 : border2; +} + +CollapsedBorderValue RenderTableCell::collapsedLeftBorder() const +{ + // For border left, we need to check, in order of precedence: + // (1) Our left border. + CollapsedBorderValue result(&style()->borderLeft(), BCELL); + + // (2) The previous cell's right border. + RenderTableCell* prevCell = table()->cellLeft(this); + if (prevCell) { + result = compareBorders(result, CollapsedBorderValue(&prevCell->style()->borderRight(), BCELL)); + if (!result.exists()) return result; + } + else if (col() == 0) { + // (3) Our row's left border. + result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderLeft(), BROW)); + if (!result.exists()) return result; + + // (4) Our row group's left border. + result = compareBorders(result, CollapsedBorderValue(§ion()->style()->borderLeft(), BROWGROUP)); + if (!result.exists()) return result; + } + + // (5) Our column's left border. + RenderTableCol* colElt = table()->colElement(col()); + if (colElt) { + result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderLeft(), BCOL)); + if (!result.exists()) return result; + } + + // (6) The previous column's right border. + if (col() > 0) { + colElt = table()->colElement(col()-1); + if (colElt) { + result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderRight(), BCOL)); + if (!result.exists()) return result; + } + } + + if (col() == 0) { + // (7) The table's left border. + result = compareBorders(result, CollapsedBorderValue(&table()->style()->borderLeft(), BTABLE)); + if (!result.exists()) return result; + } + + return result; +} + +CollapsedBorderValue RenderTableCell::collapsedRightBorder() const +{ + RenderTable* tableElt = table(); + bool inLastColumn = false; + int effCol = tableElt->colToEffCol(col()+colSpan()-1); + if (effCol == tableElt->numEffCols()-1) + inLastColumn = true; + + // For border right, we need to check, in order of precedence: + // (1) Our right border. + CollapsedBorderValue result = CollapsedBorderValue(&style()->borderRight(), BCELL); + + // (2) The next cell's left border. + if (!inLastColumn) { + RenderTableCell* nextCell = tableElt->cellRight(this); + if (nextCell) { + result = compareBorders(result, CollapsedBorderValue(&nextCell->style()->borderLeft(), BCELL)); + if (!result.exists()) return result; + } + } + else { + // (3) Our row's right border. + result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderRight(), BROW)); + if (!result.exists()) return result; + + // (4) Our row group's right border. + result = compareBorders(result, CollapsedBorderValue(§ion()->style()->borderRight(), BROWGROUP)); + if (!result.exists()) return result; + } + + // (5) Our column's right border. + RenderTableCol* colElt = table()->colElement(col()+colSpan()-1); + if (colElt) { + result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderRight(), BCOL)); + if (!result.exists()) return result; + } + + // (6) The next column's left border. + if (!inLastColumn) { + colElt = tableElt->colElement(col()+colSpan()); + if (colElt) { + result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderLeft(), BCOL)); + if (!result.exists()) return result; + } + } + else { + // (7) The table's right border. + result = compareBorders(result, CollapsedBorderValue(&tableElt->style()->borderRight(), BTABLE)); + if (!result.exists()) return result; + } + + return result; +} + +CollapsedBorderValue RenderTableCell::collapsedTopBorder() const +{ + // For border top, we need to check, in order of precedence: + // (1) Our top border. + CollapsedBorderValue result = CollapsedBorderValue(&style()->borderTop(), BCELL); + + RenderTableCell* prevCell = table()->cellAbove(this); + if (prevCell) { + // (2) A previous cell's bottom border. + result = compareBorders(result, CollapsedBorderValue(&prevCell->style()->borderBottom(), BCELL)); + if (!result.exists()) return result; + } + + // (3) Our row's top border. + result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderTop(), BROW)); + if (!result.exists()) return result; + + // (4) The previous row's bottom border. + if (prevCell) { + RenderObject* prevRow = 0; + if (prevCell->section() == section()) + prevRow = parent()->previousSibling(); + else + prevRow = prevCell->section()->lastChild(); + + if (prevRow) { + result = compareBorders(result, CollapsedBorderValue(&prevRow->style()->borderBottom(), BROW)); + if (!result.exists()) return result; + } + } + + // Now check row groups. + RenderTableSection* currSection = section(); + if (row() == 0) { + // (5) Our row group's top border. + result = compareBorders(result, CollapsedBorderValue(&currSection->style()->borderTop(), BROWGROUP)); + if (!result.exists()) return result; + + // (6) Previous row group's bottom border. + currSection = table()->sectionAbove(currSection); + if (currSection) { + result = compareBorders(result, CollapsedBorderValue(&currSection->style()->borderBottom(), BROWGROUP)); + if (!result.exists()) + return result; + } + } + + if (!currSection) { + // (8) Our column's top border. + RenderTableCol* colElt = table()->colElement(col()); + if (colElt) { + result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderTop(), BCOL)); + if (!result.exists()) return result; + } + + // (9) The table's top border. + result = compareBorders(result, CollapsedBorderValue(&table()->style()->borderTop(), BTABLE)); + if (!result.exists()) return result; + } + + return result; +} + +CollapsedBorderValue RenderTableCell::collapsedBottomBorder() const +{ + // For border top, we need to check, in order of precedence: + // (1) Our bottom border. + CollapsedBorderValue result = CollapsedBorderValue(&style()->borderBottom(), BCELL); + + RenderTableCell* nextCell = table()->cellBelow(this); + if (nextCell) { + // (2) A following cell's top border. + result = compareBorders(result, CollapsedBorderValue(&nextCell->style()->borderTop(), BCELL)); + if (!result.exists()) return result; + } + + // (3) Our row's bottom border. (FIXME: Deal with rowspan!) + result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderBottom(), BROW)); + if (!result.exists()) return result; + + // (4) The next row's top border. + if (nextCell) { + result = compareBorders(result, CollapsedBorderValue(&nextCell->parent()->style()->borderTop(), BROW)); + if (!result.exists()) return result; + } + + // Now check row groups. + RenderTableSection* currSection = section(); + if (row()+rowSpan() >= static_cast<RenderTableSection*>(currSection)->numRows()) { + // (5) Our row group's bottom border. + result = compareBorders(result, CollapsedBorderValue(&currSection->style()->borderBottom(), BROWGROUP)); + if (!result.exists()) return result; + + // (6) Following row group's top border. + currSection = table()->sectionBelow(currSection); + if (currSection) { + result = compareBorders(result, CollapsedBorderValue(&currSection->style()->borderTop(), BROWGROUP)); + if (!result.exists()) + return result; + } + } + + if (!currSection) { + // (8) Our column's bottom border. + RenderTableCol* colElt = table()->colElement(col()); + if (colElt) { + result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderBottom(), BCOL)); + if (!result.exists()) return result; + } + + // (9) The table's bottom border. + result = compareBorders(result, CollapsedBorderValue(&table()->style()->borderBottom(), BTABLE)); + if (!result.exists()) return result; + } + + return result; +} + +int RenderTableCell::borderLeft() const +{ + if (table()->collapseBorders()) { + CollapsedBorderValue border = collapsedLeftBorder(); + if (border.exists()) + return (border.width()+1)/2; // Give the extra pixel to top and left. + return 0; + } + return RenderBlock::borderLeft(); +} + +int RenderTableCell::borderRight() const +{ + if (table()->collapseBorders()) { + CollapsedBorderValue border = collapsedRightBorder(); + if (border.exists()) + return border.width()/2; + return 0; + } + return RenderBlock::borderRight(); +} + +int RenderTableCell::borderTop() const +{ + if (table()->collapseBorders()) { + CollapsedBorderValue border = collapsedTopBorder(); + if (border.exists()) + return (border.width()+1)/2; // Give the extra pixel to top and left. + return 0; + } + return RenderBlock::borderTop(); +} + +int RenderTableCell::borderBottom() const +{ + if (table()->collapseBorders()) { + CollapsedBorderValue border = collapsedBottomBorder(); + if (border.exists()) + return border.width()/2; + return 0; + } + return RenderBlock::borderBottom(); +} + +#ifdef BOX_DEBUG +#include <tqpainter.h> + +static void outlineBox(TQPainter *p, int _tx, int _ty, int w, int h) +{ + p->setPen(TQPen(TQColor("yellow"), 3, Qt::DotLine)); + p->setBrush( Qt::NoBrush ); + p->drawRect(_tx, _ty, w, h ); +} +#endif + +void RenderTableCell::paint(PaintInfo& pI, int _tx, int _ty) +{ + +#ifdef TABLE_PRINT + kdDebug( 6040 ) << renderName() << "(RenderTableCell)::paint() w/h = (" << width() << "/" << height() << ")" << " _y/_h=" << pI.r.y() << "/" << pI.r.height() << endl; +#endif + + if (needsLayout()) return; + + _tx += m_x; + _ty += m_y/* + _topExtra*/; + + RenderTable *tbl = table(); + + // check if we need to do anything at all... + int os = kMax(tbl->currentBorderStyle() ? (tbl->currentBorderStyle()->border->width+1)/2 : 0, 2*maximalOutlineSize(pI.phase)); + if (!overhangingContents() && ((_ty >= pI.r.y() + pI.r.height() + os) + || (_ty + _topExtra + m_height + _bottomExtra <= pI.r.y() - os))) return; + + if (pI.phase == PaintActionOutline) { + paintOutline( pI.p, _tx, _ty, width(), height() + borderTopExtra() + borderBottomExtra(), style()); + } + + if (pI.phase == PaintActionCollapsedTableBorders && style()->visibility() == VISIBLE) { + int w = width(); + int h = height() + borderTopExtra() + borderBottomExtra(); + paintCollapsedBorder(pI.p, _tx, _ty, w, h); + } + else + RenderBlock::paintObject(pI, _tx, _ty + _topExtra, false); + +#ifdef BOX_DEBUG + ::outlineBox( p, _tx, _ty - _topExtra, width(), height() + borderTopExtra() + borderBottomExtra()); +#endif +} + +static EBorderStyle collapsedBorderStyle(EBorderStyle style) +{ + if (style == OUTSET) + style = GROOVE; + else if (style == INSET) + style = RIDGE; + return style; +} + +struct CollapsedBorder { + CollapsedBorder(){} + + CollapsedBorderValue border; + RenderObject::BorderSide side; + bool shouldPaint; + int x1; + int y1; + int x2; + int y2; + EBorderStyle style; +}; + +class CollapsedBorders +{ +public: + CollapsedBorders() :count(0) {} + + void addBorder(const CollapsedBorderValue& b, RenderObject::BorderSide s, bool paint, + int _x1, int _y1, int _x2, int _y2, + EBorderStyle _style) + { + if (b.exists() && paint) { + borders[count].border = b; + borders[count].side = s; + borders[count].shouldPaint = paint; + borders[count].x1 = _x1; + borders[count].x2 = _x2; + borders[count].y1 = _y1; + borders[count].y2 = _y2; + borders[count].style = _style; + count++; + } + } + + CollapsedBorder* nextBorder() { + for (int i = 0; i < count; i++) { + if (borders[i].border.exists() && borders[i].shouldPaint) { + borders[i].shouldPaint = false; + return &borders[i]; + } + } + + return 0; + } + + CollapsedBorder borders[4]; + int count; +}; + +static void addBorderStyle(TQValueList<CollapsedBorderValue>& borderStyles, CollapsedBorderValue borderValue) +{ + if (!borderValue.exists() || borderStyles.contains(borderValue)) + return; + + TQValueListIterator<CollapsedBorderValue> it = borderStyles.begin(); + TQValueListIterator<CollapsedBorderValue> end = borderStyles.end(); + for (; it != end; ++it) { + CollapsedBorderValue result = compareBorders(*it, borderValue); + if (result == *it) { + borderStyles.insert(it, borderValue); + return; + } + } + + borderStyles.append(borderValue); +} + +void RenderTableCell::collectBorders(TQValueList<CollapsedBorderValue>& borderStyles) +{ + addBorderStyle(borderStyles, collapsedLeftBorder()); + addBorderStyle(borderStyles, collapsedRightBorder()); + addBorderStyle(borderStyles, collapsedTopBorder()); + addBorderStyle(borderStyles, collapsedBottomBorder()); +} + +void RenderTableCell::paintCollapsedBorder(TQPainter* p, int _tx, int _ty, int w, int h) +{ + if (!table()->currentBorderStyle()) + return; + + CollapsedBorderValue leftVal = collapsedLeftBorder(); + CollapsedBorderValue rightVal = collapsedRightBorder(); + CollapsedBorderValue topVal = collapsedTopBorder(); + CollapsedBorderValue bottomVal = collapsedBottomBorder(); + + // Adjust our x/y/width/height so that we paint the collapsed borders at the correct location. + int topWidth = topVal.width(); + int bottomWidth = bottomVal.width(); + int leftWidth = leftVal.width(); + int rightWidth = rightVal.width(); + + _tx -= leftWidth/2; + _ty -= topWidth/2; + w += leftWidth/2 + (rightWidth+1)/2; + h += topWidth/2 + (bottomWidth+1)/2; + + bool tt = topVal.isTransparent(); + bool bt = bottomVal.isTransparent(); + bool rt = rightVal.isTransparent(); + bool lt = leftVal.isTransparent(); + + EBorderStyle ts = collapsedBorderStyle(topVal.style()); + EBorderStyle bs = collapsedBorderStyle(bottomVal.style()); + EBorderStyle ls = collapsedBorderStyle(leftVal.style()); + EBorderStyle rs = collapsedBorderStyle(rightVal.style()); + + bool render_t = ts > BHIDDEN && !tt && (topVal.precedence != BCELL || *topVal.border == style()->borderTop()); + bool render_l = ls > BHIDDEN && !lt && (leftVal.precedence != BCELL || *leftVal.border == style()->borderLeft()); + bool render_r = rs > BHIDDEN && !rt && (rightVal.precedence != BCELL || *rightVal.border == style()->borderRight()); + bool render_b = bs > BHIDDEN && !bt && (bottomVal.precedence != BCELL || *bottomVal.border == style()->borderBottom()); + + // We never paint diagonals at the joins. We simply let the border with the highest + // precedence paint on top of borders with lower precedence. + CollapsedBorders borders; + borders.addBorder(topVal, BSTop, render_t, _tx, _ty, _tx + w, _ty + topWidth, ts); + borders.addBorder(bottomVal, BSBottom, render_b, _tx, _ty + h - bottomWidth, _tx + w, _ty + h, bs); + borders.addBorder(leftVal, BSLeft, render_l, _tx, _ty, _tx + leftWidth, _ty + h, ls); + borders.addBorder(rightVal, BSRight, render_r, _tx + w - rightWidth, _ty, _tx + w, _ty + h, rs); + + for (CollapsedBorder* border = borders.nextBorder(); border; border = borders.nextBorder()) { + if (border->border == *table()->currentBorderStyle()) + drawBorder(p, border->x1, border->y1, border->x2, border->y2, border->side, + border->border.color(), style()->color(), border->style, 0, 0); + } +} + +void RenderTableCell::paintBackgroundsBehindCell(PaintInfo& pI, int _tx, int _ty, RenderObject* backgroundObject) +{ + if (!backgroundObject) + return; + + RenderTable* tableElt = table(); + if (backgroundObject != this) { + _tx += m_x; + _ty += m_y + _topExtra; + } + + int w = width(); + int h = height() + borderTopExtra() + borderBottomExtra(); + _ty -= borderTopExtra(); + + int my = kMax(_ty,pI.r.y()); + int end = kMin( pI.r.y() + pI.r.height(), _ty + h ); + int mh = end - my; + + TQColor c = backgroundObject->style()->backgroundColor(); + const BackgroundLayer* bgLayer = backgroundObject->style()->backgroundLayers(); + + if (bgLayer->hasImage() || c.isValid()) { + // We have to clip here because the background would paint + // on top of the borders otherwise. This only matters for cells and rows. + bool hasLayer = backgroundObject->layer() && (backgroundObject == this || backgroundObject == parent()); + if (hasLayer && tableElt->collapseBorders()) { + pI.p->save(); + TQRect clipRect(_tx + borderLeft(), _ty + borderTop(), w - borderLeft() - borderRight(), h - borderTop() - borderBottom()); + clipRect = pI.p->xForm(clipRect); + TQRegion creg(clipRect); + TQRegion old = pI.p->clipRegion(); + if (!old.isNull()) + creg = old.intersect(creg); + pI.p->setClipRegion(creg); + } + paintBackground(pI.p, c, bgLayer, my, mh, _tx, _ty, w, h); + if (hasLayer && tableElt->collapseBorders()) + pI.p->restore(); + } +} + +void RenderTableCell::paintBoxDecorations(PaintInfo& pI, int _tx, int _ty) +{ + RenderTable* tableElt = table(); + bool drawBorders = true; + // Moz paints bgcolor/bgimage on <td>s in quirks mode even if + // empty-cells are on. Fixes regression on #43426, attachment #354 + if (!tableElt->collapseBorders() && style()->emptyCells() == HIDE && !firstChild()) + drawBorders = false; + if (!style()->htmlHacks() && !drawBorders) return; + + // Paint our cell background. + paintBackgroundsBehindCell(pI, _tx, _ty, this); + + int w = width(); + int h = height() + borderTopExtra() + borderBottomExtra(); + _ty -= borderTopExtra(); + + if (drawBorders && style()->hasBorder() && !tableElt->collapseBorders()) + paintBorder(pI.p, _tx, _ty, w, h, style()); +} + + +#ifdef ENABLE_DUMP +void RenderTableCell::dump(TQTextStream &stream, const TQString &ind) const +{ + RenderFlow::dump(stream,ind); + stream << " row=" << _row; + stream << " col=" << _col; + stream << " rSpan=" << rSpan; + stream << " cSpan=" << cSpan; +// *stream << " nWrap=" << nWrap; +} +#endif + +// ------------------------------------------------------------------------- + +RenderTableCol::RenderTableCol(DOM::NodeImpl* node) + : RenderContainer(node), m_span(1) +{ + // init RenderObject attributes + setInline(true); // our object is not Inline + updateFromElement(); +} + +void RenderTableCol::updateFromElement() +{ + DOM::NodeImpl *node = element(); + if ( node && (node->id() == ID_COL || node->id() == ID_COLGROUP) ) { + DOM::HTMLTableColElementImpl *tc = static_cast<DOM::HTMLTableColElementImpl *>(node); + m_span = tc->span(); + } else + m_span = ! ( style() && style()->display() == TABLE_COLUMN_GROUP ); +} + +#ifdef ENABLE_DUMP +void RenderTableCol::dump(TQTextStream &stream, const TQString &ind) const +{ + RenderContainer::dump(stream,ind); + stream << " _span=" << m_span; +} +#endif + +// ------------------------------------------------------------------------- + +TableSectionIterator::TableSectionIterator(RenderTable *table, bool fromEnd) +{ + if (fromEnd) { + sec = table->foot; + if (sec) return; + + sec = static_cast<RenderTableSection *>(table->lastChild()); + while (sec && (!sec->isTableSection() + || sec == table->head || sec == table->foot)) + sec = static_cast<RenderTableSection *>(sec->previousSibling()); + if (sec) return; + + sec = table->head; + } else { + sec = table->head; + if (sec) return; + + sec = static_cast<RenderTableSection *>(table->firstChild()); + while (sec && (!sec->isTableSection() + || sec == table->head || sec == table->foot)) + sec = static_cast<RenderTableSection *>(sec->nextSibling()); + if (sec) return; + + sec = table->foot; + }/*end if*/ + +} + +TableSectionIterator &TableSectionIterator::operator ++() +{ + RenderTable *table = sec->table(); + if (sec == table->head) { + + sec = static_cast<RenderTableSection *>(table->firstChild()); + while (sec && (!sec->isTableSection() + || sec == table->head || sec == table->foot)) + sec = static_cast<RenderTableSection *>(sec->nextSibling()); + if (sec) return *this; + + } else if (sec == table->foot) { + sec = 0; + return *this; + + } else { + + do { + sec = static_cast<RenderTableSection *>(sec->nextSibling()); + } while (sec && (!sec->isTableSection() || sec == table->head || sec == table->foot)); + if (sec) return *this; + + }/*end if*/ + + sec = table->foot; + return *this; +} + +TableSectionIterator &TableSectionIterator::operator --() +{ + RenderTable *table = sec->table(); + if (sec == table->foot) { + + sec = static_cast<RenderTableSection *>(table->lastChild()); + while (sec && (!sec->isTableSection() + || sec == table->head || sec == table->foot)) + sec = static_cast<RenderTableSection *>(sec->previousSibling()); + if (sec) return *this; + + } else if (sec == table->head) { + sec = 0; + return *this; + + } else { + + do { + sec = static_cast<RenderTableSection *>(sec->previousSibling()); + } while (sec && (!sec->isTableSection() || sec == table->head || sec == table->foot)); + if (sec) return *this; + + }/*end if*/ + + sec = table->foot; + return *this; +} + +#undef TABLE_DEBUG +#undef DEBUG_LAYOUT +#undef BOX_DEBUG diff --git a/tdehtml/rendering/render_table.h b/tdehtml/rendering/render_table.h new file mode 100644 index 000000000..09695e3d8 --- /dev/null +++ b/tdehtml/rendering/render_table.h @@ -0,0 +1,524 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1997 Martin Jones (mjones@kde.org) + * (C) 1997 Torben Weis (weis@kde.org) + * (C) 1998 Waldo Bastian (bastian@kde.org) + * (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDER_TABLE_H +#define RENDER_TABLE_H + +#include <tqcolor.h> +#include <tqptrvector.h> + +#include "rendering/render_box.h" +#include "rendering/render_block.h" +#include "rendering/render_style.h" + +#include "misc/tdehtmllayout.h" + +namespace DOM { + class DOMString; +} + +namespace tdehtml { + +class RenderTable; +class RenderTableSection; +class RenderTableRow; +class RenderTableCell; +class RenderTableCol; +class TableLayout; + +class RenderTable : public RenderBlock +{ +public: + + RenderTable(DOM::NodeImpl* node); + ~RenderTable(); + + virtual const char *renderName() const { return "RenderTable"; } + + virtual void setStyle(RenderStyle *style); + + virtual bool isTable() const { return true; } + + int getColumnPos(int col) const + { return columnPos[col]; } + + int borderHSpacing() const { return hspacing; } + int borderVSpacing() const { return vspacing; } + + bool collapseBorders() const { return style()->borderCollapse(); } + int borderLeft() const; + int borderRight() const; + int borderTop() const; + int borderBottom() const; + int paddingLeft() const { return collapseBorders() ? 0 : RenderBlock::paddingLeft(); } + int paddingRight() const { return collapseBorders() ? 0 : RenderBlock::paddingRight(); } + int paddingTop() const { return collapseBorders() ? 0 : RenderBlock::paddingTop(); } + int paddingBottom() const { return collapseBorders() ? 0 : RenderBlock::paddingBottom(); } + + const TQColor &bgColor() const { return style()->backgroundColor(); } + + uint cellPadding() const { return padding; } + void setCellPadding( uint p ) { padding = p; } + + // overrides + virtual void addChild(RenderObject *child, RenderObject *beforeChild = 0); + virtual void paint( PaintInfo&, int tx, int ty); + virtual void paintBoxDecorations(PaintInfo&, int _tx, int _ty); + virtual void layout(); + virtual void calcMinMaxWidth(); + virtual void close(); + + virtual short lineHeight(bool b) const; + virtual short baselinePosition(bool b) const; + + virtual void setCellWidths( ); + + virtual void calcWidth(); + + virtual FindSelectionResult checkSelectionPoint( int _x, int _y, int _tx, int _ty, + DOM::NodeImpl*& node, int & offset, + SelPointState & ); + +#ifdef ENABLE_DUMP + virtual void dump(TQTextStream &stream, const TQString &ind) const; +#endif + struct ColumnStruct { + enum { + WidthUndefined = 0xffff + }; + ColumnStruct() { + span = 1; + width = WidthUndefined; + } + ushort span; + ushort width; // the calculated position of the column + }; + + TQMemArray<int> columnPos; + TQMemArray<ColumnStruct> columns; + + void splitColumn( int pos, int firstSpan ); + void appendColumn( int span ); + int numEffCols() const { return columns.size(); } + int spanOfEffCol( int effCol ) const { return columns[effCol].span; } + int colToEffCol( int col ) const { + int c = 0; + int i = 0; + while ( c < col && i < (int)columns.size() ) { + c += columns[i].span; + i++; + } + return i; + } + int effColToCol( int effCol ) const { + int c = 0; + for ( int i = 0; i < effCol; i++ ) + c += columns[i].span; + return c; + } + + int bordersPaddingAndSpacing() const { + return borderLeft() + borderRight() + + (collapseBorders() ? 0 : (paddingLeft() + paddingRight() + (numEffCols()+1) * borderHSpacing())); + } + + RenderTableCol *colElement( int col ); + + void setNeedSectionRecalc() { needSectionRecalc = true; } + + virtual RenderObject* removeChildNode(RenderObject* child); + + RenderTableSection* sectionAbove(const RenderTableSection*, bool skipEmptySections = false) const; + RenderTableSection* sectionBelow(const RenderTableSection*, bool skipEmptySections = false) const; + + RenderTableCell* cellAbove(const RenderTableCell* cell) const; + RenderTableCell* cellBelow(const RenderTableCell* cell) const; + RenderTableCell* cellLeft(const RenderTableCell* cell) const; + RenderTableCell* cellRight(const RenderTableCell* cell) const; + + CollapsedBorderValue* currentBorderStyle() { return m_currentBorder; } + + RenderTableSection *firstBodySection() const { return firstBody; } + RenderFlow* caption() const { return tCaption; } + +protected: + + void recalcSections(); + + friend class AutoTableLayout; + friend class FixedTableLayout; + + RenderFlow *tCaption; + RenderTableSection *head; + RenderTableSection *foot; + RenderTableSection *firstBody; + + TableLayout *tableLayout; + + CollapsedBorderValue* m_currentBorder; + + bool has_col_elems : 1; + uint needSectionRecalc : 1; + uint padding : 22; + + ushort hspacing; + ushort vspacing; + + friend class TableSectionIterator; +}; + +// ------------------------------------------------------------------------- + +class RenderTableSection : public RenderBox +{ +public: + RenderTableSection(DOM::NodeImpl* node); + ~RenderTableSection(); + virtual void detach(); + + virtual void setStyle(RenderStyle *style); + + virtual const char *renderName() const { return "RenderTableSection"; } + + // overrides + virtual void addChild(RenderObject *child, RenderObject *beforeChild = 0); + virtual bool isTableSection() const { return true; } + + virtual short lineHeight(bool) const { return 0; } + virtual void position(InlineBox*, int, int, bool) {} + + virtual short width() const; + + virtual FindSelectionResult checkSelectionPoint( int _x, int _y, int _tx, int _ty, + DOM::NodeImpl*& node, int & offset, + SelPointState & ); + +#ifdef ENABLE_DUMP + virtual void dump(TQTextStream &stream, const TQString &ind) const; +#endif + + void addCell( RenderTableCell *cell, RenderTableRow *row ); + + void setCellWidths(); + void calcRowHeight(); + int layoutRows( int height ); + + RenderTable *table() const { return static_cast<RenderTable *>(parent()); } + + typedef TQMemArray<RenderTableCell *> Row; + struct RowStruct { + Row *row; + RenderTableRow* rowRenderer; + int baseLine; + Length height; + bool needFlex; + }; + + RenderTableCell *&cellAt( int row, int col ) { + return (*(grid[row].row))[col]; + } + RenderTableCell *cellAt( int row, int col ) const { + return (*(grid[row].row))[col]; + } + + virtual int lowestPosition(bool includeOverflowInterior, bool includeSelf) const; + virtual int rightmostPosition(bool includeOverflowInterior, bool includeSelf) const; + virtual int leftmostPosition(bool includeOverflowInterior, bool includeSelf) const; + virtual int highestPosition(bool includeOverflowInterior, bool includeSelf) const; + + int borderLeft() const { return table()->collapseBorders() ? 0 : RenderBox::borderLeft(); } + int borderRight() const { return table()->collapseBorders() ? 0 : RenderBox::borderRight(); } + int borderTop() const { return table()->collapseBorders() ? 0 : RenderBox::borderTop(); } + int borderBottom() const { return table()->collapseBorders() ? 0 : RenderBox::borderBottom(); } + + virtual void paint( PaintInfo& i, int tx, int ty); + + int numRows() const { return grid.size(); } + int getBaseline(int row) {return grid[row].baseLine;} + + void setNeedCellRecalc() { + needCellRecalc = true; + table()->setNeedSectionRecalc(); + } + + virtual RenderObject* removeChildNode(RenderObject* child); + + virtual bool canClear(RenderObject *child, PageBreakLevel level); + void addSpaceAt(int pos, int dy); + + virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction action, bool inside); + + // this gets a cell grid data structure. changing the number of + // columns is done by the table + TQMemArray<RowStruct> grid; + TQMemArray<int> rowPos; + + signed short cRow; + ushort cCol; + bool needCellRecalc; + + void recalcCells(); +protected: + void ensureRows( int numRows ); + void clearGrid(); + bool emptyRow(int rowNum); + bool flexCellChildren(RenderObject* p) const; + + + friend class TableSectionIterator; +}; + +// ------------------------------------------------------------------------- + +class RenderTableRow : public RenderContainer +{ +public: + RenderTableRow(DOM::NodeImpl* node); + + virtual void detach(); + + virtual void setStyle( RenderStyle* ); + virtual const char *renderName() const { return "RenderTableRow"; } + virtual bool isTableRow() const { return true; } + virtual void addChild(RenderObject *child, RenderObject *beforeChild = 0); + + virtual short offsetWidth() const; + virtual int offsetHeight() const; + virtual int offsetLeft() const; + virtual int offsetTop() const; + + virtual short lineHeight( bool ) const { return 0; } + virtual void position(InlineBox*, int, int, bool) {} + + virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction action, bool inside); + + virtual void layout(); + + virtual RenderObject* removeChildNode(RenderObject* child); + + // The only time rows get a layer is when they have transparency. + virtual bool requiresLayer() const { return /* style()->opacity() < 1.0f; */ false ; } + virtual void paint(PaintInfo& i, int tx, int ty); + + void paintRow( PaintInfo& i, int tx, int ty, int w, int h); + + RenderTable *table() const { return static_cast<RenderTable *>(parent()->parent()); } + RenderTableSection *section() const { return static_cast<RenderTableSection *>(parent()); } +}; + +// ------------------------------------------------------------------------- + +class RenderTableCell : public RenderBlock +{ +public: + RenderTableCell(DOM::NodeImpl* node); + + virtual void layout(); + virtual void detach(); + + virtual const char *renderName() const { return "RenderTableCell"; } + virtual bool isTableCell() const { return true; } + + // ### FIX these two... + long cellIndex() const { return 0; } + void setCellIndex( long ) { } + + unsigned short colSpan() const { return cSpan; } + void setColSpan( unsigned short c ) { cSpan = c; } + + unsigned short rowSpan() const { return rSpan; } + void setRowSpan( unsigned short r ) { rSpan = r; } + + int col() const { return _col; } + void setCol(int col) { _col = col; } + int row() const { return _row; } + void setRow(int r) { _row = r; } + + Length styleOrColWidth(); + + // overrides + virtual void calcMinMaxWidth(); + virtual void calcWidth(); + virtual void setWidth( int width ); + virtual void setStyle( RenderStyle *style ); + virtual bool requiresLayer() const; + + int borderLeft() const; + int borderRight() const; + int borderTop() const; + int borderBottom() const; + + CollapsedBorderValue collapsedLeftBorder() const; + CollapsedBorderValue collapsedRightBorder() const; + CollapsedBorderValue collapsedTopBorder() const; + CollapsedBorderValue collapsedBottomBorder() const; + virtual void collectBorders(TQValueList<CollapsedBorderValue>& borderStyles); + + virtual void updateFromElement(); + + void setCellTopExtra(int p) { _topExtra = p; } + void setCellBottomExtra(int p) { _bottomExtra = p; } + int cellTopExtra() const { return _topExtra; } + int cellBottomExtra() const { return _bottomExtra; } + + int pageTopAfter(int x) const; + + virtual void paint( PaintInfo& i, int tx, int ty); + + void paintCollapsedBorder(TQPainter* p, int x, int y, int w, int h); + void paintBackgroundsBehindCell(PaintInfo& i, int _tx, int _ty, RenderObject* backgroundObject); + + virtual void close(); + + // lie position to outside observers + virtual int yPos() const { return m_y + _topExtra; } + + virtual void repaintRectangle(int x, int y, int w, int h, Priority p=NormalPriority, bool f=false); + virtual bool absolutePosition(int &xPos, int &yPos, bool f = false) const; + + virtual short baselinePosition( bool = false ) const; + + virtual bool nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inside); + + RenderTable *table() const { return static_cast<RenderTable *>(parent()->parent()->parent()); } + RenderTableSection *section() const { return static_cast<RenderTableSection *>(parent()->parent()); } + +#ifdef ENABLE_DUMP + virtual void dump(TQTextStream &stream, const TQString &ind) const; +#endif + + bool widthChanged() { + bool retval = m_widthChanged; + m_widthChanged = false; + return retval; + } + + int cellPercentageHeight() const + { return m_percentageHeight; } + void setCellPercentageHeight(int h) + { m_percentageHeight = h; } + bool hasFlexedAnonymous() const + { return m_hasFlexedAnonymous; } + void setHasFlexedAnonymous(bool b=true) + { m_hasFlexedAnonymous = b; } + +protected: + virtual void paintBoxDecorations(PaintInfo& p, int _tx, int _ty); + virtual int borderTopExtra() const { return _topExtra; } + virtual int borderBottomExtra() const { return _bottomExtra; } + + short _row; + short _col; + ushort rSpan; + ushort cSpan; + int _topExtra; + signed int _bottomExtra : 30; + bool m_widthChanged : 1; + bool m_hasFlexedAnonymous : 1; + int m_percentageHeight; +}; + + +// ------------------------------------------------------------------------- + +class RenderTableCol : public RenderContainer +{ +public: + RenderTableCol(DOM::NodeImpl* node); + + virtual const char *renderName() const { return "RenderTableCol"; } + + virtual bool isTableCol() const { return true; } + + virtual short lineHeight( bool ) const { return 0; } + virtual void position(InlineBox*, int, int, bool) {} + virtual void layout() {} + virtual bool requiresLayer() const { return false; } + + virtual void updateFromElement(); + +#ifdef ENABLE_DUMP + virtual void dump(TQTextStream &stream, const TQString& ind) const; +#endif + + int span() const { return m_span; } + void setSpan( int s ) { m_span = s; } + +private: + int m_span; +}; + +// ------------------------------------------------------------------------- + +/** This class provides an iterator to iterate through the sections of a + * render table in their visual order. + * + * In HTML, sections are specified in the order of THEAD, TFOOT, and TBODY. + * Visually, TBODY sections appear between THEAD and TFOOT, which this iterator + * takes into regard. + * @author Leo Savernik + * @internal + * @since 3.2 + */ +class TableSectionIterator { +public: + + /** + * Initializes a new iterator + * @param table table whose sections to iterate + * @param fromEnd @p true, begin with last section, @p false, begin with + * first section. + */ + TableSectionIterator(RenderTable *table, bool fromEnd = false); + + /** + * Initializes a new iterator + * @param start table section to start with. + */ + TableSectionIterator(RenderTableSection *start) : sec(start) {} + + /** + * Uninitialized iterator. + */ + TableSectionIterator() {} + + /** Returns the current section, or @p 0 if the end has been reached. + */ + RenderTableSection *operator *() const { return sec; } + + /** Moves to the next section in visual order. */ + TableSectionIterator &operator ++(); + + /** Moves to the previous section in visual order. */ + TableSectionIterator &operator --(); + +private: + RenderTableSection *sec; +}; + +} +#endif + diff --git a/tdehtml/rendering/render_text.cpp b/tdehtml/rendering/render_text.cpp new file mode 100644 index 000000000..9090e1631 --- /dev/null +++ b/tdehtml/rendering/render_text.cpp @@ -0,0 +1,1546 @@ +/** + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +//#define DEBUG_LAYOUT +//#define BIDI_DEBUG + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include "rendering/render_text.h" +#include "rendering/render_canvas.h" +#include "rendering/break_lines.h" +#include "rendering/render_arena.h" +#include "xml/dom_nodeimpl.h" + +#include "misc/loader.h" +#include "misc/helper.h" + +#include <tqbitmap.h> +#include <tqimage.h> +#include <tqpainter.h> +#include <kdebug.h> +#include <kglobal.h> +#include <assert.h> +#include <limits.h> +#include <math.h> + +#ifdef HAVE_ALLOCA_H +// explicitly included for systems that don't provide it in stdlib.h +#include <alloca.h> +#else +#include <stdlib.h> +#endif + +using namespace tdehtml; +using namespace DOM; + +#ifndef NDEBUG +static bool inInlineTextBoxDetach; +#endif + +void InlineTextBox::detach(RenderArena* renderArena) +{ + if (m_parent) + m_parent->removeFromLine(this); + +#ifndef NDEBUG + inInlineTextBoxDetach = true; +#endif + delete this; +#ifndef NDEBUG + inInlineTextBoxDetach = false; +#endif + + // Recover the size left there for us by operator delete and free the memory. + renderArena->free(*(size_t *)this, this); +} + +void* InlineTextBox::operator new(size_t sz, RenderArena* renderArena) throw() +{ + return renderArena->allocate(sz); +} + +void InlineTextBox::operator delete(void* ptr, size_t sz) +{ + assert(inInlineTextBoxDetach); + + // Stash size where detach can find it. + *(size_t *)ptr = sz; +} + +void InlineTextBox::selectionStartEnd(int& sPos, int& ePos) +{ + int startPos, endPos; + if (object()->selectionState() == RenderObject::SelectionInside) { + startPos = 0; + endPos = renderText()->string()->l; + } else { + renderText()->selectionStartEnd(startPos, endPos); + if (object()->selectionState() == RenderObject::SelectionStart) + endPos = renderText()->string()->l; + else if (object()->selectionState() == RenderObject::SelectionEnd) + startPos = 0; + } + + sPos = kMax(startPos - m_start, 0); + ePos = kMin(endPos - m_start, (int)m_len); +} + +RenderObject::SelectionState InlineTextBox::selectionState() +{ + RenderObject::SelectionState state = object()->selectionState(); + if (state == RenderObject::SelectionStart || state == RenderObject::SelectionEnd || + state == RenderObject::SelectionBoth) { + int startPos, endPos; + renderText()->selectionStartEnd(startPos, endPos); + + bool start = (state != RenderObject::SelectionEnd && startPos >= m_start && startPos < m_start + m_len); + bool end = (state != RenderObject::SelectionStart && endPos > m_start && endPos <= m_start + m_len); + if (start && end) + state = RenderObject::SelectionBoth; + else if (start) + state = RenderObject::SelectionStart; + else if (end) + state = RenderObject::SelectionEnd; + else if ((state == RenderObject::SelectionEnd || startPos < m_start) && + (state == RenderObject::SelectionStart || endPos > m_start + m_len)) + state = RenderObject::SelectionInside; + } + return state; +} + +void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty) +{ + if (object()->isBR() || object()->style()->visibility() != VISIBLE || + m_truncation == cFullTruncation || i.phase == PaintActionOutline) + return; + + if (i.phase == PaintActionSelection && object()->selectionState() == RenderObject::SelectionNone) + // When only painting the selection, don't bother to paint if there is none. + return; + + int xPos = tx + m_x; + int w = width(); + if ((xPos >= i.r.x() + i.r.width()) || (xPos + w <= i.r.x())) + return; + + // Set our font. + RenderStyle* styleToUse = object()->style(m_firstLine); + int d = styleToUse->textDecorationsInEffect(); + if (styleToUse->font() != i.p->font()) + i.p->setFont(styleToUse->font()); + const Font *font = &styleToUse->htmlFont(); + bool haveSelection = selectionState() != RenderObject::SelectionNone; + + // Now calculate startPos and endPos, for painting selection. + // We paint selection while endPos > 0 + int ePos = 0, sPos = 0; + if (haveSelection && !object()->canvas()->staticMode()) { + selectionStartEnd(sPos, ePos); + } + if (styleToUse->color() != i.p->pen().color()) + i.p->setPen(styleToUse->color()); + + if (m_len > 0 && i.phase != PaintActionSelection) { + int endPoint = m_len; + if (m_truncation != cNoTruncation) + endPoint = m_truncation - m_start; + if (styleToUse->textShadow()) + paintShadow(i.p, font, tx, ty, styleToUse->textShadow()); + if (!haveSelection || sPos != 0 || ePos != m_len) { + font->drawText(i.p, m_x + tx, m_y + ty + m_baseline, renderText()->string()->s, renderText()->string()->l, m_start, endPoint, + m_toAdd, m_reversed ? TQPainter::RTL : TQPainter::LTR); + } + } + + if (d != TDNONE && i.phase != PaintActionSelection && styleToUse->htmlHacks()) { + i.p->setPen(styleToUse->color()); + paintDecoration(i.p, font, tx, ty, d); + } + + if (haveSelection && i.phase == PaintActionSelection) { + //kdDebug(6040) << this << " paintSelection with startPos=" << sPos << " endPos=" << ePos << endl; + if ( sPos < ePos ) + paintSelection(font, renderText(), i.p, styleToUse, tx, ty, sPos, ePos, d); + } +} + +/** returns the proper ::selection pseudo style for the given element + * @return the style or 0 if no ::selection pseudo applies. + */ +inline const RenderStyle *retrieveSelectionPseudoStyle(const RenderObject *obj) +{ + // http://www.w3.org/Style/CSS/Test/CSS3/Selectors/20021129/html/tests/css3-modsel-162.html + // is of the opinion that ::selection of parent elements is also to be applied + // to children, so let's do it. + while (obj) { + const RenderStyle *style = obj->style()->getPseudoStyle(RenderStyle::SELECTION); + if (style) return style; + + obj = obj->parent(); + }/*wend*/ + return 0; +} + +void InlineTextBox::paintSelection(const Font *f, RenderText *text, TQPainter *p, RenderStyle* style, int tx, int ty, int startPos, int endPos, int deco) +{ + if(startPos > m_len) return; + if(startPos < 0) startPos = 0; + + TQColor hc; + TQColor hbg; + const RenderStyle* pseudoStyle = retrieveSelectionPseudoStyle(text); + if (pseudoStyle) { + // ### support outline (mandated by CSS3) + // ### support background-image? (optional by CSS3) + if (pseudoStyle->backgroundColor().isValid()) + hbg = pseudoStyle->backgroundColor(); + hc = pseudoStyle->color(); + } else { + const TQColorGroup &grp = style->palette().active(); + hc = grp.highlightedText(); + hbg = grp.highlight(); + // ### should be at most retrieved once per render text + TQColor bg = tdehtml::retrieveBackgroundColor(text); + // It may happen that the contrast is -- well -- virtually non existent. + // In this case, simply swap the colors, thus in compliance with + // NN4 (win32 only), IE, and Mozilla. + if (!tdehtml::hasSufficientContrast(hbg, bg)) + tqSwap(hc, hbg); + } + + p->setPen(hc); + + //kdDebug( 6040 ) << "textRun::painting(" << TQConstString(text->str->s + m_start, m_len).string().left(30) << ") at(" << m_x+tx << "/" << m_y+ty << ")" << endl; + + const bool needClipping = startPos != 0 || endPos != m_len; + + if (needClipping) { + p->save(); + + int visualSelectionStart = f->width(text->str->s, text->str->l, m_start, startPos, m_start, m_start + m_len, m_toAdd); + int visualSelectionEnd = f->width(text->str->s, text->str->l, m_start, endPos, m_start, m_start + m_len, m_toAdd); + int visualSelectionWidth = visualSelectionEnd - visualSelectionStart; + if (m_reversed) { + visualSelectionStart = f->width(text->str->s, text->str->l, m_start, m_len) - visualSelectionEnd; + } + + TQRect selectionRect(m_x + tx + visualSelectionStart, m_y + ty, visualSelectionWidth, height()); + TQRegion r(selectionRect); + if (p->hasClipping()) + r &= p->clipRegion(TQPainter::CoordPainter); + p->setClipRegion(r, TQPainter::CoordPainter); + } + + f->drawText(p, m_x + tx, m_y + ty + m_baseline, text->str->s, text->str->l, + m_start, m_len, m_toAdd, + m_reversed ? TQPainter::RTL : TQPainter::LTR, + needClipping ? 0 : startPos, needClipping ? m_len : endPos, + hbg, m_y + ty, height(), deco); + + if (needClipping) p->restore(); +} + +void InlineTextBox::paintDecoration( TQPainter *pt, const Font *f, int _tx, int _ty, int deco) +{ + _tx += m_x; + _ty += m_y; + + if (m_truncation == cFullTruncation) + return; + + int width = m_width - 1; + if (m_truncation != cNoTruncation) { + width = static_cast<RenderText*>(m_object)->width(m_start, m_truncation - m_start, m_firstLine); + } + + RenderObject *p = object(); + + TQColor underline, overline, linethrough; + p->getTextDecorationColors(deco, underline, overline, linethrough, p->style()->htmlHacks()); + + if(deco & UNDERLINE){ + pt->setPen(underline); + f->drawDecoration(pt, _tx, _ty, baseline(), width, height(), Font::UNDERLINE); + } + if (deco & OVERLINE) { + pt->setPen(overline); + f->drawDecoration(pt, _tx, _ty, baseline(), width, height(), Font::OVERLINE); + } + if(deco & LINE_THROUGH) { + pt->setPen(linethrough); + f->drawDecoration(pt, _tx, _ty, baseline(), width, height(), Font::LINE_THROUGH); + } + // NO! Do NOT add BLINK! It is the most annouing feature of Netscape, and IE has a reason not to + // support it. Lars +} + +void InlineTextBox::paintShadow(TQPainter *pt, const Font *f, int _tx, int _ty, const ShadowData *shadow ) +{ + int x = m_x + _tx + shadow->x; + int y = m_y + _ty + shadow->y; + const RenderText* text = renderText(); + + if (shadow->blur <= 0) { + TQColor c = pt->pen().color(); + pt->setPen(shadow->color); + f->drawText(pt, x, y+m_baseline, text->str->s, text->str->l, + m_start, m_len, m_toAdd, + m_reversed ? TQPainter::RTL : TQPainter::LTR); + pt->setPen(c); + + } + else { + const int thickness = shadow->blur; + const int w = m_width+2*thickness; + const int h = m_height+2*thickness; + const TQRgb color = shadow->color.rgb(); + const int gray = tqGray(color); + const bool inverse = (gray < 100); + const TQRgb bgColor = (inverse) ? tqRgb(255,255,255) : tqRgb(0,0,0); + TQPixmap pixmap(w, h); + pixmap.fill(bgColor); + TQPainter p; + + p.begin(&pixmap); + p.setPen(shadow->color); + p.setFont(pt->font()); + f->drawText(&p, thickness, thickness+m_baseline, text->str->s, text->str->l, + m_start, m_len, m_toAdd, + m_reversed ? TQPainter::RTL : TQPainter::LTR); + + p.end(); + TQImage img = TQT_TQIMAGE_OBJECT(pixmap.convertToImage()).convertDepth(32); + + int md = thickness*thickness; // max-dist^2 + + // blur map (division cache) + float *bmap = (float*)alloca(sizeof(float)*(md+1)); + for(int n=0; n<=md; n++) { + float f; + f = n/(float)(md+1); + f = 1.0 - f*f; + bmap[n] = f; + } + + float factor = 0.0; // maximal potential opacity-sum + for(int n=-thickness; n<=thickness; n++) + for(int m=-thickness; m<=thickness; m++) { + int d = n*n+m*m; + if (d<=md) + factor += bmap[d]; + } + + // arbitratry factor adjustment to make shadows solid. + factor = factor/1.333; + + // alpha map + float* amap = (float*)alloca(sizeof(float)*(h*w)); + memset(amap, 0, h*w*(sizeof(float))); + for(int j=thickness; j<h-thickness; j++) { + for(int i=thickness; i<w-thickness; i++) { + TQRgb col= img.pixel(i,j); + if (col == bgColor) continue; + float g = tqGray(col); + if (inverse) + g = (255-g)/(255-gray); + else + g = g/gray; + for(int n=-thickness; n<=thickness; n++) { + for(int m=-thickness; m<=thickness; m++) { + int d = n*n+m*m; + if (d>md) continue; + float f = bmap[d]; + amap[(i+m)+(j+n)*w] += (g*f); + } + } + } + } + + TQImage res(w,h,32); + res.setAlphaBuffer(true); + int r = tqRed(color); + int g = tqGreen(color); + int b = tqBlue(color); + + // divide by factor + factor = 1.0/factor; + + for(int j=0; j<h; j++) { + for(int i=0; i<w; i++) { + int a = (int)(amap[i+j*w] * factor * 255.0); + if (a > 255) a = 255; + res.setPixel(i,j, tqRgba(r,g,b,a)); + } + } + + pt->drawImage(x-thickness, y-thickness, res, 0, 0, -1, -1, Qt::DiffuseAlphaDither | Qt::ColorOnly | Qt::PreferDither); + } + // Paint next shadow effect + if (shadow->next) paintShadow(pt, f, _tx, _ty, shadow->next); +} + +/** + * Distributes pixels to justify text. + * @param numSpaces spaces left, will be decremented by one + * @param toAdd number of pixels left to be distributed, will have the + * amount of pixels distributed during this call subtracted. + * @return number of pixels to distribute + */ +static inline int justifyWidth(int &numSpaces, int &toAdd) { + int a = 0; + if ( numSpaces ) { + a = toAdd/numSpaces; + toAdd -= a; + numSpaces--; + }/*end if*/ + return a; +} + +FindSelectionResult InlineTextBox::checkSelectionPoint(int _x, int _y, int _tx, int _ty, const Font *f, RenderText *text, int & offset, short lineHeight) +{ +// kdDebug(6040) << "InlineTextBox::checkSelectionPoint " << this << " _x=" << _x << " _y=" << _y +// << " _tx+m_x=" << _tx+m_x << " _ty+m_y=" << _ty+m_y << endl; + offset = 0; + + if ( _y < _ty + m_y ) + return SelectionPointBefore; // above -> before + + if ( _y > _ty + m_y + lineHeight ) { + // below -> after + // Set the offset to the max + offset = m_len; + return SelectionPointAfter; + } + if ( _x > _tx + m_x + m_width ) { + // to the right + return SelectionPointAfterInLine; + } + + // The Y matches, check if we're on the left + if ( _x < _tx + m_x ) { + return SelectionPointBeforeInLine; + } + + // consider spacing for justified text + int toAdd = m_toAdd; + bool justified = text->style()->textAlign() == JUSTIFY && toAdd > 0; + int numSpaces = 0; + if (justified) { + + for( int i = 0; i < m_len; i++ ) + if ( text->str->s[m_start+i].category() == TQChar::Separator_Space ) + numSpaces++; + + }/*end if*/ + + int delta = _x - (_tx + m_x); + //kdDebug(6040) << "InlineTextBox::checkSelectionPoint delta=" << delta << endl; + int pos = 0; + if ( m_reversed ) { + delta -= m_width; + while(pos < m_len) { + int w = f->width( text->str->s, text->str->l, m_start + pos); + if (justified && text->str->s[m_start + pos].category() == TQChar::Separator_Space) + w += justifyWidth(numSpaces, toAdd); + int w2 = w/2; + w -= w2; + delta += w2; + if(delta >= 0) break; + pos++; + delta += w; + } + } else { + while(pos < m_len) { + int w = f->width( text->str->s, text->str->l, m_start + pos); + if (justified && text->str->s[m_start + pos].category() == TQChar::Separator_Space) + w += justifyWidth(numSpaces, toAdd); + int w2 = w/2; + w -= w2; + delta -= w2; + if(delta <= 0) break; + pos++; + delta -= w; + } + } +// kdDebug( 6040 ) << " Text --> inside at position " << pos << endl; + offset = pos; + return SelectionPointInside; +} + +int InlineTextBox::offsetForPoint(int _x, int &ax) const +{ + // Do binary search for finding out offset, saves some time for long + // runs. + int start = 0; + int end = m_len; + ax = m_x; + int offset = (start + end) / 2; + while (end - start > 0) { + // always snap to the right column. This makes up for "jumpy" vertical + // navigation. + if (end - start == 1) start = end; + + offset = (start + end) / 2; + ax = m_x + widthFromStart(offset); + if (ax > _x) end = offset; + else if (ax < _x) start = offset; + else break; + } + return m_start + offset; +} + +int InlineTextBox::widthFromStart(int pos) const +{ + // gasp! sometimes pos is i < 0 which crashes Font::width + pos = kMax(pos, 0); + + const RenderText *t = renderText(); + Q_ASSERT(t->isText()); + const Font *f = t->htmlFont(m_firstLine); + const TQFontMetrics &fm = t->fontMetrics(m_firstLine); + + int numSpaces = 0; + // consider spacing for justified text + bool justified = t->style()->textAlign() == JUSTIFY; + //kdDebug(6000) << "InlineTextBox::width(int)" << endl; + if (justified && m_toAdd > 0) do { + //kdDebug(6000) << "justify" << endl; + +// TQConstString cstr = TQConstString(t->str->s + m_start, m_len); + for( int i = 0; i < m_len; i++ ) + if ( t->str->s[m_start+i].category() == TQChar::Separator_Space ) + numSpaces++; + if (numSpaces == 0) break; + + int toAdd = m_toAdd; + int w = 0; // accumulated width + int start = 0; // start of non-space sequence + int current = 0; // current position + while (current < pos) { + // add spacing + while (current < pos && t->str->s[m_start + current].category() == TQChar::Separator_Space) { + w += f->getWordSpacing(); + w += f->getLetterSpacing(); + w += justifyWidth(numSpaces, toAdd); + w += fm.width(' '); // ### valid assumption? (LS) + current++; start++; + }/*wend*/ + if (current >= pos) break; + + // seek next space + while (current < pos && t->str->s[m_start + current].category() != TQChar::Separator_Space) + current++; + + // check run without spaces + if ( current > start ) { + w += f->width(t->str->s + m_start, m_len, start, current - start); + start = current; + } + } + + return w; + + } while(false);/*end if*/ + + //kdDebug(6000) << "default" << endl; + // else use existing width function + return f->width(t->str->s + m_start, m_len, 0, pos); + +} + +long InlineTextBox::minOffset() const +{ + return m_start; +} + +long InlineTextBox::maxOffset() const +{ + return m_start + m_len; +} + +int InlineTextBox::placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool& foundBox) +{ + if (foundBox) { + m_truncation = cFullTruncation; + return -1; + } + + int ellipsisX = ltr ? blockEdge - ellipsisWidth : blockEdge + ellipsisWidth; + + // For LTR, if the left edge of the ellipsis is to the left of our text run, then we are the run that will get truncated. + if (ltr) { + if (ellipsisX <= m_x) { + // Too far. Just set full truncation, but return -1 and let the ellipsis just be placed at the edge of the box. + m_truncation = cFullTruncation; + foundBox = true; + return -1; + } + + if (ellipsisX < m_x + m_width) { + if (m_reversed) + return -1; // FIXME: Support LTR truncation when the last run is RTL someday. + + foundBox = true; + + int ax; + int offset = offsetForPoint(ellipsisX, ax) - 1; + if (offset <= m_start) { + // No characters should be rendered. Set ourselves to full truncation and place the ellipsis at the min of our start + // and the ellipsis edge. + m_truncation = cFullTruncation; + return kMin(ellipsisX, (int)m_x); + } + + // Set the truncation index on the text run. The ellipsis needs to be placed just after the last visible character. + m_truncation = offset; + return widthFromStart(offset - m_start); + } + } + else { + // FIXME: Support RTL truncation someday, including both modes (when the leftmost run on the line is either RTL or LTR) + } + return -1; +} + +// ----------------------------------------------------------------------------- + +InlineTextBoxArray::InlineTextBoxArray() +{ + setAutoDelete(false); +} + +int InlineTextBoxArray::compareItems( Item d1, Item d2 ) +{ + assert(d1); + assert(d2); + + return static_cast<InlineTextBox*>(d1)->m_y - static_cast<InlineTextBox*>(d2)->m_y; +} + +// remove this once TQVector::bsearch is fixed +int InlineTextBoxArray::findFirstMatching(Item d) const +{ + int len = count(); + + if ( !len ) + return -1; + if ( !d ) + return -1; + int n1 = 0; + int n2 = len - 1; + int mid = 0; + bool found = false; + while ( n1 <= n2 ) { + int res; + mid = (n1 + n2)/2; + if ( (*this)[mid] == 0 ) // null item greater + res = -1; + else + res = ((TQGVector*)this)->compareItems( d, (*this)[mid] ); + if ( res < 0 ) + n2 = mid - 1; + else if ( res > 0 ) + n1 = mid + 1; + else { // found it + found = true; + break; + } + } + /* if ( !found ) + return -1; */ + // search to first one equal or bigger + while ( found && (mid > 0) && !((TQGVector*)this)->compareItems(d, (*this)[mid-1]) ) + mid--; + return mid; +} + +// ------------------------------------------------------------------------------------- + +RenderText::RenderText(DOM::NodeImpl* node, DOMStringImpl *_str) + : RenderObject(node) +{ + // init RenderObject attributes + setRenderText(); // our object inherits from RenderText + + m_minWidth = -1; + m_maxWidth = -1; + str = _str; + if(str) str->ref(); + KHTMLAssert(!str || !str->l || str->s); + + m_selectionState = SelectionNone; + m_hasReturn = true; + +#ifdef DEBUG_LAYOUT + TQConstString cstr(str->s, str->l); + kdDebug( 6040 ) << "RenderText ctr( "<< cstr.string().length() << " ) '" << cstr.string() << "'" << endl; +#endif +} + +void RenderText::setStyle(RenderStyle *_style) +{ + if ( style() != _style ) { + bool changedText = ((!style() && ( _style->textTransform() != TTNONE || + !_style->preserveLF() || !_style->preserveWS() )) || + (style() && (style()->textTransform() != _style->textTransform() || + style()->whiteSpace() != _style->whiteSpace()))); + + RenderObject::setStyle( _style ); + m_lineHeight = RenderObject::lineHeight(false); + + if (!isBR() && changedText) { + DOM::DOMStringImpl* textToTransform = originalString(); + if (textToTransform) + setText(textToTransform, true); + } + } +} + +RenderText::~RenderText() +{ + KHTMLAssert(m_lines.count() == 0); + if(str) str->deref(); +} + +void RenderText::deleteInlineBoxes(RenderArena* arena) +{ + // this is a slight variant of TQArray::clear(). + // We don't delete the array itself here because its + // likely to be used in the same size later again, saves + // us resize() calls + unsigned int len = m_lines.size(); + if (len) { + if (!arena) + arena = renderArena(); + for(unsigned int i=0; i < len; i++) { + InlineTextBox* s = m_lines.at(i); + if (s) + s->detach(arena); + m_lines.remove(i); + } + } + + KHTMLAssert(m_lines.count() == 0); +} + +bool RenderText::isTextFragment() const +{ + return false; +} + +DOM::DOMStringImpl* RenderText::originalString() const +{ + return element() ? element()->string() : 0; +} + +InlineTextBox * RenderText::findInlineTextBox( int offset, int &pos, bool checkFirstLetter ) +{ + // The text boxes point to parts of the rendertext's str string + // (they don't include '\n') + // Find the text box that includes the character at @p offset + // and return pos, which is the position of the char in the run. + + // FIXME: make this use binary search? Dirk says it won't work :-( (LS) + (void)checkFirstLetter; +#if 0 + if (checkFirstLetter && forcedMinOffset()) { +// kdDebug(6040) << "checkFirstLetter: forcedMinOffset: " << forcedMinOffset() << endl; + RenderFlow *firstLetter = static_cast<RenderFlow *>(previousSibling()); + if (firstLetter && firstLetter->isFlow() && firstLetter->isFirstLetter()) { + RenderText *letterText = static_cast<RenderText *>(firstLetter->firstChild()); + //kdDebug(6040) << "lettertext: " << letterText << " minOfs: " << letterText->minOffset() << " maxOfs: " << letterText->maxOffset() << endl; + if (offset >= letterText->minOffset() && offset <= letterText->maxOffset()) { + InlineTextBox *result = letterText->findInlineTextBox(offset, pos, false); + //kdDebug(6040) << "result: " << result << endl; + if (result) return result; + } + } + } +#endif + + if ( m_lines.isEmpty() ) + return 0L; + + // The text boxes don't resemble a contiguous coverage of the text, there + // may be holes. Therefore, we snap to the nearest previous text box if + // the given offset happens to point to such a hole. + + InlineTextBox* s = m_lines[0]; + uint count = m_lines.count(); + uint si = 0; + uint nearest_idx = 0; // index of nearest text box + int nearest = INT_MAX; // nearest distance +//kdDebug(6040) << "s[" << si << "] m_start " << s->m_start << " m_end " << (s->m_start + s->m_len) << endl; + while(!(offset >= s->m_start && offset <= s->m_start + s->m_len) + && ++si < count) + { + int dist = offset - (s->m_start + s->m_len); +//kdDebug(6040) << "dist " << dist << " nearest " << nearest << endl; + if (dist >= 0 && dist <= nearest) { + nearest = dist; + nearest_idx = si - 1; + }/*end if*/ + s = m_lines[si]; +//kdDebug(6040) << "s[" << si << "] m_start " << s->m_start << " m_end " << (s->m_start + s->m_len) << endl; + } +//kdDebug(6040) << "nearest_idx " << nearest_idx << " count " << count << endl; + if (si >= count) s = m_lines[nearest_idx]; + // we are now in the correct text box + pos = kMin(offset - s->m_start, int( s->m_len )); + //kdDebug(6040) << "offset=" << offset << " s->m_start=" << s->m_start << endl; + return s; +} + +bool RenderText::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction /*hitTestAction*/, bool /*inBox*/) +{ + assert(parent()); + + bool inside = false; + if (style()->visibility() != HIDDEN) { + InlineTextBox *s = m_lines.count() ? m_lines[0] : 0; + int si = 0; + while(s) { + if((_y >=_ty + s->m_y) && (_y < _ty + s->m_y + s->m_height) && + (_x >= _tx + s->m_x) && (_x <_tx + s->m_x + s->m_width) ) { + inside = true; + break; + } + + s = si < (int) m_lines.count()-1 ? m_lines[++si] : 0; + } + } + + // #### ported over from Safari. Can this happen at all? (lars) + + if (inside && element()) { + if (info.innerNode() && info.innerNode()->renderer() && + !info.innerNode()->renderer()->isInline()) { + // Within the same layer, inlines are ALWAYS fully above blocks. Change inner node. + info.setInnerNode(element()); + + // Clear everything else. + info.setInnerNonSharedNode(0); + info.setURLElement(0); + } + + if (!info.innerNode()) + info.setInnerNode(element()); + + if(!info.innerNonSharedNode()) + info.setInnerNonSharedNode(element()); + } + + return inside; +} + +FindSelectionResult RenderText::checkSelectionPoint(int _x, int _y, int _tx, int _ty, DOM::NodeImpl*& node, int &offset, SelPointState &) +{ +// kdDebug(6040) << "RenderText::checkSelectionPoint " << this << " _x=" << _x << " _y=" << _y +// << " _tx=" << _tx << " _ty=" << _ty << endl; +//kdDebug(6040) << renderName() << "::checkSelectionPoint x=" << xPos() << " y=" << yPos() << " w=" << width() << " h=" << height() << " m_lines.count=" << m_lines.count() << endl; + + NodeImpl *lastNode = 0; + int lastOffset = 0; + FindSelectionResult lastResult = SelectionPointAfter; + + for(unsigned int si = 0; si < m_lines.count(); si++) + { + InlineTextBox* s = m_lines[si]; + FindSelectionResult result; + const Font *f = htmlFont( si==0 ); + result = s->checkSelectionPoint(_x, _y, _tx, _ty, f, this, offset, m_lineHeight); + +// kdDebug(6040) << "RenderText::checkSelectionPoint " << this << " line " << si << " result=" << result << " offset=" << offset << endl; + if ( result == SelectionPointInside ) // x,y is inside the textrun + { + offset += s->m_start; // add the offset from the previous lines +// kdDebug(6040) << "RenderText::checkSelectionPoint inside -> " << offset << endl; + node = element(); + return SelectionPointInside; + } else if ( result == SelectionPointBefore ) { + if (!lastNode) { + // x,y is before the textrun -> stop here + offset = 0; +// kdDebug(6040) << "RenderText::checkSelectionPoint " << this << "before us -> returning Before" << endl; + node = element(); + return SelectionPointBefore; + } + } else if ( result == SelectionPointBeforeInLine ) { + offset = s->m_start; + node = element(); + return SelectionPointInside; + } else if ( result == SelectionPointAfterInLine ) { + lastOffset = s->m_start + s->m_len; + lastNode = element(); + lastResult = result; + // no return here + } + + } + + if (lastNode) { + offset = lastOffset; + node = lastNode; +// kdDebug(6040) << "RenderText::checkSelectionPoint: lastNode " << lastNode << " lastOffset " << lastOffset << endl; + return lastResult; + } + + // set offset to max + offset = str->l; + //tqDebug("setting node to %p", element()); + node = element(); +// kdDebug(6040) << "RenderText::checkSelectionPoint: node " << node << " offset " << offset << endl; + return SelectionPointAfter; +} + +void RenderText::caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height) +{ + if (!m_lines.count()) { + _x = _y = height = -1; + width = 1; + return; + } + + int pos; + InlineTextBox * s = findInlineTextBox( offset, pos, true ); + RenderText *t = s->renderText(); +// kdDebug(6040) << "offset="<<offset << " pos="<<pos << endl; + + const TQFontMetrics &fm = t->metrics( s->m_firstLine ); + height = fm.height(); // s->m_height; + + _x = s->m_x + s->widthFromStart(pos); + _y = s->m_y + s->baseline() - fm.ascent(); + width = 1; + if (flags & CFOverride) { + width = offset < maxOffset() ? fm.width(str->s[offset]) : 1; + }/*end if*/ +#if 0 + kdDebug(6040) << "_x="<<_x << " s->m_x="<<s->m_x + << " s->m_start"<<s->m_start + << " s->m_len" << s->m_len << " _y=" << _y << endl; +#endif + + int absx, absy; + + if (absolutePosition(absx,absy)) + { + //kdDebug(6040) << "absx=" << absx << " absy=" << absy << endl; + _x += absx; + _y += absy; + } else { + // we don't know our absolute position, and there is no point returning + // just a relative one + _x = _y = -1; + } +} + +long RenderText::minOffset() const +{ + if (!m_lines.count()) return 0; + // FIXME: it is *not* guaranteed that the first run contains the lowest offset + // Either make this a linear search (slow), + // or maintain an index (needs much mem), + // or calculate and store it in bidi.cpp (needs calculation even if not needed) + // (LS) + return m_lines[0]->m_start; +} + +long RenderText::maxOffset() const +{ + int count = m_lines.count(); + if (!count) return str->l; + // FIXME: it is *not* guaranteed that the last run contains the highest offset + // Either make this a linear search (slow), + // or maintain an index (needs much mem), + // or calculate and store it in bidi.cpp (needs calculation even if not needed) + // (LS) + return m_lines[count - 1]->m_start + m_lines[count - 1]->m_len; +} + +bool RenderText::absolutePosition(int &xPos, int &yPos, bool) const +{ + return RenderObject::absolutePosition(xPos, yPos, false); +} + +bool RenderText::posOfChar(int chr, int &x, int &y) +{ + if (!parent()) + return false; + parent()->absolutePosition( x, y, false ); + + int pos; + InlineTextBox * s = findInlineTextBox( chr, pos ); + + if ( s ) { + // s is the line containing the character + x += s->m_x; // this is the x of the beginning of the line, but it's good enough for now + y += s->m_y; + return true; + } + + return false; +} + +void RenderText::paint( PaintInfo& /*pI*/, int /*tx*/, int /*ty*/) +{ + KHTMLAssert( false ); +} + +void RenderText::calcMinMaxWidth() +{ + KHTMLAssert( !minMaxKnown() ); + + // ### calc Min and Max width... + m_minWidth = m_beginMinWidth = m_endMinWidth = 0; + m_maxWidth = 0; + + if (isBR()) + return; + + int currMinWidth = 0; + int currMaxWidth = 0; + m_hasBreakableChar = m_hasBreak = m_hasBeginWS = m_hasEndWS = false; + + // ### not 100% correct for first-line + const Font *f = htmlFont( false ); + int wordSpacing = style()->wordSpacing(); + int len = str->l; + bool isSpace = false; + bool firstWord = true; + bool firstLine = true; + for(int i = 0; i < len; i++) + { + unsigned short c = str->s[i].unicode(); + bool isNewline = false; + + // If line-breaks survive to here they are preserved + if ( c == '\n' ) { + m_hasBreak = true; + isNewline = true; + isSpace = false; + } else + isSpace = c == ' '; + + if ((isSpace || isNewline) && i == 0) + m_hasBeginWS = true; + if ((isSpace || isNewline) && i == len-1) + m_hasEndWS = true; + + if (i && c == SOFT_HYPHEN) + continue; + + int wordlen = 0; + while( i+wordlen < len && (i+wordlen == 0 || str->s[i+wordlen].unicode() != SOFT_HYPHEN) && + !(isBreakable( str->s, i+wordlen, str->l )) ) + wordlen++; + + if (wordlen) + { +#ifndef APPLE_CHANGES + int w = f->width(str->s, str->l, i, wordlen); +#else + int w = widthFromCache(f, i, wordlen); +#endif + currMinWidth += w; + currMaxWidth += w; + + // Add in wordspacing to our maxwidth, but not if this is the last word. + if (wordSpacing && !containsOnlyWhitespace(i+wordlen, len-(i+wordlen))) + currMaxWidth += wordSpacing; + + if (firstWord) { + firstWord = false; + m_beginMinWidth = w; + } + m_endMinWidth = w; + + if(currMinWidth > m_minWidth) m_minWidth = currMinWidth; + currMinWidth = 0; + + i += wordlen-1; + } + else { + // Nowrap can never be broken, so don't bother setting the + // breakable character boolean. Pre can only be broken if we encounter a newline. + if (style()->autoWrap() || isNewline) + m_hasBreakableChar = true; + + if(currMinWidth > m_minWidth) m_minWidth = currMinWidth; + currMinWidth = 0; + + if (isNewline) // Only set if isPre was true and we saw a newline. + { + if ( firstLine ) { + firstLine = false; + m_beginMinWidth = currMaxWidth; + } + + if(currMaxWidth > m_maxWidth) m_maxWidth = currMaxWidth; + currMaxWidth = 0; + } + else + { + currMaxWidth += f->width( str->s, str->l, i + wordlen ); + } + } + } + + if(currMinWidth > m_minWidth) m_minWidth = currMinWidth; + if(currMaxWidth > m_maxWidth) m_maxWidth = currMaxWidth; + + if (!style()->autoWrap()) { + m_minWidth = m_maxWidth; + if (style()->preserveLF()) { + if (firstLine) + m_beginMinWidth = m_maxWidth; + m_endMinWidth = currMaxWidth; + } + } + + setMinMaxKnown(); + //kdDebug( 6040 ) << "Text::calcMinMaxWidth(): min = " << m_minWidth << " max = " << m_maxWidth << endl; + +} + +int RenderText::minXPos() const +{ + if (!m_lines.count()) + return 0; + int retval=6666666; + for (unsigned i=0;i < m_lines.count(); i++) + { + retval = kMin ( retval, int( m_lines[i]->m_x )); + } + return retval; +} + +int RenderText::inlineXPos() const +{ + return minXPos(); +} + +int RenderText::inlineYPos() const +{ + return m_lines.isEmpty() ? 0 : m_lines[0]->yPos(); +} + +const TQFont &RenderText::font() +{ + return style()->font(); +} + +void RenderText::setText(DOMStringImpl *text, bool force) +{ + if( !force && str == text ) return; + + DOMStringImpl *oldstr = str; + if(text && style()) + str = text->collapseWhiteSpace(style()->preserveLF(), style()->preserveWS()); + else + str = text; + if(str) str->ref(); + if(oldstr) oldstr->deref(); + + if ( str && style() ) { + oldstr = str; + switch(style()->textTransform()) { + case CAPITALIZE: + { + RenderObject *o; + bool runOnString = false; + + // find previous non-empty text renderer if one exists + for (o = previousRenderer(); o; o = o->previousRenderer()) { + if (!o->isInlineFlow()) { + if (!o->isText()) + break; + + DOMStringImpl *prevStr = static_cast<RenderText*>(o)->string(); + // !prevStr can happen with css like "content:open-quote;" + if (!prevStr) + break; + + if (prevStr->length() == 0) + continue; + TQChar c = (*prevStr)[prevStr->length() - 1]; + if (!c.isSpace()) + runOnString = true; + + break; + } + } + + str = str->capitalize(runOnString); + } + break; + + + + case UPPERCASE: str = str->upper(); break; + case LOWERCASE: str = str->lower(); break; + case NONE: + default:; + } + str->ref(); + oldstr->deref(); + } + + // ### what should happen if we change the text of a + // RenderBR object ? + KHTMLAssert(!isBR() || (str->l == 1 && (*str->s) == '\n')); + KHTMLAssert(!str->l || str->s); + + setNeedsLayoutAndMinMaxRecalc(); +#ifdef BIDI_DEBUG + TQConstString cstr(str->s, str->l); + kdDebug( 6040 ) << "RenderText::setText( " << cstr.string().length() << " ) '" << cstr.string() << "'" << endl; +#endif +} + +int RenderText::height() const +{ + int retval; + if ( m_lines.count() ) + retval = m_lines[m_lines.count()-1]->m_y + m_lineHeight - m_lines[0]->m_y; + else + retval = metrics( false ).height(); + + return retval; +} + +short RenderText::lineHeight( bool firstLine ) const +{ + if ( firstLine ) + return RenderObject::lineHeight( firstLine ); + + return m_lineHeight; +} + +short RenderText::baselinePosition( bool firstLine ) const +{ + const TQFontMetrics &fm = metrics( firstLine ); + return fm.ascent() + + ( lineHeight( firstLine ) - fm.height() ) / 2; +} + +InlineBox* RenderText::createInlineBox(bool, bool isRootLineBox) +{ + KHTMLAssert( !isRootLineBox ); + return new (renderArena()) InlineTextBox(this); +} + +void RenderText::position(InlineBox* box, int from, int len, bool reverse) +{ +//kdDebug(6040) << "position: from="<<from<<" len="<<len<<endl; + // ### should not be needed!!! + // asserts sometimes with pre (that unibw-hamburg testcase). ### find out why + //KHTMLAssert(!(len == 0 || (str->l && len == 1 && *(str->s+from) == '\n') )); + // It is now needed. BRs need text boxes too otherwise caret navigation + // gets stuck (LS) + // if (len == 0 || (str->l && len == 1 && *(str->s+from) == '\n') ) return; + + reverse = reverse && !style()->visuallyOrdered(); + +#ifdef DEBUG_LAYOUT + TQChar *ch = str->s+from; + TQConstString cstr(ch, len); +#endif + + KHTMLAssert(box->isInlineTextBox()); + InlineTextBox *s = static_cast<InlineTextBox *>(box); + s->m_start = from; + s->m_len = len; + s->m_reversed = reverse; + //kdDebug(6040) << "m_start: " << s->m_start << " m_len: " << s->m_len << endl; + + if(m_lines.count() == m_lines.size()) + m_lines.resize(m_lines.size()*2+1); + + m_lines.insert(m_lines.count(), s); + //kdDebug(6040) << this << " " << renderName() << "::position inserted" << endl; +} + +unsigned int RenderText::width(unsigned int from, unsigned int len, bool firstLine) const +{ + if(!str->s || from > str->l ) return 0; + if ( from + len > str->l ) len = str->l - from; + + const Font *f = htmlFont( firstLine ); + return width( from, len, f ); +} + +unsigned int RenderText::width(unsigned int from, unsigned int len, const Font *f) const +{ + if(!str->s || from > str->l ) return 0; + if ( from + len > str->l ) len = str->l - from; + + if ( f == &style()->htmlFont() && from == 0 && len == str->l ) + return m_maxWidth; + + int w = f->width(str->s, str->l, from, len ); + + //kdDebug( 6040 ) << "RenderText::width(" << from << ", " << len << ") = " << w << endl; + return w; +} + +short RenderText::width() const +{ + int w; + int minx = 100000000; + int maxx = 0; + // slooow + for(unsigned int si = 0; si < m_lines.count(); si++) { + InlineTextBox* s = m_lines[si]; + if(s->m_x < minx) + minx = s->m_x; + if(s->m_x + s->m_width > maxx) + maxx = s->m_x + s->m_width; + } + + w = kMax(0, maxx-minx); + + return w; +} + +void RenderText::repaint(Priority p) +{ + RenderObject *cb = containingBlock(); + if(cb) + cb->repaint(p); +} + +bool RenderText::isFixedWidthFont() const +{ + return TQFontInfo(style()->font()).fixedPitch(); +} + +short RenderText::verticalPositionHint( bool firstLine ) const +{ + return parent()->verticalPositionHint( firstLine ); +} + +const TQFontMetrics &RenderText::metrics(bool firstLine) const +{ + if( firstLine && hasFirstLine() ) { + RenderStyle *pseudoStyle = style()->getPseudoStyle(RenderStyle::FIRST_LINE); + if ( pseudoStyle ) + return pseudoStyle->fontMetrics(); + } + return style()->fontMetrics(); +} + +const Font *RenderText::htmlFont(bool firstLine) const +{ + const Font *f = 0; + if( firstLine && hasFirstLine() ) { + RenderStyle *pseudoStyle = style()->getPseudoStyle(RenderStyle::FIRST_LINE); + if ( pseudoStyle ) + f = &pseudoStyle->htmlFont(); + } else { + f = &style()->htmlFont(); + } + return f; +} + +bool RenderText::containsOnlyWhitespace(unsigned int from, unsigned int len) const +{ + unsigned int currPos; + for (currPos = from; + currPos < from+len && (str->s[currPos] == '\n' || str->s[currPos].direction() == TQChar::DirWS); + currPos++); + return currPos >= (from+len); +} + +void RenderText::trimmedMinMaxWidth(short& beginMinW, bool& beginWS, + short& endMinW, bool& endWS, + bool& hasBreakableChar, bool& hasBreak, + short& beginMaxW, short& endMaxW, + short& minW, short& maxW, bool& stripFrontSpaces) +{ + bool preserveWS = style()->preserveWS(); + bool preserveLF = style()->preserveLF(); + bool autoWrap = style()->autoWrap(); + if (preserveWS) + stripFrontSpaces = false; + + int len = str->l; + if (len == 0 || (stripFrontSpaces && str->containsOnlyWhitespace())) { + maxW = 0; + hasBreak = false; + return; + } + + minW = m_minWidth; + maxW = m_maxWidth; + beginWS = stripFrontSpaces ? false : m_hasBeginWS; + endWS = m_hasEndWS; + + beginMinW = m_beginMinWidth; + endMinW = m_endMinWidth; + + hasBreakableChar = m_hasBreakableChar; + hasBreak = m_hasBreak; + + if (stripFrontSpaces && (str->s[0].direction() == TQChar::DirWS || (!preserveLF && str->s[0] == '\n'))) { + const Font *f = htmlFont( false ); + TQChar space[1]; space[0] = ' '; + int spaceWidth = f->width(space, 1, 0); + maxW -= spaceWidth; + } + + stripFrontSpaces = !preserveWS && m_hasEndWS; + + if (!autoWrap) + minW = maxW; + else if (minW > maxW) + minW = maxW; + + // Compute our max widths by scanning the string for newlines. + if (hasBreak) { + const Font *f = htmlFont( false ); + bool firstLine = true; + beginMaxW = endMaxW = maxW; + for(int i = 0; i < len; i++) + { + int linelen = 0; + while( i+linelen < len && str->s[i+linelen] != '\n') + linelen++; + + if (linelen) + { +#ifndef APPLE_CHANGES + endMaxW = f->width(str->s, str->l, i, linelen); +#else + endMaxW = widthFromCache(f, i, linelen); +#endif + if (firstLine) { + firstLine = false; + beginMaxW = endMaxW; + } + i += linelen; + } + else if (firstLine) { + beginMaxW = 0; + firstLine = false; + } + if (i == len-1) + // A <pre> run that ends with a newline, as in, e.g., + // <pre>Some text\n\n<span>More text</pre> + endMaxW = 0; + } + } +} + +#ifdef ENABLE_DUMP + +static TQString quoteAndEscapeNonPrintables(const TQString &s) +{ + TQString result; + result += '"'; + for (uint i = 0; i != s.length(); ++i) { + TQChar c = s.at(i); + if (c == '\\') { + result += "\\\\"; + } else if (c == '"') { + result += "\\\""; + } else { + ushort u = c.unicode(); + if (u >= 0x20 && u < 0x7F) { + result += c; + } else { + TQString hex; + hex.sprintf("\\x{%X}", u); + result += hex; + } + } + } + result += '"'; + return result; +} + +static void writeTextRun(TQTextStream &ts, const RenderText &o, const InlineTextBox &run) +{ + ts << "text run at (" << run.m_x << "," << run.m_y << ") width " << run.m_width << ": " + << quoteAndEscapeNonPrintables(o.data().string().mid(run.m_start, run.m_len)); +} + +void RenderText::dump(TQTextStream &stream, const TQString &ind) const +{ + RenderObject::dump( stream, ind ); + + for (unsigned int i = 0; i < m_lines.count(); i++) { + stream << endl << ind << " "; + writeTextRun(stream, *this, *m_lines[i]); + } +} +#endif + +RenderTextFragment::RenderTextFragment(DOM::NodeImpl* _node, DOM::DOMStringImpl* _str, + int startOffset, int endOffset) +:RenderText(_node, _str->substring(startOffset, endOffset)), +m_start(startOffset), m_end(endOffset), m_generatedContentStr(0) +{} + +RenderTextFragment::RenderTextFragment(DOM::NodeImpl* _node, DOM::DOMStringImpl* _str) +:RenderText(_node, _str), m_start(0) +{ + m_generatedContentStr = _str; + if (_str) { + _str->ref(); + m_end = _str->l; + } + else + m_end = 0; +} + +RenderTextFragment::~RenderTextFragment() +{ + if (m_generatedContentStr) + m_generatedContentStr->deref(); +} + +bool RenderTextFragment::isTextFragment() const +{ + return true; +} + +DOM::DOMStringImpl* RenderTextFragment::originalString() const +{ + DOM::DOMStringImpl* result = 0; + if (element()) + result = element()->string(); + else + result = contentString(); + if (result && (start() > 0 || start() < result->l)) + result = result->substring(start(), end()); + return result; +} + +#undef BIDI_DEBUG +#undef DEBUG_LAYOUT diff --git a/tdehtml/rendering/render_text.h b/tdehtml/rendering/render_text.h new file mode 100644 index 000000000..acce98350 --- /dev/null +++ b/tdehtml/rendering/render_text.h @@ -0,0 +1,345 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * (C) 1999-2003 Lars Knoll (knoll@kde.org) + * (C) 2000-2003 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef RENDERTEXT_H +#define RENDERTEXT_H + +#include "dom/dom_string.h" +#include "xml/dom_stringimpl.h" +#include "xml/dom_textimpl.h" +#include "rendering/render_object.h" +#include "rendering/render_line.h" + +#include <tqptrvector.h> +#include <assert.h> + +class TQPainter; +class TQFontMetrics; + +// Define a constant for soft hyphen's unicode value. +#define SOFT_HYPHEN 173 + +const int cNoTruncation = -1; +const int cFullTruncation = -2; + +namespace tdehtml +{ + class RenderText; + class RenderStyle; + +class InlineTextBox : public InlineBox +{ +public: + InlineTextBox(RenderObject *obj) + :InlineBox(obj), + // ### necessary as some codepaths (<br>) do *not* initialize these (LS) + m_start(0), m_len(0), m_truncation(cNoTruncation), m_reversed(false), m_toAdd(0) + { + } + + void detach(RenderArena* renderArena); + + virtual void clearTruncation() { m_truncation = cNoTruncation; } + virtual int placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool& foundBox); + + // Overloaded new operator. Derived classes must override operator new + // in order to allocate out of the RenderArena. + void* operator new(size_t sz, RenderArena* renderArena) throw(); + + // Overridden to prevent the normal delete from being called. + void operator delete(void* ptr, size_t sz); + +private: + // The normal operator new is disallowed. + void* operator new(size_t sz) throw(); + +public: + void setSpaceAdd(int add) { m_width -= m_toAdd; m_toAdd = add; m_width += m_toAdd; } + int spaceAdd() { return m_toAdd; } + + virtual bool isInlineTextBox() const { return true; } + + void paint(RenderObject::PaintInfo& i, int tx, int ty); + void paintDecoration(TQPainter *pt, const Font *f, int _tx, int _ty, int decoration); + void paintShadow(TQPainter *pt, const Font* f, int _tx, int _ty, const ShadowData *shadow ); + void paintSelection(const Font *f, RenderText *text, TQPainter *p, RenderStyle* style, int tx, int ty, int startPos, int endPos, int deco); + + void selectionStartEnd(int& sPos, int& ePos); + RenderObject::SelectionState selectionState(); + + // Return before, after (offset set to max), or inside the text, at @p offset + FindSelectionResult checkSelectionPoint(int _x, int _y, int _tx, int _ty, const Font *f, RenderText *text, int & offset, short lineheight); + + bool checkVerticalPoint(int _y, int _ty, int _h, int height) + { if((_ty + m_y > _y + _h) || (_ty + m_y + m_baseline + height < _y)) return false; return true; } + + /** + * determines the offset into the DOMString of the character the given + * coordinate points to. + * The returned offset is never out of range. + * @param _x given coordinate (relative to containing block) + * @param ax returns exact coordinate the offset corresponds to + * (relative to containing block) + * @return the offset (relative to the RenderText object, not to this run) + */ + int offsetForPoint(int _x, int &ax) const; + + /** + * calculates the with of the specified chunk in this text box. + * @param pos zero-based position within the text box up to which + * the width is to be determined + * @return the width in pixels + */ + int widthFromStart(int pos) const; + + /** returns the lowest possible value the caret offset may have to + * still point to a valid position. + */ + virtual long minOffset() const; + /** returns the highest possible value the caret offset may have to + * still point to a valid position. + */ + virtual long maxOffset() const; + + /** returns the associated render text + */ + const RenderText *renderText() const; + RenderText *renderText(); + + int m_start; + unsigned short m_len; + + int m_truncation; // Where to truncate when text overflow is applied. + // We use special constants to denote no truncation (the whole run paints) + // and full truncation (nothing paints at all). + + bool m_reversed : 1; + unsigned m_toAdd : 14; // for justified text +private: + // this is just for TQVector::bsearch. Don't use it otherwise + InlineTextBox(int _x, int _y) + :InlineBox(0) + { + m_x = _x; + m_y = _y; + m_reversed = false; + }; + friend class RenderText; +}; + +class InlineTextBoxArray : public TQPtrVector<InlineTextBox> +{ +public: + InlineTextBoxArray(); + + InlineTextBox* first(); + + int findFirstMatching( Item ) const; + virtual int compareItems( Item, Item ); +}; + +class RenderText : public RenderObject +{ + friend class InlineTextBox; + +public: + RenderText(DOM::NodeImpl* node, DOM::DOMStringImpl *_str); + virtual ~RenderText(); + + virtual bool isTextFragment() const; + virtual DOM::DOMStringImpl* originalString() const; + + virtual const char *renderName() const { return "RenderText"; } + + virtual void setStyle(RenderStyle *style); + + + virtual void paint( PaintInfo& i, int tx, int ty ); + + virtual void deleteInlineBoxes(RenderArena* arena=0); + + DOM::DOMString data() const { return str; } + DOM::DOMStringImpl *string() const { return str; } + + virtual InlineBox* createInlineBox(bool, bool); + + virtual void layout() {assert(false);} + + virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction hitTestAction, bool inBox); + + // Return before, after (offset set to max), or inside the text, at @p offset + virtual FindSelectionResult checkSelectionPoint( int _x, int _y, int _tx, int _ty, + DOM::NodeImpl*& node, int & offset, + SelPointState & ); + + unsigned int length() const { if (str) return str->l; else return 0; } + TQChar *text() const { if (str) return str->s; else return 0; } + unsigned int stringLength() const { return str->l; } // non virtual implementation of length() + virtual void position(InlineBox* box, int from, int len, bool reverse); + + virtual unsigned int width(unsigned int from, unsigned int len, const Font *f) const; + virtual unsigned int width(unsigned int from, unsigned int len, bool firstLine = false) const; + virtual short width() const; + virtual int height() const; + + // height of the contents (without paddings, margins and borders) + virtual short lineHeight( bool firstLine ) const; + virtual short baselinePosition( bool firstLine ) const; + + // overrides + virtual void calcMinMaxWidth(); + virtual short minWidth() const { return m_minWidth; } + virtual int maxWidth() const { return m_maxWidth; } + + void trimmedMinMaxWidth(short& beginMinW, bool& beginWS, + short& endMinW, bool& endWS, + bool& hasBreakableChar, bool& hasBreak, + short& beginMaxW, short& endMaxW, + short& minW, short& maxW, bool& stripFrontSpaces); + + bool containsOnlyWhitespace(unsigned int from, unsigned int len) const; + + ushort startMin() const { return m_startMin; } + ushort endMin() const { return m_endMin; } + + // returns the minimum x position of all runs relative to the parent. + // defaults to 0. + int minXPos() const; + + virtual int inlineXPos() const; + virtual int inlineYPos() const; + + bool hasReturn() const { return m_hasReturn; } + + virtual const TQFont &font(); + virtual short verticalPositionHint( bool firstLine ) const; + + bool isFixedWidthFont() const; + + void setText(DOM::DOMStringImpl *text, bool force=false); + + virtual SelectionState selectionState() const {return m_selectionState;} + virtual void setSelectionState(SelectionState s) {m_selectionState = s; } + virtual void caretPos(int offset, int flags, int &_x, int &_y, int &width, int &height); + virtual bool absolutePosition(int &/*xPos*/, int &/*yPos*/, bool f = false) const; + bool posOfChar(int ch, int &x, int &y); + + virtual short marginLeft() const { return style()->marginLeft().minWidth(0); } + virtual short marginRight() const { return style()->marginRight().minWidth(0); } + + virtual void repaint(Priority p=NormalPriority); + + bool hasBreakableChar() const { return m_hasBreakableChar; } + const TQFontMetrics &metrics(bool firstLine) const; + const Font *htmlFont(bool firstLine) const; + + DOM::TextImpl *element() const + { return static_cast<DOM::TextImpl*>(RenderObject::element()); } + + /** returns the lowest possible value the caret offset may have to + * still point to a valid position. + */ + virtual long minOffset() const; + + /** returns the highest possible value the caret offset may have to + * still point to a valid position. + */ + virtual long maxOffset() const; + + /** returns the number of inline text boxes + */ + unsigned inlineTextBoxCount() const { return m_lines.count(); } + /** returns the array of inline text boxes for this render text. + */ + const InlineTextBoxArray &inlineTextBoxes() const { return m_lines; } + +#ifdef ENABLE_DUMP + virtual void dump(TQTextStream &stream, const TQString &ind) const; +#endif + + /** Find the text box that includes the character at @p offset + * and return pos, which is the position of the char in the run. + * @param offset zero-based offset into DOM string + * @param pos returns relative position within text box + * @param checkFirstLetter passing @p true will also regard :first-letter + * boxes, if available. + * @return the text box, or 0 if no match has been found + */ + InlineTextBox * findInlineTextBox( int offset, int &pos, + bool checkFirstLetter = false ); + +protected: // members + InlineTextBoxArray m_lines; + DOM::DOMStringImpl *str; // + + short m_lineHeight; + short m_minWidth; + int m_maxWidth; + short m_beginMinWidth; + short m_endMinWidth; + + SelectionState m_selectionState : 3 ; + bool m_hasReturn : 1; + bool m_hasBreakableChar : 1; + bool m_hasBreak : 1; + bool m_hasBeginWS : 1; + bool m_hasEndWS : 1; + + ushort m_startMin : 8; + ushort m_endMin : 8; +}; + +inline const RenderText* InlineTextBox::renderText() const +{ return static_cast<RenderText*>( object() ); } + +inline RenderText* InlineTextBox::renderText() +{ return static_cast<RenderText*>( object() ); } + +// Used to represent a text substring of an element, e.g., for text runs that are split because of +// first letter and that must therefore have different styles (and positions in the render tree). +// We cache offsets so that text transformations can be applied in such a way that we can recover +// the original unaltered string from our corresponding DOM node. +class RenderTextFragment : public RenderText +{ +public: + RenderTextFragment(DOM::NodeImpl* _node, DOM::DOMStringImpl* _str, + int startOffset, int endOffset); + RenderTextFragment(DOM::NodeImpl* _node, DOM::DOMStringImpl* _str); + ~RenderTextFragment(); + + virtual bool isTextFragment() const; + virtual const char *renderName() const { return "RenderTextFragment"; } + + uint start() const { return m_start; } + uint end() const { return m_end; } + + DOM::DOMStringImpl* contentString() const { return m_generatedContentStr; } + virtual DOM::DOMStringImpl* originalString() const; + +private: + uint m_start; + uint m_end; + DOM::DOMStringImpl* m_generatedContentStr; +}; +} // end namespace +#endif diff --git a/tdehtml/rendering/table_layout.cpp b/tdehtml/rendering/table_layout.cpp new file mode 100644 index 000000000..eb8153331 --- /dev/null +++ b/tdehtml/rendering/table_layout.cpp @@ -0,0 +1,1193 @@ +/* + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 2002 Lars Knoll (knoll@kde.org) + * (C) 2002 Dirk Mueller (mueller@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#include "table_layout.h" +#include "render_table.h" + +#include <kglobal.h> + +using namespace tdehtml; + +// #define DEBUG_LAYOUT + +/* + The text below is from the CSS 2.1 specs. + + Fixed table layout + ------------------ + + With this (fast) algorithm, the horizontal layout of the table does + not depend on the contents of the cells; it only depends on the + table's width, the width of the columns, and borders or cell + spacing. + + The table's width may be specified explicitly with the 'width' + property. A value of 'auto' (for both 'display: table' and 'display: + inline-table') means use the automatic table layout algorithm. + + In the fixed table layout algorithm, the width of each column is + determined as follows: + + 1. A column element with a value other than 'auto' for the 'width' + property sets the width for that column. + + 2. Otherwise, a cell in the first row with a value other than + 'auto' for the 'width' property sets the width for that column. If + the cell spans more than one column, the width is divided over the + columns. + + 3. Any remaining columns equally divide the remaining horizontal + table space (minus borders or cell spacing). + + The width of the table is then the greater of the value of the + 'width' property for the table element and the sum of the column + widths (plus cell spacing or borders). If the table is wider than + the columns, the extra space should be distributed over the columns. + + + In this manner, the user agent can begin to lay out the table once + the entire first row has been received. Cells in subsequent rows do + not affect column widths. Any cell that has content that overflows + uses the 'overflow' property to determine whether to clip the + overflow content. + +_____________________________________________________ + + This is not quite true when comparing to IE. IE always honors + table-layout:fixed and treats a variable table width as 100%. Makes + a lot of sense, and is implemented here the same way. + +*/ + +FixedTableLayout::FixedTableLayout( RenderTable *table ) + : TableLayout ( table ) +{ +} + +FixedTableLayout::~FixedTableLayout() +{ +} + +int FixedTableLayout::calcWidthArray() +{ + int usedWidth = 0; + + // iterate over all <col> elements + RenderObject *child = table->firstChild(); + int cCol = 0; + int nEffCols = table->numEffCols(); + width.resize( nEffCols ); + width.fill( Length( Variable ) ); + +#ifdef DEBUG_LAYOUT + tqDebug("FixedTableLayout::calcWidthArray()" ); + tqDebug(" col elements:"); +#endif + + Length grpWidth; + while ( child ) { + if ( child->isTableCol() ) { + RenderTableCol *col = static_cast<RenderTableCol *>(child); + int span = col->span(); + if ( col->firstChild() ) { + grpWidth = col->style()->width(); + } else { + Length w = col->style()->width(); + if ( w.isVariable() ) + w = grpWidth; + int effWidth = 0; + if ( w.isFixed() && w.value() > 0 ) { + effWidth = w.value(); + effWidth = KMIN( effWidth, 32760 ); + } +#ifdef DEBUG_LAYOUT + tqDebug(" col element: effCol=%d, span=%d: %d w=%d type=%d", + cCol, span, effWidth, w.value(), w.type()); +#endif + int usedSpan = 0; + int i = 0; + while ( usedSpan < span ) { + if( cCol + i >= nEffCols ) { + table->appendColumn( span - usedSpan ); + nEffCols++; + width.resize( nEffCols ); + width[nEffCols-1] = Length(); + } + int eSpan = table->spanOfEffCol( cCol+i ); + if ( (w.isFixed() || w.isPercent()) && w.value() > 0 ) { + width[cCol+i] = Length( w.value() * eSpan, w.type() ); + usedWidth += effWidth * eSpan; +#ifdef DEBUG_LAYOUT + tqDebug(" setting effCol %d (span=%d) to width %d(type=%d)", + cCol+i, eSpan, width[cCol+i].value(), width[cCol+i].type() ); +#endif + } + usedSpan += eSpan; + i++; + } + cCol += i; + } + } else { + break; + } + + RenderObject *next = child->firstChild(); + if ( !next ) + next = child->nextSibling(); + if ( !next && child->parent()->isTableCol() ) { + next = child->parent()->nextSibling(); + grpWidth = Length(); + } + child = next; + } + +#ifdef DEBUG_LAYOUT + tqDebug(" first row:"); +#endif + // iterate over the first row in case some are unspecified. + RenderTableSection *section = table->head; + if ( !section ) + section = table->firstBody; + if ( !section ) + section = table->foot; + if ( section && section->firstChild() ) { + cCol = 0; + // get the first cell in the first row + child = section->firstChild()->firstChild(); + while ( child ) { + if ( child->isTableCell() ) { + RenderTableCell *cell = static_cast<RenderTableCell *>(child); + Length w = cell->styleOrColWidth(); + int span = cell->colSpan(); + int effWidth = 0; + if ( (w.isFixed() || w.isPercent()) && w.value() > 0 ) { + effWidth = w.value(); + effWidth = kMin( effWidth, 32760 ); + } +#ifdef DEBUG_LAYOUT + tqDebug(" table cell: effCol=%d, span=%d: %d", cCol, span, effWidth); +#endif + int usedSpan = 0; + int i = 0; + while ( usedSpan < span ) { + Q_ASSERT( cCol + i < nEffCols ); + int eSpan = table->spanOfEffCol( cCol+i ); + // only set if no col element has already set it. + if ( width[cCol+i].isVariable() && !w.isVariable() ) { + width[cCol+i] = Length( w.value()*eSpan, w.type() ); + usedWidth += effWidth*eSpan; +#ifdef DEBUG_LAYOUT + tqDebug(" setting effCol %d (span=%d) to width %d(type=%d)", + cCol+i, eSpan, width[cCol+i].value(), width[cCol+i].type() ); +#endif + } +#ifdef DEBUG_LAYOUT + else { + tqDebug(" width of col %d already defined (span=%d)", cCol, table->spanOfEffCol( cCol ) ); + } +#endif + usedSpan += eSpan; + i++; + } + cCol += i; + } else { + Q_ASSERT( false ); + } + child = child->nextSibling(); + } + } + + return usedWidth; + +} + +void FixedTableLayout::calcMinMaxWidth() +{ + // we might want to wait until we have all of the first row before + // layouting for the first time. + + // only need to calculate the minimum width as the sum of the + // cols/cells with a fixed width. + // + // The maximum width is kMax( minWidth, tableWidth ) if table + // width is fixed. If table width is percent, we set maxWidth to + // unlimited. + + int bs = table->bordersPaddingAndSpacing(); + int tableWidth = 0; + if (table->style()->width().isFixed()) { + tableWidth = table->calcBoxWidth(table->style()->width().value()); + } + + int mw = calcWidthArray() + bs; + table->m_minWidth = kMin( kMax( mw, tableWidth ), 0x7fff ); + table->m_maxWidth = table->m_minWidth; + + if ( !tableWidth ) { + bool haveNonFixed = false; + for ( unsigned int i = 0; i < width.size(); i++ ) { + if ( !width[i].isFixed() ) { + haveNonFixed = true; + break; + } + } + if ( haveNonFixed ) + table->m_maxWidth = 0x7fff; + } +#ifdef DEBUG_LAYOUT + tqDebug("FixedTableLayout::calcMinMaxWidth: minWidth=%d, maxWidth=%d", table->m_minWidth, table->m_maxWidth ); +#endif +} + +void FixedTableLayout::layout() +{ + int tableWidth = table->width() - table->bordersPaddingAndSpacing(); + int available = tableWidth; + int nEffCols = table->numEffCols(); +#ifdef DEBUG_LAYOUT + tqDebug("FixedTableLayout::layout: tableWidth=%d, numEffCols=%d", tableWidth, nEffCols); +#endif + + + TQMemArray<int> calcWidth; + calcWidth.resize( nEffCols ); + calcWidth.fill( -1 ); + + // first assign fixed width + for ( int i = 0; i < nEffCols; i++ ) { + if ( width[i].isFixed() ) { + calcWidth[i] = width[i].value(); + available -= width[i].value(); + } + } + + // assign percent width + if ( available > 0 ) { + int totalPercent = 0; + for ( int i = 0; i < nEffCols; i++ ) + if ( width[i].isPercent() ) + totalPercent += width[i].value(); + + // calculate how much to distribute to percent cells. + int base = tableWidth * totalPercent / 100; + if ( base > available ) + base = available; + +#ifdef DEBUG_LAYOUT + tqDebug("FixedTableLayout::layout: assigning percent width, base=%d, totalPercent=%d", base, totalPercent); +#endif + for ( int i = 0; available > 0 && i < nEffCols; i++ ) { + if ( width[i].isPercent() ) { + // totalPercent may be 0 below if all %-width specifed are 0%. (#172557) + int w = totalPercent ? base * width[i].value() / totalPercent : 0; + available -= w; + calcWidth[i] = w; + } + } + } + + // assign variable width + if ( available > 0 ) { + int totalVariable = 0; + for ( int i = 0; i < nEffCols; i++ ) + if ( width[i].isVariable() ) + totalVariable++; + + for ( int i = 0; available > 0 && i < nEffCols; i++ ) { + if ( width[i].isVariable() ) { + // totalVariable may be 0 below if all the variable widths specified are 0. + int w = totalVariable ? available / totalVariable : 0; + available -= w; + calcWidth[i] = w; + totalVariable--; + } + } + } + + for ( int i = 0; i < nEffCols; i++ ) + if ( calcWidth[i] < 0 ) + calcWidth[i] = 0; // IE gives min 1 px... + + // spread extra space over columns + if ( available > 0 ) { + int total = nEffCols; + // still have some width to spread + int i = nEffCols; + while ( i-- ) { + int w = available / total; + available -= w; + total--; + calcWidth[i] += w; + } + } + + int pos = 0; + int hspacing = table->borderHSpacing(); + for ( int i = 0; i < nEffCols; i++ ) { +#ifdef DEBUG_LAYOUT + tqDebug("col %d: %d (width %d)", i, pos, calcWidth[i] ); +#endif + table->columnPos[i] = pos; + pos += calcWidth[i] + hspacing; + } + table->columnPos[table->columnPos.size()-1] = pos; +} + +// ------------------------------------------------------------------------- +// ------------------------------------------------------------------------- + + +AutoTableLayout::AutoTableLayout( RenderTable* table ) + : TableLayout( table ) +{ + percentagesDirty = true; + effWidthDirty = true; + total_percent = 0; + hasPercent = false; +} + +AutoTableLayout::~AutoTableLayout() +{ +} + +/* recalculates the full structure needed to do layouting and minmax calculations. + This is usually calculated on the fly, but needs to be done fully when table cells change + dynamically +*/ +void AutoTableLayout::recalcColumn( int effCol ) +{ + Layout &l = layoutStruct[effCol]; + + RenderObject *child = table->firstChild(); + // first we iterate over all rows. + + RenderTableCell *fixedContributor = 0; + RenderTableCell *maxContributor = 0; + + while ( child ) { + if ( child->isTableSection() ) { + RenderTableSection *section = static_cast<RenderTableSection *>(child); + int numRows = section->numRows(); + RenderTableCell *last = 0; + for ( int i = 0; i < numRows; i++ ) { + RenderTableCell *cell = section->cellAt( i, effCol ); + if ( cell == (RenderTableCell *)-1 ) + continue; + if ( cell && cell->colSpan() == 1 ) { + // A cell originates in this column. Ensure we have + // a min/max width of at least 1px for this column now. + l.minWidth = kMax(int( l.minWidth ), 1); + l.maxWidth = kMax(int( l.maxWidth ), 1); + + if ( !cell->minMaxKnown() ) + cell->calcMinMaxWidth(); + if ( cell->minWidth() > l.minWidth ) + l.minWidth = cell->minWidth(); + if ( cell->maxWidth() > l.maxWidth ) { + l.maxWidth = cell->maxWidth(); + maxContributor = cell; + } + + Length w = cell->styleOrColWidth(); + w.l.value = kMin( 32767, kMax( 0, w.value() ) ); + switch( w.type() ) { + case Fixed: + // ignore width=0 + if ( w.value() > 0 && !l.width.isPercent() ) { + int wval = cell->calcBoxWidth(w.value()); + if ( l.width.isFixed() ) { + // Nav/IE weirdness + if ((wval > l.width.value()) || + ((l.width.value() == wval) && (maxContributor == cell))) { + l.width.l.value = wval; + fixedContributor = cell; + } + } else { + l.width = Length( wval, Fixed ); + fixedContributor = cell; + } + } + break; + case Percent: + hasPercent = true; + if ( w.value() > 0 && (!l.width.isPercent() || w.value() > l.width.value() ) ) + l.width = w; + break; + case Relative: + if ( w.isVariable() || (w.isRelative() && w.value() > l.width.value() ) ) + l.width = w; + default: + break; + } + } else { + if ( cell && (!effCol || section->cellAt( i, effCol-1 ) != cell) ) { + // This spanning cell originates in this column. Ensure we have + // a min/max width of at least 1px for this column now. + l.minWidth = kMax(int( l.minWidth ), 1); + l.maxWidth = kMax(int( l.maxWidth ), 1); + insertSpanCell( cell ); + } + last = cell; + } + } + } + child = child->nextSibling(); + } + + // Nav/IE weirdness + if ( l.width.isFixed() ) { + if ( table->style()->htmlHacks() + && (l.maxWidth > l.width.value()) && (fixedContributor != maxContributor)) { + l.width = Length(); + fixedContributor = 0; + } + } + + l.maxWidth = kMax(l.maxWidth, int(l.minWidth)); +#ifdef DEBUG_LAYOUT + tqDebug("col %d, final min=%d, max=%d, width=%d(%d)", effCol, l.minWidth, l.maxWidth, l.width.value(), l.width.type() ); +#endif + + // ### we need to add col elements aswell +} + + +void AutoTableLayout::fullRecalc() +{ + percentagesDirty = true; + hasPercent = false; + effWidthDirty = true; + + int nEffCols = table->numEffCols(); + layoutStruct.resize( nEffCols ); + layoutStruct.fill( Layout() ); + spanCells.fill( 0 ); + + RenderObject *child = table->firstChild(); + Length grpWidth; + int cCol = 0; + while ( child ) { + if ( child->isTableCol() ) { + RenderTableCol *col = static_cast<RenderTableCol *>(child); + int span = col->span(); + if ( col->firstChild() ) { + grpWidth = col->style()->width(); + } else { + Length w = col->style()->width(); + if ( w.isVariable() ) + w = grpWidth; + if ( (w.isFixed() && w.value() == 0) || + (w.isPercent() && w.value() == 0) ) + w = Length(); + int cEffCol = table->colToEffCol( cCol ); +#ifdef DEBUG_LAYOUT + tqDebug(" col element %d (eff=%d): Length=%d(%d), span=%d, effColSpan=%d", cCol, cEffCol, w.value(), w.type(), span, table->spanOfEffCol(cEffCol ) ); +#endif + if ( !w.isVariable() && span == 1 && cEffCol < nEffCols ) { + if ( table->spanOfEffCol( cEffCol ) == 1 ) { + layoutStruct[cEffCol].width = w; + if (w.isFixed() && layoutStruct[cEffCol].maxWidth < w.value()) + layoutStruct[cEffCol].maxWidth = w.value(); + } + } + cCol += span; + } + } else { + break; + } + + RenderObject *next = child->firstChild(); + if ( !next ) + next = child->nextSibling(); + if ( !next && child->parent()->isTableCol() ) { + next = child->parent()->nextSibling(); + grpWidth = Length(); + } + child = next; + } + + + for ( int i = 0; i < nEffCols; i++ ) + recalcColumn( i ); +} + +static bool shouldScaleColumns(RenderTable* table) +{ + // A special case. If this table is not fixed width and contained inside + // a cell, then don't bloat the maxwidth by examining percentage growth. + bool scale = true; + while (table) { + Length tw = table->style()->width(); + if ((tw.isVariable() || tw.isPercent()) && !table->isPositioned()) { + RenderBlock* cb = table->containingBlock(); + while (cb && !cb->isCanvas() && !cb->isTableCell() && + cb->style()->width().isVariable() && !cb->isPositioned()) + cb = cb->containingBlock(); + + table = 0; + if (cb && cb->isTableCell() && + (cb->style()->width().isVariable() || cb->style()->width().isPercent())) { + if (tw.isPercent()) + scale = false; + else { + RenderTableCell* cell = static_cast<RenderTableCell*>(cb); + if (cell->colSpan() > 1 || cell->table()->style()->width().isVariable()) + scale = false; + else + table = cell->table(); + } + } + } + else + table = 0; + } + return scale; +} + +void AutoTableLayout::calcMinMaxWidth() +{ +#ifdef DEBUG_LAYOUT + tqDebug("AutoTableLayout::calcMinMaxWidth"); +#endif + fullRecalc(); + + int spanMaxWidth = calcEffectiveWidth(); + int minWidth = 0; + int maxWidth = 0; + int maxPercent = 0; + int maxNonPercent = 0; + + int remainingPercent = 100; + for ( unsigned int i = 0; i < layoutStruct.size(); i++ ) { + minWidth += layoutStruct[i].effMinWidth; + maxWidth += layoutStruct[i].effMaxWidth; + if ( layoutStruct[i].effWidth.isPercent() ) { + int percent = kMin(layoutStruct[i].effWidth.value(), remainingPercent); + int pw = ( layoutStruct[i].effMaxWidth * 100) / kMax(percent, 1); + remainingPercent -= percent; + maxPercent = kMax( pw, maxPercent ); + } else { + maxNonPercent += layoutStruct[i].effMaxWidth; + } + } + + if (shouldScaleColumns(table)) { + maxNonPercent = (maxNonPercent * 100 + 50) / kMax(remainingPercent, 1); + maxWidth = kMax( maxNonPercent, maxWidth ); + maxWidth = kMax( maxWidth, maxPercent ); + } + + maxWidth = kMax( maxWidth, spanMaxWidth ); + + int bs = table->bordersPaddingAndSpacing(); + minWidth += bs; + maxWidth += bs; + + Length tw = table->style()->width(); + if ( tw.isFixed() && tw.value() > 0 ) { + int width = table->calcBoxWidth(tw.value()); + minWidth = kMax( minWidth, width ); + maxWidth = minWidth; + } + + table->m_maxWidth = kMin(maxWidth, 0x7fff); + table->m_minWidth = kMin(minWidth, 0x7fff); +#ifdef DEBUG_LAYOUT + tqDebug(" minWidth=%d, maxWidth=%d", table->m_minWidth, table->m_maxWidth ); +#endif +} + +/* + This method takes care of colspans. + effWidth is the same as width for cells without colspans. If we have colspans, they get modified. + */ +int AutoTableLayout::calcEffectiveWidth() +{ + int tMaxWidth = 0; + + unsigned int nEffCols = layoutStruct.size(); + int hspacing = table->borderHSpacing(); +#ifdef DEBUG_LAYOUT + tqDebug("AutoTableLayout::calcEffectiveWidth for %d cols", nEffCols ); +#endif + for ( unsigned int i = 0; i < nEffCols; i++ ) { + layoutStruct[i].effWidth = layoutStruct[i].width; + layoutStruct[i].effMinWidth = layoutStruct[i].minWidth; + layoutStruct[i].effMaxWidth = layoutStruct[i].maxWidth; + } + + for ( unsigned int i = 0; i < spanCells.size(); i++ ) { + RenderTableCell *cell = spanCells[i]; + if ( !cell || cell == (RenderTableCell *)-1 ) + break; + int span = cell->colSpan(); + + Length w = cell->styleOrColWidth(); + if ( !w.isRelative() && w.value() == 0 ) + w = Length(); // make it Variable + + int col = table->colToEffCol( cell->col() ); + unsigned int lastCol = col; + int cMinWidth = cell->minWidth() + hspacing; + int cMaxWidth = cell->maxWidth() + hspacing; + int totalPercent = 0; + int minWidth = 0; + int maxWidth = 0; + bool allColsArePercent = true; + bool allColsAreFixed = true; + bool haveVariable = false; + int fixedWidth = 0; +#ifdef DEBUG_LAYOUT + int cSpan = span; +#endif + while ( lastCol < nEffCols && span > 0 ) { + switch( layoutStruct[lastCol].width.type() ) { + case Percent: + totalPercent += layoutStruct[lastCol].width.value(); + allColsAreFixed = false; + break; + case Fixed: + if (layoutStruct[lastCol].width.value() > 0) { + fixedWidth += layoutStruct[lastCol].width.value(); + allColsArePercent = false; + // IE resets effWidth to Variable here, but this breaks the konqueror about page and seems to be some bad + // legacy behavior anyway. mozilla doesn't do this so I decided we don't either. + break; + } + // fall through + case Variable: + haveVariable = true; + // fall through + default: + // If the column is a percentage width, do not let the spanning cell overwrite the + // width value. This caused a mis-rendering on amazon.com. + // Sample snippet: + // <table border=2 width=100%>< + // <tr><td>1</td><td colspan=2>2-3</tr> + // <tr><td>1</td><td colspan=2 width=100%>2-3</td></tr> + // </table> + if (!layoutStruct[lastCol].effWidth.isPercent()) { + layoutStruct[lastCol].effWidth = Length(); + allColsArePercent = false; + } + else + totalPercent += layoutStruct[lastCol].effWidth.value(); + allColsAreFixed = false; + } + span -= table->spanOfEffCol( lastCol ); + minWidth += layoutStruct[lastCol].effMinWidth; + maxWidth += layoutStruct[lastCol].effMaxWidth; + lastCol++; + cMinWidth -= hspacing; + cMaxWidth -= hspacing; + } +#ifdef DEBUG_LAYOUT + tqDebug(" colspan cell %p at effCol %d, span %d, type %d, value %d cmin=%d min=%d fixedwidth=%d", cell, col, cSpan, w.type(), w.value(), cMinWidth, minWidth, fixedWidth ); +#endif + + // adjust table max width if needed + if ( w.isPercent() ) { + if ( totalPercent > w.value() || allColsArePercent ) { + // can't satify this condition, treat as variable + w = Length(); + } else { + int spanMax = kMax( maxWidth, cMaxWidth ); +#ifdef DEBUG_LAYOUT + tqDebug(" adjusting tMaxWidth (%d): spanMax=%d, value=%d, totalPercent=%d", tMaxWidth, spanMax, w.value(), totalPercent ); +#endif + tMaxWidth = kMax( tMaxWidth, spanMax * 100 / w.value() ); + + // all non percent columns in the span get percent values to sum up correctly. + int percentMissing = w.value() - totalPercent; + int totalWidth = 0; + for ( unsigned int pos = col; pos < lastCol; pos++ ) { + if ( !(layoutStruct[pos].width.isPercent() ) ) + totalWidth += layoutStruct[pos].effMaxWidth; + } + + for ( unsigned int pos = col; pos < lastCol && totalWidth > 0; pos++ ) { + if ( !(layoutStruct[pos].width.isPercent() ) ) { + int percent = percentMissing * layoutStruct[pos].effMaxWidth / totalWidth; +#ifdef DEBUG_LAYOUT + tqDebug(" col %d: setting percent value %d effMaxWidth=%d totalWidth=%d", pos, percent, layoutStruct[pos].effMaxWidth, totalWidth ); +#endif + totalWidth -= layoutStruct[pos].effMaxWidth; + percentMissing -= percent; + if ( percent > 0 ) + layoutStruct[pos].effWidth = Length( percent, Percent ); + else + layoutStruct[pos].effWidth = Length(); + } + } + + } + } + + // make sure minWidth and maxWidth of the spanning cell are honoured + if ( cMinWidth > minWidth ) { + if ( allColsAreFixed ) { +#ifdef DEBUG_LAYOUT + tqDebug("extending minWidth of cols %d-%d to %dpx currentMin=%d accroding to fixed sum %d", col, lastCol-1, cMinWidth, minWidth, fixedWidth ); +#endif + for ( unsigned int pos = col; fixedWidth > 0 && pos < lastCol; pos++ ) { + int w = kMax( int( layoutStruct[pos].effMinWidth ), cMinWidth * layoutStruct[pos].width.value() / fixedWidth ); +#ifdef DEBUG_LAYOUT + tqDebug(" col %d: min=%d, effMin=%d, new=%d", pos, layoutStruct[pos].effMinWidth, layoutStruct[pos].effMinWidth, w ); +#endif + fixedWidth -= layoutStruct[pos].width.value(); + cMinWidth -= w; + layoutStruct[pos].effMinWidth = w; + } + + } else if ( allColsArePercent ) { + int maxw = maxWidth; + int minw = minWidth; + int cminw = cMinWidth; + + for ( unsigned int pos = col; maxw > 0 && pos < lastCol; pos++ ) { + if ( layoutStruct[pos].effWidth.isPercent() && layoutStruct[pos].effWidth.value()>0 && fixedWidth <= cMinWidth) { + int w = layoutStruct[pos].effMinWidth; + w = kMax( w, cminw*layoutStruct[pos].effWidth.value()/totalPercent ); + w = kMin(layoutStruct[pos].effMinWidth+(cMinWidth-minw), w); +#ifdef DEBUG_LAYOUT + tqDebug(" col %d: min=%d, effMin=%d, new=%d", pos, layoutStruct[pos].effMinWidth, layoutStruct[pos].effMinWidth, w ); +#endif + maxw -= layoutStruct[pos].effMaxWidth; + minw -= layoutStruct[pos].effMinWidth; + cMinWidth -= w; + layoutStruct[pos].effMinWidth = w; + } + } + } else { +#ifdef DEBUG_LAYOUT + tqDebug("extending minWidth of cols %d-%d to %dpx currentMin=%d", col, lastCol-1, cMinWidth, minWidth ); +#endif + int maxw = maxWidth; + int minw = minWidth; + + // Give min to variable first, to fixed second, and to others third. + for ( unsigned int pos = col; maxw > 0 && pos < lastCol; pos++ ) { + if ( layoutStruct[pos].width.isFixed() && haveVariable && fixedWidth <= cMinWidth ) { + int w = kMax( int( layoutStruct[pos].effMinWidth ), layoutStruct[pos].width.value() ); + fixedWidth -= layoutStruct[pos].width.value(); + minw -= layoutStruct[pos].effMinWidth; +#ifdef DEBUG_LAYOUT + tqDebug(" col %d: min=%d, effMin=%d, new=%d", pos, layoutStruct[pos].effMinWidth, layoutStruct[pos].effMinWidth, w ); +#endif + maxw -= layoutStruct[pos].effMaxWidth; + cMinWidth -= w; + layoutStruct[pos].effMinWidth = w; + } + } + + for ( unsigned int pos = col; maxw > 0 && pos < lastCol && minw < cMinWidth; pos++ ) { + if ( !(layoutStruct[pos].width.isFixed() && haveVariable && fixedWidth <= cMinWidth) ) { + int w = kMax( int( layoutStruct[pos].effMinWidth ), cMinWidth * layoutStruct[pos].effMaxWidth / maxw ); + w = kMin(layoutStruct[pos].effMinWidth+(cMinWidth-minw), w); + +#ifdef DEBUG_LAYOUT + tqDebug(" col %d: min=%d, effMin=%d, new=%d", pos, layoutStruct[pos].effMinWidth, layoutStruct[pos].effMinWidth, w ); +#endif + maxw -= layoutStruct[pos].effMaxWidth; + minw -= layoutStruct[pos].effMinWidth; + cMinWidth -= w; + layoutStruct[pos].effMinWidth = w; + } + } + } + } + if ( !w.isPercent() ) { + if ( cMaxWidth > maxWidth ) { +#ifdef DEBUG_LAYOUT + tqDebug("extending maxWidth of cols %d-%d to %dpx", col, lastCol-1, cMaxWidth ); +#endif + for ( unsigned int pos = col; maxWidth > 0 && pos < lastCol; pos++ ) { + int w = kMax( int( layoutStruct[pos].effMaxWidth ), cMaxWidth * layoutStruct[pos].effMaxWidth / maxWidth ); +#ifdef DEBUG_LAYOUT + tqDebug(" col %d: max=%d, effMax=%d, new=%d", pos, layoutStruct[pos].effMaxWidth, layoutStruct[pos].effMaxWidth, w ); +#endif + maxWidth -= layoutStruct[pos].effMaxWidth; + cMaxWidth -= w; + layoutStruct[pos].effMaxWidth = w; + } + } + } else { + for ( unsigned int pos = col; pos < lastCol; pos++ ) + layoutStruct[pos].maxWidth = kMax(layoutStruct[pos].maxWidth, int(layoutStruct[pos].minWidth) ); + } + } + effWidthDirty = false; + +// tqDebug("calcEffectiveWidth: tMaxWidth=%d", tMaxWidth ); + return tMaxWidth; +} + +/* gets all cells that originate in a column and have a cellspan > 1 + Sorts them by increasing cellspan +*/ +void AutoTableLayout::insertSpanCell( RenderTableCell *cell ) +{ + if ( !cell || cell == (RenderTableCell *)-1 || cell->colSpan() == 1 ) + return; + +// tqDebug("inserting span cell %p with span %d", cell, cell->colSpan() ); + int size = spanCells.size(); + if ( !size || spanCells[size-1] != 0 ) { + spanCells.resize( size + 10 ); + for ( int i = 0; i < 10; i++ ) + spanCells[size+i] = 0; + size += 10; + } + + // add them in sort. This is a slow algorithm, and a binary search or a fast sorting after collection would be better + unsigned int pos = 0; + int span = cell->colSpan(); + while ( pos < spanCells.size() && spanCells[pos] && span > spanCells[pos]->colSpan() ) + pos++; + memmove( spanCells.data()+pos+1, spanCells.data()+pos, (size-pos-1)*sizeof( RenderTableCell * ) ); + spanCells[pos] = cell; +} + + +void AutoTableLayout::layout() +{ + // table layout based on the values collected in the layout structure. + int tableWidth = table->width() - table->bordersPaddingAndSpacing(); + int available = tableWidth; + int nEffCols = table->numEffCols(); + + if ( nEffCols != (int)layoutStruct.size() ) { + tqWarning("WARNING: nEffCols is not equal to layoutstruct!" ); + fullRecalc(); + nEffCols = table->numEffCols(); + } +#ifdef DEBUG_LAYOUT + tqDebug("AutoTableLayout::layout()"); +#endif + + if ( effWidthDirty ) + calcEffectiveWidth(); + +#ifdef DEBUG_LAYOUT + tqDebug(" tableWidth=%d, nEffCols=%d", tableWidth, nEffCols ); + for ( int i = 0; i < nEffCols; i++ ) { + tqDebug(" effcol %d is of type %d value %d, minWidth=%d, maxWidth=%d", + i, layoutStruct[i].width.type(), layoutStruct[i].width.value(), + layoutStruct[i].minWidth, layoutStruct[i].maxWidth ); + tqDebug(" effective: type %d value %d, minWidth=%d, maxWidth=%d", + layoutStruct[i].effWidth.type(), layoutStruct[i].effWidth.value(), + layoutStruct[i].effMinWidth, layoutStruct[i].effMaxWidth ); + } +#endif + + bool havePercent = false; + bool haveRelative = false; + int totalRelative = 0; + int numVariable = 0; + int numFixed = 0; + int totalVariable = 0; + int totalFixed = 0; + int totalPercent = 0; + int allocVariable = 0; + + // fill up every cell with it's minWidth + for ( int i = 0; i < nEffCols; i++ ) { + int w = layoutStruct[i].effMinWidth; + layoutStruct[i].calcWidth = w; + available -= w; + Length& width = layoutStruct[i].effWidth; + switch( width.type()) { + case Percent: + havePercent = true; + totalPercent += width.value(); + break; + case Relative: + haveRelative = true; + totalRelative += width.value(); + break; + case Fixed: + numFixed++; + totalFixed += layoutStruct[i].effMaxWidth; + // fall through + break; + case Variable: + case Static: + numVariable++; + totalVariable += layoutStruct[i].effMaxWidth; + allocVariable += w; + } + } + + // allocate width to percent cols + if ( available > 0 && havePercent ) { + for ( int i = 0; i < nEffCols; i++ ) { + const Length &width = layoutStruct[i].effWidth; + if ( width.isPercent() ) { + int w = kMax ( int( layoutStruct[i].effMinWidth ), width.minWidth( tableWidth ) ); + available += layoutStruct[i].calcWidth - w; + layoutStruct[i].calcWidth = w; + } + } + if ( totalPercent > 100 ) { + // remove overallocated space from the last columns + int excess = tableWidth*(totalPercent-100)/100; + for ( int i = nEffCols-1; i >= 0; i-- ) { + if ( layoutStruct[i].effWidth.isPercent() ) { + int w = layoutStruct[i].calcWidth; + int reduction = kMin( w, excess ); + // the lines below might look inconsistent, but that's the way it's handled in mozilla + excess -= reduction; + int newWidth = kMax( int (layoutStruct[i].effMinWidth), w - reduction ); + available += w - newWidth; + layoutStruct[i].calcWidth = newWidth; + //tqDebug("col %d: reducing to %d px (reduction=%d)", i, newWidth, reduction ); + } + } + } + } +#ifdef DEBUG_LAYOUT + tqDebug("percent satisfied: available is %d", available); +#endif + + // then allocate width to fixed cols + if ( available > 0 ) { + for ( int i = 0; i < nEffCols; ++i ) { + const Length &width = layoutStruct[i].effWidth; + if ( width.isFixed() && width.value() > layoutStruct[i].calcWidth ) { + available += layoutStruct[i].calcWidth - width.value(); + layoutStruct[i].calcWidth = width.value(); + } + } + } +#ifdef DEBUG_LAYOUT + tqDebug("fixed satisfied: available is %d", available); +#endif + + // now satisfy relative + if ( available > 0 ) { + for ( int i = 0; i < nEffCols; i++ ) { + const Length &width = layoutStruct[i].effWidth; + if ( width.isRelative() && width.value() ) { + // width=0* gets effMinWidth. + int w = width.value()*tableWidth/totalRelative; + available += layoutStruct[i].calcWidth - w; + layoutStruct[i].calcWidth = w; + } + } + } + + // now satisfy variable + if ( available > 0 && numVariable ) { + available += allocVariable; // this gets redistributed + //tqDebug("redistributing %dpx to %d variable columns. totalVariable=%d", available, numVariable, totalVariable ); + for ( int i = 0; i < nEffCols; i++ ) { + const Length &width = layoutStruct[i].effWidth; + if ( width.isVariable() && totalVariable != 0 ) { + int w = kMax( int ( layoutStruct[i].calcWidth ), + available * layoutStruct[i].effMaxWidth / totalVariable ); + available -= w; + totalVariable -= layoutStruct[i].effMaxWidth; + layoutStruct[i].calcWidth = w; + } + } + } +#ifdef DEBUG_LAYOUT + tqDebug("variable satisfied: available is %d", available ); +#endif + + // spread over fixed colums + if ( available > 0 && numFixed) { + // still have some width to spread, distribute to fixed columns + for ( int i = 0; i < nEffCols; i++ ) { + const Length &width = layoutStruct[i].effWidth; + if ( width.isFixed() ) { + int w = available * layoutStruct[i].effMaxWidth / totalFixed; + available -= w; + totalFixed -= layoutStruct[i].effMaxWidth; + layoutStruct[i].calcWidth += w; + } + } + } + +#ifdef DEBUG_LAYOUT + tqDebug("after fixed distribution: available=%d", available ); +#endif + + // spread over percent colums + if ( available > 0 && hasPercent && totalPercent < 100) { + // still have some width to spread, distribute weighted to percent columns + for ( int i = 0; i < nEffCols; i++ ) { + const Length &width = layoutStruct[i].effWidth; + if ( width.isPercent() ) { + int w = available * width.value() / totalPercent; + available -= w; + totalPercent -= width.value(); + layoutStruct[i].calcWidth += w; + if (!available || !totalPercent) break; + } + } + } + +#ifdef DEBUG_LAYOUT + tqDebug("after percent distribution: available=%d", available ); +#endif + + // spread over the rest + if ( available > 0 ) { + int total = nEffCols; + // still have some width to spread + int i = nEffCols; + while ( i-- ) { + int w = available / total; + available -= w; + total--; + layoutStruct[i].calcWidth += w; + } + } + +#ifdef DEBUG_LAYOUT + tqDebug("after equal distribution: available=%d", available ); +#endif + // if we have overallocated, reduce every cell according to the difference between desired width and minwidth + // this seems to produce to the pixel exaxt results with IE. Wonder is some of this also holds for width distributing. + if ( available < 0 ) { + // Need to reduce cells with the following prioritization: + // (1) Variable + // (2) Relative + // (3) Fixed + // (4) Percent + // This is basically the reverse of how we grew the cells. + if (available < 0) { + int mw = 0; + for ( int i = nEffCols-1; i >= 0; i-- ) { + Length &width = layoutStruct[i].effWidth; + if (width.isVariable()) + mw += layoutStruct[i].calcWidth - layoutStruct[i].effMinWidth; + } + + for ( int i = nEffCols-1; i >= 0 && mw > 0; i-- ) { + Length &width = layoutStruct[i].effWidth; + if (width.isVariable()) { + int minMaxDiff = layoutStruct[i].calcWidth-layoutStruct[i].effMinWidth; + int reduce = available * minMaxDiff / mw; + layoutStruct[i].calcWidth += reduce; + available -= reduce; + mw -= minMaxDiff; + if ( available >= 0 ) + break; + } + } + } + + if (available < 0) { + int mw = 0; + for ( int i = nEffCols-1; i >= 0; i-- ) { + Length &width = layoutStruct[i].effWidth; + if (width.isRelative()) + mw += layoutStruct[i].calcWidth - layoutStruct[i].effMinWidth; + } + + for ( int i = nEffCols-1; i >= 0 && mw > 0; i-- ) { + Length &width = layoutStruct[i].effWidth; + if (width.isRelative()) { + int minMaxDiff = layoutStruct[i].calcWidth-layoutStruct[i].effMinWidth; + int reduce = available * minMaxDiff / mw; + layoutStruct[i].calcWidth += reduce; + available -= reduce; + mw -= minMaxDiff; + if ( available >= 0 ) + break; + } + } + } + + if (available < 0) { + int mw = 0; + for ( int i = nEffCols-1; i >= 0; i-- ) { + Length &width = layoutStruct[i].effWidth; + if (width.isFixed()) + mw += layoutStruct[i].calcWidth - layoutStruct[i].effMinWidth; + } + + for ( int i = nEffCols-1; i >= 0 && mw > 0; i-- ) { + Length &width = layoutStruct[i].effWidth; + if (width.isFixed()) { + int minMaxDiff = layoutStruct[i].calcWidth-layoutStruct[i].effMinWidth; + int reduce = available * minMaxDiff / mw; + layoutStruct[i].calcWidth += reduce; + available -= reduce; + mw -= minMaxDiff; + if ( available >= 0 ) + break; + } + } + } + + if (available < 0) { + int mw = 0; + for ( int i = nEffCols-1; i >= 0; i-- ) { + Length &width = layoutStruct[i].effWidth; + if (width.isPercent()) + mw += layoutStruct[i].calcWidth - layoutStruct[i].effMinWidth; + } + + for ( int i = nEffCols-1; i >= 0 && mw > 0; i-- ) { + Length &width = layoutStruct[i].effWidth; + if (width.isPercent()) { + int minMaxDiff = layoutStruct[i].calcWidth-layoutStruct[i].effMinWidth; + int reduce = available * minMaxDiff / mw; + layoutStruct[i].calcWidth += reduce; + available -= reduce; + mw -= minMaxDiff; + if ( available >= 0 ) + break; + } + } + } + } + + //tqDebug( " final available=%d", available ); + + int pos = 0; + for ( int i = 0; i < nEffCols; i++ ) { +#ifdef DEBUG_LAYOUT + tqDebug("col %d: %d (width %d)", i, pos, layoutStruct[i].calcWidth ); +#endif + table->columnPos[i] = pos; + pos += layoutStruct[i].calcWidth + table->borderHSpacing(); + } + table->columnPos[table->columnPos.size()-1] = pos; + +} + + +void AutoTableLayout::calcPercentages() const +{ + total_percent = 0; + for ( unsigned int i = 0; i < layoutStruct.size(); i++ ) { + if ( layoutStruct[i].width.isPercent() ) + total_percent += layoutStruct[i].width.value(); + } + percentagesDirty = false; +} + +#undef DEBUG_LAYOUT diff --git a/tdehtml/rendering/table_layout.h b/tdehtml/rendering/table_layout.h new file mode 100644 index 000000000..04b34a832 --- /dev/null +++ b/tdehtml/rendering/table_layout.h @@ -0,0 +1,112 @@ +/* + * This file is part of the HTML rendering engine for KDE. + * + * Copyright (C) 2002 Lars Knoll (knoll@kde.org) + * (C) 2002 Dirk Mueller (mueller@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#ifndef TABLE_LAYOUT_H +#define TABLE_LAYOUT_H + +#include <tqmemarray.h> +#include <misc/tdehtmllayout.h> + +namespace tdehtml { + +class RenderTable; +class RenderTableCell; + +// ------------------------------------------------------------------------- + +class TableLayout +{ +public: + TableLayout( RenderTable *t ) : table( t ) {} + virtual ~TableLayout() {} + + virtual void calcMinMaxWidth() = 0; + virtual void layout() = 0; + +protected: + RenderTable *table; +}; + +// ------------------------------------------------------------------------- + +class FixedTableLayout : public TableLayout +{ +public: + FixedTableLayout( RenderTable *table ); + ~FixedTableLayout(); + + void calcMinMaxWidth(); + void layout(); + +protected: + int calcWidthArray(); + + TQMemArray<Length> width; +}; + +// ------------------------------------------------------------------------- + +class AutoTableLayout : public TableLayout +{ +public: + AutoTableLayout( RenderTable *table ); + ~AutoTableLayout(); + + void calcMinMaxWidth(); + void layout(); + + +protected: + void fullRecalc(); + void recalcColumn( int effCol ); + int totalPercent() const { + if ( percentagesDirty ) + calcPercentages(); + return total_percent; + } + void calcPercentages() const; + int calcEffectiveWidth(); + void insertSpanCell( RenderTableCell *cell ); + + struct Layout { + Layout() : minWidth( 1 ), maxWidth( 1 ), + effMinWidth( 0 ), effMaxWidth( 0 ), + calcWidth( 0 ) {} + Length width; + Length effWidth; + short minWidth; + int maxWidth; + short effMinWidth; + int effMaxWidth; + short calcWidth; + }; + + TQMemArray<Layout> layoutStruct; + TQMemArray<RenderTableCell *>spanCells; + bool hasPercent : 1; + mutable bool percentagesDirty : 1; + mutable bool effWidthDirty : 1; + mutable unsigned short total_percent; +}; + +} +#endif diff --git a/tdehtml/rendering/table_layout.txt b/tdehtml/rendering/table_layout.txt new file mode 100644 index 000000000..6dee6c1c2 --- /dev/null +++ b/tdehtml/rendering/table_layout.txt @@ -0,0 +1,74 @@ +CSS describes two ways of layouting tables. Auto layout (the NS4 +compliant HTML table layout) and fixed layout. The fixed layout +strategy is described in detail in the CSS specs and will not be +repeated here. + +Due to the fact that two layout strategies exist, it is rather natural +to encapsulate the layouting process in a TableLayout class. Two types +(FixedTableLayout and AutoTableLayout) exist. AutoTableLayout is the +default and also need a quirks flags for NS compatibility +mode. FixedTableLayout will be used if a style rule sets the +table-layout property to fixed. + +The grid of table cells is stored in each table section, as spans +can't pass section borders. Changing the number of cols in the grid +has to be done by the table to keep all grids (for all sections) in +sync. The grid only stores effective columns. The table below would +only result in one column being allocated in the grid: + +<table><tr><td colspan=1000>foo</td></tr></table> + +Once a colspan get's used, the column is split into its subparts. To +do this, the table has to store the colspans of effective columns in a +structure. + + + + +NS & Mozilla compliant table layouting algorithm (AutoTableLayout) +------------------------------------------------------------------ + +The table layout algorithm computes a set of layout hints from the +informations in the table cells, <col> elements and style +sheets. Hints from different sources are treated a bit differently in +the collection stage. + +In addition certain operations are only done in quirks (NS4 compat) +mode. + +Resizing the table doesn't require you to build up this information +again. All that is needed is a list of layout hints for each column. + +The algorithm below describes to the best of our knowledge the way +table alyouting is handled in a NS compatible way. + +There are two stages, the collection stage (assocaited with +calcMinMaxWidth() in tdehtml) and the stage assigning width to cells +(associated with layout()). + +A set of hinted widths are used to determine the final table layout in +the layouting stage. + +enum hintType { + MinWidth, + DesiredWidth, + FixedWidth, + MinWidthAdjusted, + DesiredWidthAdjusted, + FixedWidthAdjusted, + PercentWidth, + PercentWidthAdjusted, + ProportionalWidth +}; + +One width (in pixels) for each hintType describes how the column +wishes to be layouted. The layouting stage operates only on an array +of hints for each column. + +An additional totalCellSpacing variable is used to know about the +remaining width to distribute. + +Collection stage: +----------------- + + |
