KoTextParag.cpp

/* This file is part of the KDE project
   Copyright (C) 2001-2006 David Faure <faure@kde.org>
   Copyright (C) 2005-2006 Martin Ellis <martin.ellis@kdemail.net>
 
   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 "KoTextParag.h"
#include "KoTextDocument.h"
#include "KoParagCounter.h"
#include "KoTextZoomHandler.h"
#include "KoStyleCollection.h"
#include "KoVariable.h"
#include <KoOasisContext.h>
#include <KoXmlWriter.h>
#include <KoGenStyles.h>
#include <KoDom.h>
#include <KoXmlNS.h>
#include <tdeglobal.h>
#include <tdelocale.h>
#include <kdebug.h>
#include <tdeglobalsettings.h>
#include <assert.h>
 
//#define DEBUG_PAINT
 
KoTextParag::KoTextParag( KoTextDocument *d, KoTextParag *pr, KoTextParag *nx, bool updateIds )
    : p( pr ), n( nx ), doc( d ),
      m_invalid( true ),
      changed( false ),
      fullWidth( true ),
      newLinesAllowed( true ), // default in kotext
      visible( true ), //breakable( true ),
      movedDown( false ),
      m_toc( false ),
      align( 0 ),
      m_lineChanged( -1 ),
      m_wused( 0 ),
      mSelections( 0 ),
      mFloatingItems( 0 ),
      tArray( 0 )
{
    defFormat = formatCollection()->defaultFormat();
    /*if ( !doc ) {
    tabStopWidth = defFormat->width( 'x' ) * 8;
    commandHistory = new KoTextDocCommandHistory( 100 );
    }*/
 
    if ( p ) {
    p->n = this;
    }
    if ( n ) {
    n->p = this;
    }
 
    if ( !p && doc )
    doc->setFirstParag( this );
    if ( !n && doc )
    doc->setLastParag( this );
 
    //firstFormat = true; //// unused
    //firstPProcess = true;
    //state = -1;
    //needPreProcess = false;
 
    if ( p )
    id = p->id + 1;
    else
    id = 0;
    if ( n && updateIds ) {
    KoTextParag *s = n;
    while ( s ) {
        s->id = s->p->id + 1;
        //s->lm = s->rm = s->tm = s->bm = -1, s->flm = -1;
        s = s->n;
    }
    }
 
    str = new KoTextString();
    str->insert( 0, " ", formatCollection()->defaultFormat() );
    setJoinBorder( true );
}
 
KoTextParag::~KoTextParag()
{
    //kdDebug(32500) << "KoTextParag::~KoTextParag " << this << " id=" << paragId() << endl;
 
    // #107961: unregister custom items; KoTextString::clear() will delete them
    const int len = str->length();
    for ( int i = 0; i < len; ++i ) {
    KoTextStringChar *c = at( i );
    if ( doc && c->isCustom() ) {
        doc->unregisterCustomItem( c->customItem(), this );
        //removeCustomItem();
    }
    }
 
    delete str;
    str = 0;
//    if ( doc && p == doc->minwParag ) {
//  doc->minwParag = 0;
//  doc->minw = 0;
//    }
    if ( !doc ) {
    //delete pFormatter;
    //delete commandHistory;
    }
    delete [] tArray;
    //delete eData;
    TQMap<int, KoTextParagLineStart*>::Iterator it = lineStarts.begin();
    for ( ; it != lineStarts.end(); ++it )
    delete *it;
    if ( mSelections ) delete mSelections;
    if ( mFloatingItems ) delete mFloatingItems;
 
    if (p)
       p->setNext(n);
    if (n)
       n->setPrev(p);

    if ( doc && !doc->isDestroying() )
    {
        doc->informParagraphDeleted( this );
    }
    //kdDebug(32500) << "KoTextParag::~KoTextParag " << this << " done" << endl;
}
 
void KoTextParag::setNext( KoTextParag *s )
{
    n = s;
    if ( !n && doc )
    doc->setLastParag( this );
}
 
void KoTextParag::setPrev( KoTextParag *s )
{
    p = s;
    if ( !p && doc )
    doc->setFirstParag( this );
}
 
void KoTextParag::invalidate( int /*chr, ignored*/ )
{
    m_invalid = true;
#if 0
    if ( invalid < 0 )
    invalid = chr;
    else
    invalid = TQMIN( invalid, chr );
#endif
}
 
void KoTextParag::setChanged( bool b, bool /*recursive*/ )
{
    changed = b;
    m_lineChanged = -1; // all
}
 
void KoTextParag::setLineChanged( short int line )
{
    if ( m_lineChanged == -1 ) {
        if ( !changed ) // only if the whole parag wasn't "changed" already
            m_lineChanged = line;
    }
    else
        m_lineChanged = TQMIN( m_lineChanged, line ); // also works if line=-1
    changed = true;
    //kdDebug(32500) << "KoTextParag::setLineChanged line=" << line << " -> m_lineChanged=" << m_lineChanged << endl;
}
 
void KoTextParag::insert( int index, const TQString &s )
{
    str->insert( index, s, formatCollection()->defaultFormat() );
    invalidate( index );
    //needPreProcess = true;
}
 
void KoTextParag::truncate( int index )
{
    str->truncate( index );
    insert( length(), " " );
    //needPreProcess = true;
}
 
void KoTextParag::remove( int index, int len )
{
    if ( index + len - str->length() > 0 )
    return;
    for ( int i = index; i < index + len; ++i ) {
    KoTextStringChar *c = at( i );
    if ( doc && c->isCustom() ) {
        doc->unregisterCustomItem( c->customItem(), this );
        //removeCustomItem();
    }
    }
    str->remove( index, len );
    invalidate( 0 );
    //needPreProcess = true;
}
 
void KoTextParag::join( KoTextParag *s )
{
    //kdDebug(32500) << "KoTextParag::join this=" << paragId() << " (length " << length() << ") with " << s->paragId() << " (length " << s->length() << ")" << endl;
    int oh = r.height() + s->r.height();
    n = s->n;
    if ( n )
    n->p = this;
    else if ( doc )
    doc->setLastParag( this );
 
    int start = str->length();
    if ( length() > 0 && at( length() - 1 )->c == ' ' ) {
    remove( length() - 1, 1 );
    --start;
    }
    append( s->str->toString(), true );
 
    for ( int i = 0; i < s->length(); ++i ) {
    if ( doc->useFormatCollection() ) {
        s->str->at( i ).format()->addRef();
        str->setFormat( i + start, s->str->at( i ).format(), true );
    }
    if ( s->str->at( i ).isCustom() ) {
        KoTextCustomItem * item = s->str->at( i ).customItem();
        str->at( i + start ).setCustomItem( item );
        s->str->at( i ).loseCustomItem();
        doc->unregisterCustomItem( item, s ); // ### missing in TQRT
        doc->registerCustomItem( item, this );
    }
    }
    Q_ASSERT(str->at(str->length()-1).c == ' ');
 
    /*if ( !extraData() && s->extraData() ) {
    setExtraData( s->extraData() );
    s->setExtraData( 0 );
    } else if ( extraData() && s->extraData() ) {
    extraData()->join( s->extraData() );
        }*/
    delete s;
    invalidate( 0 );
    invalidateCounters();
    r.setHeight( oh );
    //needPreProcess = true;
    if ( n ) {
    KoTextParag *s = n;
    while ( s ) {
        s->id = s->p->id + 1;
        //s->state = -1;
        //s->needPreProcess = true;
        s->changed = true;
        s = s->n;
    }
    }
    format();
    //state = -1;
}
 
void KoTextParag::move( int &dy )
{
    //kdDebug(32500) << "KoTextParag::move paragId=" << paragId() << " dy=" << dy << endl;
    if ( dy == 0 )
    return;
    changed = true;
    r.moveBy( 0, dy );
    if ( mFloatingItems ) {
    for ( KoTextCustomItem *i = mFloatingItems->first(); i; i = mFloatingItems->next() ) {
        i->finalize();
    }
    }
    //if ( p )
    //    p->lastInFrame = true; // TQt does this, but the loop at the end of format() calls move a lot!
 
    movedDown = false;
 
    // do page breaks if required
    if ( doc && doc->isPageBreakEnabled() ) {
    int shift;
    if ( ( shift = doc->formatter()->formatVertically(  doc, this ) ) ) {
        if ( p )
        p->setChanged( true );
        dy += shift;
    }
    }
}
 
void KoTextParag::format( int start, bool doMove )
{
    if ( !str || str->length() == 0 || !formatter() )
    return;
 
    if ( isValid() )
    return;
 
    //kdDebug(32500) << "KoTextParag::format " << this << " id:" << paragId() << endl;
 
    r.moveTopLeft( TQPoint( documentX(), p ? p->r.y() + p->r.height() : documentY() ) );
    //if ( p )
    //    p->lastInFrame = false;
 
    movedDown = false;
    bool formattedAgain = false;
 
 formatAgain:
    r.setWidth( documentWidth() );
 
    // Not really useful....
    if ( doc && mFloatingItems ) {
    for ( KoTextCustomItem *i = mFloatingItems->first(); i; i = mFloatingItems->next() ) {
        if ( i->placement() == KoTextCustomItem::PlaceRight )
        i->move( r.x() + r.width() - i->width, r.y() );
        else
        i->move( i->x(), r.y() );
    }
    }
    TQMap<int, KoTextParagLineStart*> oldLineStarts = lineStarts;
    lineStarts.clear();
    int y;
    bool formatterWorked = formatter()->format( doc, this, start, oldLineStarts, y, m_wused );
 
    // It can't happen that width < minimumWidth -- hopefully.
    //r.setWidth( TQMAX( r.width(), formatter()->minimumWidth() ) );
    //m_minw = formatter()->minimumWidth();
 
    TQMap<int, KoTextParagLineStart*>::Iterator it = oldLineStarts.begin();
 
    for ( ; it != oldLineStarts.end(); ++it )
    delete *it;
 
/*    if ( hasBorder() || str->isRightToLeft() )
    {
        setWidth( textDocument()->width() - 1 );
    }
    else*/
    {
        if ( lineStarts.count() == 1 ) { //&& ( !doc || doc->flow()->isEmpty() ) ) {
// kotext: for proper parag borders, we want all parags to be as wide as linestart->w
/*            if ( !str->isBidi() ) {
                KoTextStringChar *c = &str->at( str->length() - 1 );
                r.setWidth( c->x + c->width );
            } else*/ {
                r.setWidth( lineStarts[0]->w );
            }
        }
        if ( newLinesAllowed ) {
            it = lineStarts.begin();
            int usedw = 0; int lineid = 0;
            for ( ; it != lineStarts.end(); ++it, ++lineid ) {
                usedw = TQMAX( usedw, (*it)->w );
            }
            if ( r.width() <= 0 ) {
                // if the user specifies an invalid rect, this means that the
                // bounding box should grow to the width that the text actually
                // needs
                r.setWidth( usedw );
            } else {
                r.setWidth( TQMIN( usedw, r.width() ) );
            }
        }
    }
 
    if ( y != r.height() )
    r.setHeight( y );
 
    if ( !visible )
    r.setHeight( 0 );
 
    // do page breaks if required
    if ( doc && doc->isPageBreakEnabled() ) {
        int shift = doc->formatter()->formatVertically( doc, this );
        //kdDebug(32500) << "formatVertically returned shift=" << shift << endl;
        if ( shift && !formattedAgain ) {
            formattedAgain = true;
            goto formatAgain;
        }
    }
 
    if ( doc )
        doc->formatter()->postFormat( this );
 
    if ( n && doMove && n->isValid() && r.y() + r.height() != n->r.y() ) {
        //kdDebug(32500) << "r=" << r << " n->r=" << n->r << endl;
    int dy = ( r.y() + r.height() ) - n->r.y();
    KoTextParag *s = n;
    bool makeInvalid = false; //p && p->lastInFrame;
    //kdDebug(32500) << "might move of dy=" << dy << ". previous's lastInFrame (=makeInvalid): " << makeInvalid << endl;
    while ( s && dy ) {
            if ( s->movedDown ) { // (not in TQRT) : moved down -> invalidate and stop moving down
                s->invalidate( 0 ); // (there is no point in moving down a parag that has a frame break...)
                break;
            }
        if ( !s->isFullWidth() )
        makeInvalid = true;
        if ( makeInvalid )
        s->invalidate( 0 );
        s->move( dy );
        //if ( s->lastInFrame )
            //    makeInvalid = true;
        s = s->n;
    }
    }
 
//#define DEBUG_CI_PLACEMENT
    if ( mFloatingItems ) {
#ifdef DEBUG_CI_PLACEMENT
        kdDebug(32500) << lineStarts.count() << " lines" << endl;
#endif
        // Place custom items - after the formatting is finished
        int len = length();
        int line = -1;
        int lineY = 0; // the one called "cy" in other algos
        int baseLine = 0;
        TQMap<int, KoTextParagLineStart*>::Iterator it = lineStarts.begin();
        for ( int i = 0 ; i < len; ++i ) {
            KoTextStringChar *chr = &str->at( i );
            if ( chr->lineStart ) {
                ++line;
                if ( line > 0 )
                    ++it;
                lineY = (*it)->y;
                baseLine = (*it)->baseLine;
#ifdef DEBUG_CI_PLACEMENT
                kdDebug(32500) << "New line (" << line << "): lineStart=" << (*it) << " lineY=" << lineY << " baseLine=" << baseLine << " height=" << (*it)->h << endl;
#endif
            }
            if ( chr->isCustom() ) {
                int x = chr->x;
                KoTextCustomItem* item = chr->customItem();
                Q_ASSERT( baseLine >= item->ascent() ); // something went wrong in KoTextFormatter if this isn't the case
                int y = lineY + baseLine - item->ascent();
#ifdef DEBUG_CI_PLACEMENT
                kdDebug(32500) << "Custom item: i=" << i << " x=" << x << " lineY=" << lineY << " baseLine=" << baseLine << " ascent=" << item->ascent() << " -> y=" << y << endl;
#endif
                item->move( x, y );
                item->finalize();
            }
        }
    }
 
    //firstFormat = false; //// unused
    if ( formatterWorked ) // only if it worked, i.e. we had some width to format it
    {
        m_invalid = false;
    }
    changed = true;
    //####   str->setTextChanged( false );
}
 
int KoTextParag::lineHeightOfChar( int i, int *bl, int *y ) const
{
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.end();
    --it;
    for ( ;; ) {
    if ( i >= it.key() ) {
        if ( bl )
        *bl = ( *it )->baseLine;
        if ( y )
        *y = ( *it )->y;
        return ( *it )->h;
    }
    if ( it == lineStarts.begin() )
        break;
    --it;
    }
 
    kdWarning(32500) << "KoTextParag::lineHeightOfChar: couldn't find lh for " << i << endl;
    return 15;
}
 
KoTextStringChar *KoTextParag::lineStartOfChar( int i, int *index, int *line ) const
{
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    int l = (int)lineStarts.count() - 1;
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.end();
    --it;
    for ( ;; ) {
    if ( i >= it.key() ) {
        if ( index )
        *index = it.key();
        if ( line )
        *line = l;
        return &str->at( it.key() );
    }
    if ( it == lineStarts.begin() )
        break;
    --it;
    --l;
    }
 
    kdWarning(32500) << "KoTextParag::lineStartOfChar: couldn't find " << i << endl;
    return 0;
}
 
int KoTextParag::lines() const
{
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    return (int)lineStarts.count();
}
 
KoTextStringChar *KoTextParag::lineStartOfLine( int line, int *index ) const
{
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    if ( line >= 0 && line < (int)lineStarts.count() ) {
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
    while ( line-- > 0 )
        ++it;
    int i = it.key();
    if ( index )
        *index = i;
    return &str->at( i );
    }
 
    kdWarning(32500) << "KoTextParag::lineStartOfLine: couldn't find " << line << endl;
    return 0;
}
 
int KoTextParag::leftGap() const
{
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    int line = 0;
    int x = str->at(0).x;  /* set x to x of first char */
    if ( str->isBidi() ) {
    for ( int i = 1; i < str->length(); ++i )
        x = TQMIN(x, str->at(i).x);
    return x;
    }
 
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
    while (line < (int)lineStarts.count()) {
    int i = it.key(); /* char index */
    x = TQMIN(x, str->at(i).x);
    ++it;
    ++line;
    }
    return x;
}
 
void KoTextParag::setFormat( int index, int len, const KoTextFormat *_f, bool useCollection, int flags )
{
    Q_ASSERT( useCollection ); // just for info
    if ( index < 0 )
    index = 0;
    if ( index > str->length() - 1 )
    index = str->length() - 1;
    if ( index + len >= str->length() )
    len = str->length() - index;
 
    KoTextFormatCollection *fc = 0;
    if ( useCollection )
    fc = formatCollection();
    KoTextFormat *of;
    for ( int i = 0; i < len; ++i ) {
    of = str->at( i + index ).format();
    if ( !changed && _f->key() != of->key() )
        changed = true;
        // Check things that need the textformatter to run
        // (e.g. not color changes)
        // ######## Is this test exhaustive?
    if ( m_invalid == false &&
         ( _f->font().family() != of->font().family() ||
           _f->pointSize() != of->pointSize() ||
           _f->font().weight() != of->font().weight() ||
           _f->font().italic() != of->font().italic() ||
           _f->vAlign() != of->vAlign() ||
               _f->relativeTextSize() != of->relativeTextSize() ||
               _f->offsetFromBaseLine() != of->offsetFromBaseLine() ||
               _f->wordByWord() != of->wordByWord()  ||
               _f->attributeFont() != of->attributeFont() ||
               _f->language() != of->language() ||
               _f->hyphenation() != of->hyphenation() ||
               _f->shadowDistanceX() != of->shadowDistanceX() ||
               _f->shadowDistanceY() != of->shadowDistanceY()
                 ) ) {
        invalidate( 0 );
    }
    if ( flags == -1 || flags == KoTextFormat::Format || !fc ) {
#ifdef DEBUG_COLLECTION
        kdDebug(32500) << " KoTextParag::setFormat, will use format(f) " << f << " " << _f->key() << endl;
#endif
            KoTextFormat* f = fc ? fc->format( _f ) : const_cast<KoTextFormat *>( _f );
        str->setFormat( i + index, f, useCollection, true );
    } else {
#ifdef DEBUG_COLLECTION
        kdDebug(32500) << " KoTextParag::setFormat, will use format(of,f,flags) of=" << of << " " << of->key() << ", f=" << _f << " " << _f->key() << endl;
#endif
        KoTextFormat *fm = fc->format( of, _f, flags );
#ifdef DEBUG_COLLECTION
        kdDebug(32500) << " KoTextParag::setFormat, format(of,f,flags) returned " << fm << " " << fm->key() << " " << endl;
#endif
        str->setFormat( i + index, fm, useCollection );
    }
    }
}
 
void KoTextParag::drawCursorDefault( TQPainter &painter, KoTextCursor *cursor, int curx, int cury, int curh, const TQColorGroup &cg )
{
    painter.fillRect( TQRect( curx, cury, 1, curh ), cg.color( TQColorGroup::Text ) );
    painter.save();
    if ( str->isBidi() ) {
        const int d = 4;
        if ( at( cursor->index() )->rightToLeft ) {
            painter.setPen( TQt::black );
            painter.drawLine( curx, cury, curx - d / 2, cury + d / 2 );
            painter.drawLine( curx, cury + d, curx - d / 2, cury + d / 2 );
        } else {
            painter.setPen( TQt::black );
            painter.drawLine( curx, cury, curx + d / 2, cury + d / 2 );
            painter.drawLine( curx, cury + d, curx + d / 2, cury + d / 2 );
        }
    }
    painter.restore();
}
 
int *KoTextParag::tabArray() const
{
    int *ta = tArray;
    if ( !ta && doc )
    ta = doc->tabArray();
    return ta;
}
 
int KoTextParag::nextTabDefault( int, int x )
{
    int *ta = tArray;
    //if ( doc ) {
    if ( !ta )
        ta = doc->tabArray();
    int tabStopWidth = doc->tabStopWidth();
    //}
    if ( tabStopWidth != 0 )
    return tabStopWidth*(x/tabStopWidth+1);
    else
        return x;
}
 
KoTextFormatCollection *KoTextParag::formatCollection() const
{
    if ( doc )
    return doc->formatCollection();
    //if ( !qFormatCollection )
    //    qFormatCollection = new KoTextFormatCollection;
    //return qFormatCollection;
    return 0L;
}
 
void KoTextParag::show()
{
    if ( visible || !doc )
    return;
    visible = true;
}
 
void KoTextParag::hide()
{
    if ( !visible || !doc )
    return;
    visible = false;
}
 
void KoTextParag::setDirection( TQChar::Direction d )
{
    if ( str && str->direction() != d ) {
    str->setDirection( d );
    invalidate( 0 );
        m_layout.direction = d;
    invalidateCounters(); // #47178
    }
}
 
TQChar::Direction KoTextParag::direction() const
{
    return (str ? str->direction() : TQChar::DirON );
}
 
void KoTextParag::setSelection( int id, int start, int end )
{
    TQMap<int, KoTextParagSelection>::ConstIterator it = selections().find( id );
    if ( it != mSelections->end() ) {
    if ( start == ( *it ).start && end == ( *it ).end )
        return;
    }
 
    KoTextParagSelection sel;
    sel.start = start;
    sel.end = end;
    (*mSelections)[ id ] = sel;
    setChanged( true, true );
}
 
void KoTextParag::removeSelection( int id )
{
    if ( !hasSelection( id ) )
    return;
    if ( mSelections )
    mSelections->remove( id );
    setChanged( true, true );
}
 
int KoTextParag::selectionStart( int id ) const
{
    if ( !mSelections )
    return -1;
    TQMap<int, KoTextParagSelection>::ConstIterator it = mSelections->find( id );
    if ( it == mSelections->end() )
    return -1;
    return ( *it ).start;
}
 
int KoTextParag::selectionEnd( int id ) const
{
    if ( !mSelections )
    return -1;
    TQMap<int, KoTextParagSelection>::ConstIterator it = mSelections->find( id );
    if ( it == mSelections->end() )
    return -1;
    return ( *it ).end;
}
 
bool KoTextParag::hasSelection( int id ) const
{
    if ( !mSelections )
    return false;
    TQMap<int, KoTextParagSelection>::ConstIterator it = mSelections->find( id );
    if ( it == mSelections->end() )
    return false;
    return ( *it ).start != ( *it ).end || length() == 1;
}
 
bool KoTextParag::fullSelected( int id ) const
{
    if ( !mSelections )
    return false;
    TQMap<int, KoTextParagSelection>::ConstIterator it = mSelections->find( id );
    if ( it == mSelections->end() )
    return false;
    return ( *it ).start == 0 && ( *it ).end == str->length() - 1;
}
 
int KoTextParag::lineY( int l ) const
{
    if ( l > (int)lineStarts.count() - 1 ) {
    kdWarning(32500) << "KoTextParag::lineY: line " << l << " out of range!" << endl;
    return 0;
    }
 
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
    while ( l-- > 0 )
    ++it;
    return ( *it )->y;
}
 
int KoTextParag::lineBaseLine( int l ) const
{
    if ( l > (int)lineStarts.count() - 1 ) {
    kdWarning(32500) << "KoTextParag::lineBaseLine: line " << l << " out of range!" << endl;
    return 10;
    }
 
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
    while ( l-- > 0 )
    ++it;
    return ( *it )->baseLine;
}
 
int KoTextParag::lineHeight( int l ) const
{
    if ( l > (int)lineStarts.count() - 1 ) {
    kdWarning(32500) << "KoTextParag::lineHeight: line " << l << " out of range!" << endl;
    return 15;
    }
 
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
    while ( l-- > 0 )
    ++it;
    return ( *it )->h;
}
 
void KoTextParag::lineInfo( int l, int &y, int &h, int &bl ) const
{
    if ( l > (int)lineStarts.count() - 1 ) {
    kdWarning(32500) << "KoTextParag::lineInfo: line " << l << " out of range!" << endl;
    kdDebug(32500) << (int)lineStarts.count() - 1 << " " << l << endl;
    y = 0;
    h = 15;
    bl = 10;
    return;
    }
 
    if ( !isValid() )
    ( (KoTextParag*)this )->format();
 
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
    while ( l-- > 0 )
    ++it;
    y = ( *it )->y;
    h = ( *it )->h;
    bl = ( *it )->baseLine;
}
 
uint KoTextParag::alignment() const
{
    return align;
}
 
void KoTextParag::setFormat( KoTextFormat *fm )
{
#if 0
    bool doUpdate = false;
    if (defFormat && (defFormat != formatCollection()->defaultFormat()))
       doUpdate = true;
#endif
    defFormat = formatCollection()->format( fm );
#if 0
    if ( !doUpdate )
    return;
    for ( int i = 0; i < length(); ++i ) {
    if ( at( i )->format()->styleName() == defFormat->styleName() )
        at( i )->format()->updateStyle();
    }
#endif
}
 
KoTextFormatterBase *KoTextParag::formatter() const
{
    if ( doc )
    return doc->formatter();
    return 0;
}
 
/*int KoTextParag::minimumWidth() const
{
    //return doc ? doc->minimumWidth() : 0;
    return m_minw;
}*/
 
int KoTextParag::widthUsed() const
{
    return m_wused;
}
 
void KoTextParag::setTabArray( int *a )
{
    delete [] tArray;
    tArray = a;
}
 
void KoTextParag::setTabStops( int tw )
{
    if ( doc )
    doc->setTabStops( tw );
    //else
    //    tabStopWidth = tw;
}
 
TQMap<int, KoTextParagSelection> &KoTextParag::selections() const
{
    if ( !mSelections )
    ((KoTextParag *)this)->mSelections = new TQMap<int, KoTextParagSelection>;
    return *mSelections;
}
 
TQPtrList<KoTextCustomItem> &KoTextParag::floatingItems() const
{
    if ( !mFloatingItems )
    ((KoTextParag *)this)->mFloatingItems = new TQPtrList<KoTextCustomItem>;
    return *mFloatingItems;
}
 
void KoTextCursor::setIndex( int i, bool /*restore*/ )
{
// Note: TQRT doesn't allow to position the cursor at string->length
// However we need it, when applying a style to a paragraph, so that
// the trailing space gets the style change applied as well.
// Obviously "right of the trailing space" isn't a good place for a real
// cursor, but this needs to be checked somewhere else.
    if ( i < 0 || i > string->length() ) {
#if defined(TQT_CHECK_RANGE)
    kdWarning(32500) << "KoTextCursor::setIndex: " << i << " out of range" << endl;
        //abort();
#endif
    i = i < 0 ? 0 : string->length() - 1;
    }
 
    tmpIndex = -1;
    idx = i;
}

 
// Return the counter associated with this paragraph.
KoParagCounter *KoTextParag::counter()
{
    if ( !m_layout.counter )
        return 0L;
 
    // Garbage collect un-needed counters.
    if ( m_layout.counter->numbering() == KoParagCounter::NUM_NONE
        // [keep it for unnumbered outlines (the depth is useful)]
         && ( !m_layout.style || !m_layout.style->isOutline() ) )
        setNoCounter();
    return m_layout.counter;
}
 
void KoTextParag::setMargin( TQStyleSheetItem::Margin m, double _i )
{
    //kdDebug(32500) << "KoTextParag::setMargin " << m << " margin " << _i << endl;
    m_layout.margins[m] = _i;
    if ( m == TQStyleSheetItem::MarginTop && prev() )
        prev()->invalidate(0);     // for top margin (post-1.1: remove this, not necessary anymore)
    invalidate(0);
}
 
void KoTextParag::setMargins( const double * margins )
{
    for ( int i = 0 ; i < 5 ; ++i )
        m_layout.margins[i] = margins[i];
    invalidate(0);
}
 
void KoTextParag::setAlign( int align )
{
    Q_ASSERT( align <= TQt::AlignJustify );
    align &= TQt::AlignHorizontal_Mask;
    setAlignment( align );
    m_layout.alignment = align;
}
 
int KoTextParag::resolveAlignment() const
{
    if ( (int)m_layout.alignment == TQt::AlignAuto )
        return str->isRightToLeft() ? TQt::AlignRight : TQt::AlignLeft;
    return m_layout.alignment;
}
 
void KoTextParag::setLineSpacing( double _i )
{
    m_layout.setLineSpacingValue(_i);
    invalidate(0);
}
 
void KoTextParag::setLineSpacingType( KoParagLayout::SpacingType _type )
{
    m_layout.lineSpacingType = _type;
    invalidate(0);
}
 
void KoTextParag::setTopBorder( const KoBorder & _brd )
{
    m_layout.topBorder = _brd;
    invalidate(0);
}
 
void KoTextParag::setBottomBorder( const KoBorder & _brd )
{
    m_layout.bottomBorder = _brd;
    invalidate(0);
}
 
void KoTextParag::setJoinBorder( bool join )
{
    m_layout.joinBorder = join;
    invalidate(0);
}
 
void KoTextParag::setBackgroundColor ( const TQColor& color )
{
    m_layout.backgroundColor = color;
    invalidate(0);
}
 
void KoTextParag::setNoCounter()
{
    delete m_layout.counter;
    m_layout.counter = 0L;
    invalidateCounters();
}
 
void KoTextParag::setCounter( const KoParagCounter * pCounter )
{
    // Preserve footnote numbering when applying a style
    const bool isFootNote = m_layout.counter &&
                            m_layout.counter->numbering() == KoParagCounter::NUM_FOOTNOTE;
    if ( isFootNote ) {
        const TQString footNotePrefix = m_layout.counter->prefix(); // this is where the number is
        delete m_layout.counter;
        m_layout.counter = pCounter ? new KoParagCounter( *pCounter ) : new KoParagCounter();
        m_layout.counter->setNumbering( KoParagCounter::NUM_FOOTNOTE );
        m_layout.counter->setStyle( KoParagCounter::STYLE_NONE ); // no number after the 'prefix'
        m_layout.counter->setPrefix( footNotePrefix );
        m_layout.counter->setSuffix( TQString() );
        invalidateCounters();
    } else {
        if ( pCounter )
            setCounter( *pCounter );
        else
            setNoCounter();
    }
}
 
void KoTextParag::setCounter( const KoParagCounter & counter )
{
    // Garbage collect unnneeded counters.
    if ( counter.numbering() == KoParagCounter::NUM_NONE
         // [keep it for unnumbered outlines (the depth is useful)]
         && ( !m_layout.style || !m_layout.style->isOutline() ) )
    {
        setNoCounter();
    }
    else
    {
        delete m_layout.counter;
        m_layout.counter = new KoParagCounter( counter );
 
        // Invalidate the counters
        invalidateCounters();
    }
}
 
void KoTextParag::invalidateCounters()
{
    // Invalidate this paragraph and all the following ones
    // (Numbering may have changed)
    invalidate( 0 );
    if ( m_layout.counter )
        m_layout.counter->invalidate();
    KoTextParag *s = next();
    // #### Possible optimization: since any invalidation propagates down,
    // it's enough to stop at the first paragraph with an already-invalidated counter, isn't it?
    // This is only true if nobody else calls counter->invalidate...
    while ( s ) {
        if ( s->m_layout.counter )
            s->m_layout.counter->invalidate();
        s->invalidate( 0 );
        s = s->next();
    }
}
 
int KoTextParag::counterWidth() const
{
    if ( !m_layout.counter )
        return 0;
 
    return m_layout.counter->width( this );
}
 
// Draw the complete label (i.e. heading/list numbers/bullets) for this paragraph.
// This is called by KoTextParag::paint.
void KoTextParag::drawLabel( TQPainter* p, int xLU, int yLU, int /*wLU*/, int /*hLU*/, int baseLU, const TQColorGroup& /*cg*/ )
{
    if ( !m_layout.counter ) // shouldn't happen
        return;
 
    if ( m_layout.counter->numbering() == KoParagCounter::NUM_NONE )
        return;
 
    int counterWidthLU = m_layout.counter->width( this );
 
    // We use the formatting of the first char as the formatting of the counter
    KoTextFormat counterFormat( *KoParagCounter::counterFormat( this ) );
    if ( !m_layout.style || !m_layout.style->isOutline() )
    {
      // But without bold/italic for normal lists, since some items could be bold and others not.
      // For headings we must keep the bold when the heading is bold.
      counterFormat.setBold( false );
      counterFormat.setItalic( false );
    }
    KoTextFormat* format = &counterFormat;
    p->save();
 
    TQColor textColor( format->color() );
    if ( !textColor.isValid() ) // Resolve the color at this point
        textColor = KoTextFormat::defaultTextColor( p );
    p->setPen( TQPen( textColor ) );
 
    KoTextZoomHandler * zh = textDocument()->paintingZoomHandler();
    assert( zh );
    //bool forPrint = ( p->device()->devType() == TQInternal::Printer );
 
    bool rtl = str->isRightToLeft(); // when true, we put suffix+counter+prefix at the RIGHT of the paragraph.
    int xLeft = zh->layoutUnitToPixelX( xLU - (rtl ? 0 : counterWidthLU) );
    int y = zh->layoutUnitToPixelY( yLU );
    //int h = zh->layoutUnitToPixelY( yLU, hLU );
    int base = zh->layoutUnitToPixelY( yLU, baseLU );
    int counterWidth = zh->layoutUnitToPixelX( xLU, counterWidthLU );
    int height = zh->layoutUnitToPixelY( yLU, format->height() );
 
    TQFont font( format->screenFont( zh ) );
    // Footnote numbers are in superscript (in WP and Word, not in OO)
    if ( m_layout.counter->numbering() == KoParagCounter::NUM_FOOTNOTE )
    {
        int pointSize = ( ( font.pointSize() * 2 ) / 3 );
        font.setPointSize( pointSize );
        y -= ( height - TQFontMetrics(font).height() );
    }
    p->setFont( font );
 
    // Now draw any bullet that is required over the space left for it.
    if ( m_layout.counter->isBullet() )
    {
    int xBullet = xLeft + zh->layoutUnitToPixelX( m_layout.counter->bulletX() );
 
        //kdDebug(32500) << "KoTextParag::drawLabel xLU=" << xLU << " counterWidthLU=" << counterWidthLU << endl;
    // The width and height of the bullet is the width of one space
        int width = zh->layoutUnitToPixelX( xLeft, format->width( ' ' ) );
 
        //kdDebug(32500) << "Pix: xLeft=" << xLeft << " counterWidth=" << counterWidth
        //          << " xBullet=" << xBullet << " width=" << width << endl;
 
        TQString prefix = m_layout.counter->prefix();
        if ( !prefix.isEmpty() )
        {
            if ( rtl )
                prefix.prepend( ' ' /*the space before the bullet in RTL mode*/ );
            KoTextParag::drawFontEffects( p, format, zh, format->screenFont( zh ), textColor, xLeft, base, width, y, height, prefix[0] );
 
            int posY =y + base - format->offsetFromBaseLine();
            //we must move to bottom text because we create
            //shadow to 'top'.
            int sy = format->shadowY( zh );
            if ( sy < 0)
                posY -= sy;
 
            p->drawText( xLeft, posY, prefix );
        }
 
        TQRect er( xBullet + (rtl ? width : 0), y + height / 2 - width / 2, width, width );
        // Draw the bullet.
        int posY = 0;
        switch ( m_layout.counter->style() )
        {
            case KoParagCounter::STYLE_DISCBULLET:
                p->setBrush( TQBrush(textColor) );
                p->drawEllipse( er );
                p->setBrush( TQt::NoBrush );
                break;
            case KoParagCounter::STYLE_SQUAREBULLET:
                p->fillRect( er, TQBrush(textColor) );
                break;
            case KoParagCounter::STYLE_BOXBULLET:
                p->drawRect( er );
                break;
            case KoParagCounter::STYLE_CIRCLEBULLET:
                p->drawEllipse( er );
                break;
            case KoParagCounter::STYLE_CUSTOMBULLET:
            {
                // The user has selected a symbol from a special font. Override the paragraph
                // font with the given family. This conserves the right size etc.
                if ( !m_layout.counter->customBulletFont().isEmpty() )
                {
                    TQFont bulletFont( p->font() );
                    bulletFont.setFamily( m_layout.counter->customBulletFont() );
                    p->setFont( bulletFont );
                }
                KoTextParag::drawFontEffects( p, format, zh, format->screenFont( zh ), textColor, xBullet, base, width, y, height, ' ' );
 
                posY = y + base- format->offsetFromBaseLine();
                //we must move to bottom text because we create
                //shadow to 'top'.
                int sy = format->shadowY( zh );
                if ( sy < 0)
                    posY -= sy;
 
                p->drawText( xBullet, posY, TQString(m_layout.counter->customBulletCharacter()) );
                break;
            }
            default:
                break;
        }
 
        TQString suffix = m_layout.counter->suffix();
        if ( !suffix.isEmpty() )
        {
            if ( !rtl )
                suffix += ' ' /*the space after the bullet*/;
 
            KoTextParag::drawFontEffects( p, format, zh, format->screenFont( zh ), textColor, xBullet + width, base, counterWidth, y,height, suffix[0] );
 
            int posY =y + base- format->offsetFromBaseLine();
            //we must move to bottom text because we create
            //shadow to 'top'.
            int sy = format->shadowY( zh );
            if ( sy < 0)
                posY -= sy;
 
            p->drawText( xBullet + width, posY, suffix, -1 );
        }
    }
    else
    {
        TQString counterText = m_layout.counter->text( this );
        // There are no bullets...any parent bullets have already been suppressed.
        // Just draw the text! Note: one space is always appended.
        if ( !counterText.isEmpty() )
        {
            KoTextParag::drawFontEffects( p, format, zh, format->screenFont( zh ), textColor, xLeft, base, counterWidth, y, height, counterText[0] );
 
            counterText += ' ' /*the space after the bullet (before in RTL mode)*/;
 
            int posY =y + base - format->offsetFromBaseLine();
            //we must move to bottom text because we create
            //shadow to 'top'.
            int sy = format->shadowY( zh );
            if ( sy < 0)
                posY -= sy;
 
            p->drawText( xLeft, posY , counterText, -1 );
        }
    }
    p->restore();
}
 
int KoTextParag::breakableTopMargin() const
{
    KoTextZoomHandler * zh = textDocument()->formattingZoomHandler();
    return zh->ptToLayoutUnitPixY(
        m_layout.margins[ TQStyleSheetItem::MarginTop ] );
}
 
int KoTextParag::topMargin() const
{
    KoTextZoomHandler * zh = textDocument()->formattingZoomHandler();
    return zh->ptToLayoutUnitPixY(
        m_layout.margins[ TQStyleSheetItem::MarginTop ]
        + ( ( prev() && prev()->joinBorder() && prev()->bottomBorder() == m_layout.bottomBorder &&
        prev()->topBorder() == m_layout.topBorder && prev()->leftBorder() == m_layout.leftBorder &&
        prev()->rightBorder() == m_layout.rightBorder) ? 0 : m_layout.topBorder.width() ) );
}
 
int KoTextParag::bottomMargin() const
{
    KoTextZoomHandler * zh = textDocument()->formattingZoomHandler();
    return zh->ptToLayoutUnitPixY(
        m_layout.margins[ TQStyleSheetItem::MarginBottom ]
        + ( ( joinBorder() && next() && next()->bottomBorder() == m_layout.bottomBorder &&
        next()->topBorder() == m_layout.topBorder && next()->leftBorder() == m_layout.leftBorder &&
        next()->rightBorder() == m_layout.rightBorder) ? 0 : m_layout.bottomBorder.width() ) );
}
 
int KoTextParag::leftMargin() const
{
    KoTextZoomHandler * zh = textDocument()->formattingZoomHandler();
    return zh->ptToLayoutUnitPixX(
        m_layout.margins[ TQStyleSheetItem::MarginLeft ]
        + m_layout.leftBorder.width() );
}
 
int KoTextParag::rightMargin() const
{
    KoTextZoomHandler * zh = textDocument()->formattingZoomHandler();
    int cw=0;
    if( m_layout.counter && str->isRightToLeft() &&
        (( m_layout.counter->alignment() == TQt::AlignRight ) || ( m_layout.counter->alignment() == TQt::AlignAuto )))
        cw = counterWidth();
 
    return zh->ptToLayoutUnitPixX(
        m_layout.margins[ TQStyleSheetItem::MarginRight ]
        + m_layout.rightBorder.width() )
        + cw; /* in layout units already */
}
 
int KoTextParag::firstLineMargin() const
{
    KoTextZoomHandler * zh = textDocument()->formattingZoomHandler();
    return zh->ptToLayoutUnitPixY(
        m_layout.margins[ TQStyleSheetItem::MarginFirstLine ] );
}
 
int KoTextParag::lineSpacing( int line ) const
{
    Q_ASSERT( isValid() );
    if ( m_layout.lineSpacingType == KoParagLayout::LS_SINGLE )
        return 0; // or shadow, see calculateLineSpacing
    else {
        if( line >= (int)lineStarts.count() )
        {
            kdError() << "KoTextParag::lineSpacing assert(line<lines) failed: line=" << line << " lines=" << lineStarts.count() << endl;
            return 0;
        }
        TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
        while ( line-- > 0 )
            ++it;
        return (*it)->lineSpacing;
    }
}
 
// Called by KoTextFormatter
int KoTextParag::calculateLineSpacing( int line, int startChar, int lastChar ) const
{
    KoTextZoomHandler * zh = textDocument()->formattingZoomHandler();
    // TODO add shadow in KoTextFormatter!
    int shadow = 0; //TQABS( zh->ptToLayoutUnitPixY( shadowDistanceY() ) );
    if ( m_layout.lineSpacingType == KoParagLayout::LS_SINGLE )
        return shadow;
    else if ( m_layout.lineSpacingType == KoParagLayout::LS_CUSTOM )
        return zh->ptToLayoutUnitPixY( m_layout.lineSpacingValue() ) + shadow;
    else {
        if( line >= (int)lineStarts.count() )
        {
            kdError() << "KoTextParag::lineSpacing assert(line<lines) failed: line=" << line << " lines=" << lineStarts.count() << endl;
            return 0+shadow;
        }
        TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
        while ( line-- > 0 )
            ++it;
 
        //kdDebug(32500) << " line spacing type: " << m_layout.lineSpacingType << " value:" << m_layout.lineSpacingValue() << " line_height=" << (*it)->h << " startChar=" << startChar << " lastChar=" << lastChar << endl;
        switch ( m_layout.lineSpacingType )
        {
        case KoParagLayout::LS_MULTIPLE:
        {
            double n = m_layout.lineSpacingValue() - 1.0; // yes, can be negative
            return shadow + tqRound( n * heightForLineSpacing( startChar, lastChar ) );
        }
        case KoParagLayout::LS_ONEANDHALF:
        {
            // Special case of LS_MULTIPLE, with n=1.5
            return shadow + heightForLineSpacing( startChar, lastChar ) / 2;
        }
        case KoParagLayout::LS_DOUBLE:
        {
            // Special case of LS_MULTIPLE, with n=1
            return shadow + heightForLineSpacing( startChar, lastChar );
        }
        case KoParagLayout::LS_AT_LEAST:
        {
            int atLeast = zh->ptToLayoutUnitPixY( m_layout.lineSpacingValue() );
            const int lineHeight = ( *it )->h;
            int h = TQMAX( lineHeight, atLeast );
            // height is now the required total height
            return shadow + h - lineHeight;
        }
        case KoParagLayout::LS_FIXED:
        {
            const int lineHeight = ( *it )->h;
            return shadow + zh->ptToLayoutUnitPixY( m_layout.lineSpacingValue() ) - lineHeight;
        }
        // Silence compiler warnings
        case KoParagLayout::LS_SINGLE:
        case KoParagLayout::LS_CUSTOM:
            break;
        }
    }
    kdWarning() << "Unhandled linespacing type : " << m_layout.lineSpacingType << endl;
    return 0+shadow;
}
 
TQRect KoTextParag::pixelRect( KoTextZoomHandler *zh ) const
{
    TQRect rct( zh->layoutUnitToPixel( rect() ) );
    //kdDebug(32500) << "   pixelRect for parag " << paragId()
    //               << ": rect=" << rect() << " pixelRect=" << rct << endl;
 
    // After division we almost always end up with the top overwriting the bottom of the parag above
    if ( prev() )
    {
        TQRect prevRect( zh->layoutUnitToPixel( prev()->rect() ) );
        if ( rct.top() < prevRect.bottom() + 1 )
        {
            //kdDebug(32500) << "   pixelRect: rct.top() adjusted to " << prevRect.bottom() + 1 << " (was " << rct.top() << ")" << endl;
            rct.setTop( prevRect.bottom() + 1 );
        }
    }
    return rct;
}
 
// Paint this paragraph. This is called by KoTextDocument::drawParagWYSIWYG
// (KoTextDocument::drawWithoutDoubleBuffer when printing)
void KoTextParag::paint( TQPainter &painter, const TQColorGroup &cg, KoTextCursor *cursor, bool drawSelections,
                         int clipx, int clipy, int clipw, int cliph )
{
#ifdef DEBUG_PAINT
    kdDebug(32500) << "KoTextParag::paint =====  id=" << paragId() << " clipx=" << clipx << " clipy=" << clipy << " clipw=" << clipw << " cliph=" << cliph << endl;
    kdDebug(32500) << " clipw in pix (approx) : " << textDocument()->paintingZoomHandler()->layoutUnitToPixelX( clipw ) << " cliph in pix (approx) : " << textDocument()->paintingZoomHandler()->layoutUnitToPixelX( cliph ) << endl;
#endif
 
    KoTextZoomHandler * zh = textDocument()->paintingZoomHandler();
    assert(zh);
 
    TQRect paraRect = pixelRect( zh );
 
    // Find left margin size, first line offset and right margin in pixels
    int leftMarginPix = zh->layoutUnitToPixelX( leftMargin() );
    int firstLineOffset = zh->layoutUnitToPixelX( firstLineMargin() );
 
    // The furthest left and right x-coords of the paragraph,
    // including the bullet/counter, but not the borders.
    int leftExtent = TQMIN ( leftMarginPix,  leftMarginPix + firstLineOffset );
    int rightExtent = paraRect.width() - zh->layoutUnitToPixelX( rightMargin() );
 
    // Draw the paragraph background color
    if ( backgroundColor().isValid() )
    {
        // Render background from either left margin indent, or first line indent,
        // whichever is nearer the left.
        int backgroundWidth = rightExtent - leftExtent + 1;
        int backgroundHeight = pixelRect( zh ).height();
        painter.fillRect( leftExtent, 0,
                          backgroundWidth, backgroundHeight,
                          backgroundColor() );
    }
 
    // Let's call drawLabel ourselves, rather than having to deal with TQStyleSheetItem to get paintLines to call it!
    if ( m_layout.counter && m_layout.counter->numbering() != KoParagCounter::NUM_NONE && m_lineChanged <= 0 )
    {
        int cy, h, baseLine;
        lineInfo( 0, cy, h, baseLine );
        int xLabel = at(0)->x;
        if ( str->isRightToLeft() )
            xLabel += at(0)->width;
        drawLabel( &painter, xLabel, cy, 0, 0, baseLine, cg );
    }
 
    paintLines( painter, cg, cursor, drawSelections, clipx, clipy, clipw, cliph );
 
    // Now draw paragraph border
    if ( m_layout.hasBorder() )
    {
        bool const drawTopBorder = !prev() || !prev()->joinBorder() || prev()->bottomBorder() != bottomBorder() || prev()->topBorder() != topBorder() || prev()->leftBorder() != leftBorder() || prev()->rightBorder() != rightBorder();
        bool const drawBottomBorder = !joinBorder() || !next() || next()->bottomBorder() != bottomBorder() || next()->topBorder() != topBorder() || next()->leftBorder() != leftBorder() || next()->rightBorder() != rightBorder();
 
        // Paragraph borders surround the paragraph and its
        // counters/bullets, but they only touch the frame border if
        // the paragraph margins are of non-zero length.
        // This is what OpenOffice does (no really, it is this time).
        //
        // drawBorders paints outside the give rect, so for the
        // x-coords, it just needs to know the left and right extent
        // of the paragraph.
        TQRect r;
        r.setLeft( leftExtent );
        r.setRight( rightExtent );
        r.setTop( zh->layoutUnitToPixelY(lineY( 0 )) );
 
        int lastLine = lines() - 1;
        // We need to start from the pixelRect, to make sure the bottom border is entirely painted.
        // This is a case where we DO want to subtract pixels to pixels...
        int paragBottom = pixelRect(zh).height()-1;
        // If we don't have a bottom border, we need go as low as possible ( to touch the next parag's border ).
        // If we have a bottom border, then we rather exclude the linespacing. Looks nicer. OO does that too.
        if ( m_layout.bottomBorder.width() > 0 && drawBottomBorder)
            paragBottom -= zh->layoutUnitToPixelY( lineSpacing( lastLine ) );
        paragBottom -= KoBorder::zoomWidthY( m_layout.bottomBorder.width(), zh, 0 );
        //kdDebug(32500) << "Parag border: paragBottom=" << paragBottom
        //               << " bottom border width = " << KoBorder::zoomWidthY( m_layout.bottomBorder.width(), zh, 0 ) << endl;
        r.setBottom( paragBottom );
 
        //kdDebug(32500) << "KoTextParag::paint documentWidth=" << documentWidth() << " LU (" << zh->layoutUnitToPixelX(documentWidth()) << " pixels) bordersRect=" << r << endl;
        KoBorder::drawBorders( painter, zh, r,
                               m_layout.leftBorder, m_layout.rightBorder, m_layout.topBorder, m_layout.bottomBorder,
                               0, TQPen(), drawTopBorder, drawBottomBorder );
    }
}
 
 
void KoTextParag::paintLines( TQPainter &painter, const TQColorGroup &cg, KoTextCursor *cursor, bool drawSelections,
            int clipx, int clipy, int clipw, int cliph )
{
    if ( !visible )
    return;
    //KoTextStringChar *chr = at( 0 );
    //if (!chr) { kdDebug(32500) << "paragraph " << (void*)this << " " << paragId() << ", can't paint, EMPTY !" << endl;
 
    // This is necessary with the current code, but in theory it shouldn't
    // be necessary, if Xft really gives us fully proportionnal chars....
#define CHECK_PIXELXADJ
 
    int curx = -1, cury = 0, curh = 0, curline = 0;
    int xstart, xend = 0;
 
    TQString qstr = str->toString();
    qstr.replace( TQChar(0x00a0U), ' ' ); // Not all fonts have non-breakable-space glyph
 
    const int nSels = doc ? doc->numSelections() : 1;
    TQMemArray<int> selectionStarts( nSels );
    TQMemArray<int> selectionEnds( nSels );
    if ( drawSelections ) {
    bool hasASelection = false;
    for ( int i = 0; i < nSels; ++i ) {
        if ( !hasSelection( i ) ) {
        selectionStarts[ i ] = -1;
        selectionEnds[ i ] = -1;
        } else {
        hasASelection = true;
        selectionStarts[ i ] = selectionStart( i );
        int end = selectionEnd( i );
        if ( end == length() - 1 && n && n->hasSelection( i ) )
            end++;
        selectionEnds[ i ] = end;
        }
    }
    if ( !hasASelection )
        drawSelections = false;
    }
 
    // Draw the lines!
    int line = m_lineChanged;
    if (line<0) line = 0;
 
    int numLines = lines();
#ifdef DEBUG_PAINT
    kdDebug(32500) << " paintLines: from line " << line << " to " << numLines-1 << endl;
#endif
    for( ; line<numLines ; line++ )
    {
    // get the start and length of the line
    int nextLine;
        int startOfLine;
        lineStartOfLine(line, &startOfLine);
    if (line == numLines-1 )
            nextLine = length();
    else
            lineStartOfLine(line+1, &nextLine);
 
    // init this line
        int cy, h, baseLine;
    lineInfo( line, cy, h, baseLine );
    if ( clipy != -1 && cy > clipy - r.y() + cliph ) // outside clip area, leave
        break;
 
        // Vars related to the current "run of text"
    int paintStart = startOfLine;
    KoTextStringChar* chr = at(startOfLine);
        KoTextStringChar* nextchr = chr;
 
    // okay, paint the line!
    for(int i=startOfLine;i<nextLine;i++)
    {
            chr = nextchr;
            if ( i < nextLine-1 )
                nextchr = at( i+1 );
 
            // we flush at end of line
            bool flush = ( i == nextLine - 1 );
            // Optimization note: TQRT uses "flush |=", which doesn't have shortcut optimization
 
            // we flush on format changes
        flush = flush || ( nextchr->format() != chr->format() );
        // we flush on link changes
        //flush = flush || ( nextchr->isLink() != chr->isLink() );
            // we flush on small caps changes
            if ( !flush && chr->format()->attributeFont() == KoTextFormat::ATT_SMALL_CAPS )
            {
                bool isLowercase = chr->c.upper() != chr->c;
                bool nextLowercase = nextchr->c.upper() != nextchr->c;
                flush = isLowercase != nextLowercase;
            }
        // we flush on start of run
        flush = flush || nextchr->startOfRun;
        // we flush on bidi changes
        flush = flush || ( nextchr->rightToLeft != chr->rightToLeft );
#ifdef CHECK_PIXELXADJ
            // we flush when the value of pixelxadj changes
            // [unless inside a ligature]
            flush = flush || ( nextchr->pixelxadj != chr->pixelxadj && nextchr->charStop );
#endif
        // we flush before and after tabs
        flush = flush || ( chr->c == '\t' || nextchr->c == '\t' );
        // we flush on soft hypens
        flush = flush || ( chr->c.unicode() == 0xad );
        // we flush on custom items
        flush = flush || chr->isCustom();
        // we flush before custom items
        flush = flush || nextchr->isCustom();
        // when painting justified we flush on spaces
        if ((alignment() & TQt::AlignJustify) == TQt::AlignJustify )
        //flush = flush || TQTextFormatter::isBreakable( str, i );
                flush = flush || chr->whiteSpace;
        // when underlining or striking "word by word" we flush before/after spaces
        if (!flush && chr->format()->wordByWord() && chr->format()->isStrikedOrUnderlined())
                flush = flush || chr->whiteSpace || nextchr->whiteSpace;
        // we flush when the string is getting too long
        flush = flush || ( i - paintStart >= 256 );
        // we flush when the selection state changes
        if ( drawSelections ) {
                // check if selection state changed - TODO update from TQRT
        bool selectionChange = false;
        if ( drawSelections ) {
            for ( int j = 0; j < nSels; ++j ) {
            selectionChange = selectionStarts[ j ] == i+1 || selectionEnds[ j ] == i+1;
            if ( selectionChange )
                break;
            }
        }
                flush = flush || selectionChange;
            }
 
            // check for cursor mark
            if ( cursor && this == cursor->parag() && i == cursor->index() ) {
                curx = cursor->x();
                curline = line;
                KoTextStringChar *c = chr;
                if ( i > 0 )
                    --c;
                curh = c->height();
                cury = cy + baseLine - c->ascent();
            }
 
            if ( flush ) {  // something changed, draw what we have so far
 
                KoTextStringChar* cStart = at( paintStart );
                if ( chr->rightToLeft ) {
                    xstart = chr->x;
                    xend = cStart->x + cStart->width;
                } else {
                    xstart = cStart->x;
                        if ( i < length() - 1 && !str->at( i + 1 ).lineStart &&
                         str->at( i + 1 ).rightToLeft == chr->rightToLeft )
                        xend = str->at( i + 1 ).x;
                    else
                        xend = chr->x + chr->width;
                }
 
                if ( (clipx == -1 || clipw == -1) || (xend >= clipx && xstart <= clipx + clipw) ) {
                    if ( !chr->isCustom() ) {
                        drawParagString( painter, qstr, paintStart, i - paintStart + 1, xstart, cy,
                                         baseLine, xend-xstart, h, drawSelections,
                                         chr->format(), selectionStarts, selectionEnds,
                                         cg, chr->rightToLeft, line );
                    }
                    else
                        if ( chr->customItem()->placement() == KoTextCustomItem::PlaceInline ) {
                            chr->customItem()->draw( &painter, chr->x, cy + baseLine - chr->customItem()->ascent(),
                                                     clipx - r.x(), clipy - r.y(), clipw, cliph, cg,
                                                     drawSelections && nSels && selectionStarts[ 0 ] <= i && selectionEnds[ 0 ] > i );
                    }
                }
                paintStart = i+1;
            }
        } // end of character loop
    } // end of line loop
 
    // if we should draw a cursor, draw it now
    if ( curx != -1 && cursor ) {
        drawCursor( painter, cursor, curx, cury, curh, cg );
    }
}
 
// Called by KoTextParag::paintLines
// Draw a set of characters with the same formattings.
// Reimplemented here to convert coordinates first, and call @ref drawFormattingChars.
void KoTextParag::drawParagString( TQPainter &painter, const TQString &str, int start, int len, int startX,
                                   int lastY, int baseLine, int bw, int h, bool drawSelections,
                                   KoTextFormat *format, const TQMemArray<int> &selectionStarts,
                                   const TQMemArray<int> &selectionEnds, const TQColorGroup &cg, bool rightToLeft, int line )
{
    KoTextZoomHandler * zh = textDocument()->paintingZoomHandler();
    assert(zh);
 
#ifdef DEBUG_PAINT
    kdDebug(32500) << "KoTextParag::drawParagString drawing from " << start << " to " << start+len << endl;
    kdDebug(32500) << " startX in LU: " << startX << " lastY in LU:" << lastY
                   << " baseLine in LU:" << baseLine << endl;
#endif
 
    // Calculate offset (e.g. due to shadow on left or top)
    // Important: don't use the 2-args methods here, offsets are not heights
    // (0 should be 0, not 1) (#63256)
    int shadowOffsetX_pix = zh->layoutUnitToPixelX( format->offsetX() );
    int shadowOffsetY_pix = zh->layoutUnitToPixelY( format->offsetY() );
 
    // Calculate startX in pixels
    int startX_pix = zh->layoutUnitToPixelX( startX ) /* + at( rightToLeft ? start+len-1 : start )->pixelxadj */;
#ifdef DEBUG_PAINT
    kdDebug(32500) << "KoTextParag::drawParagString startX in pixels : " << startX_pix /*<< " adjustment:" << at( rightToLeft ? start+len-1 : start )->pixelxadj*/ << " bw=" << bw << endl;
#endif
 
    int bw_pix = zh->layoutUnitToPixelX( startX, bw );
    int lastY_pix = zh->layoutUnitToPixelY( lastY );
    int baseLine_pix = zh->layoutUnitToPixelY( lastY, baseLine ); // 2 args=>+1. Is that correct?
    int h_pix = zh->layoutUnitToPixelY( lastY, h );
#ifdef DEBUG_PAINT
    kdDebug(32500) << "KoTextParag::drawParagString h(LU)=" << h << " lastY(LU)=" << lastY
                   << " h(PIX)=" << h_pix << " lastY(PIX)=" << lastY_pix
                   << " baseLine(PIX)=" << baseLine_pix << endl;
#endif
 
    if ( format->textBackgroundColor().isValid() )
        painter.fillRect( startX_pix, lastY_pix, bw_pix, h_pix, format->textBackgroundColor() );
 
    // don't want to draw line breaks but want them when drawing formatting chars
    int draw_len = len;
    int draw_startX = startX;
    int draw_bw = bw_pix;
    if ( at( start + len - 1 )->c == '\n' )
    {
        draw_len--;
        draw_bw -= at( start + len - 1 )->pixelwidth;
        if ( rightToLeft && draw_len > 0 )
            draw_startX = at( start + draw_len - 1 )->x;
    }
 
    // Draw selection (moved here to do it before applying the offset from the shadow)
    // (and because it's not part of the shadow drawing)
    if ( drawSelections ) {
        bool inSelection = false;
    const int nSels = doc ? doc->numSelections() : 1;
    for ( int j = 0; j < nSels; ++j ) {
        if ( start >= selectionStarts[ j ] && start < selectionEnds[ j ] ) {
                inSelection = true;
                switch (j) {
                case KoTextDocument::Standard:
                    painter.fillRect( startX_pix, lastY_pix, bw_pix, h_pix, cg.color( TQColorGroup::Highlight ) );
                    break;
                case KoTextDocument::InputMethodPreedit:
                    // no highlight
                    break;
                default:
                    painter.fillRect( startX_pix, lastY_pix, bw_pix, h_pix, doc ? doc->selectionColor( j ) : cg.color( TQColorGroup::Highlight ) );
                    break;
                }
        }
    }
        if ( !inSelection )
            drawSelections = false; // save time in drawParagStringInternal
    }
 
    // Draw InputMethod Preedit Underline
    const int nSels = doc ? doc->numSelections() : 1;
    if ( KoTextDocument::InputMethodPreedit < nSels
         && doc->hasSelection( KoTextDocument::InputMethodPreedit )
         && start >= selectionStarts[ KoTextDocument::InputMethodPreedit ]
         && start < selectionEnds[ KoTextDocument::InputMethodPreedit ] )
    {
        TQColor textColor( format->color() );
        painter.setPen( TQPen( textColor ) );
 
        TQPoint p1( startX_pix, lastY_pix + h_pix - 1 );
        TQPoint p2( startX_pix + bw_pix, lastY_pix + h_pix - 1 );
        painter.drawLine( p1, p2 );
    }
 
    if ( draw_len > 0 )
    {
        int draw_startX_pix = zh->layoutUnitToPixelX( draw_startX ) /* + at( rightToLeft ? start+draw_len-1 : start )->pixelxadj*/;
        draw_startX_pix += shadowOffsetX_pix;
        lastY_pix += shadowOffsetY_pix;
 
        if ( format->shadowDistanceX() != 0 || format->shadowDistanceY() != 0 ) {
            int sx = format->shadowX( zh );
            int sy = format->shadowY( zh );
            if ( sx != 0 || sy != 0 )
            {
                painter.save();
                painter.translate( sx, sy );
                drawParagStringInternal( painter, str, start, draw_len, draw_startX_pix,
                                         lastY_pix, baseLine_pix,
                                         draw_bw,
                                         h_pix, false /*drawSelections*/,
                                         format, selectionStarts,
                                         selectionEnds, cg, rightToLeft, line, zh, true );
                painter.restore();
            }
        }
 
        drawParagStringInternal( painter, str, start, draw_len, draw_startX_pix,
                                 lastY_pix, baseLine_pix,
                                 draw_bw,
                                 h_pix, drawSelections, format, selectionStarts,
                                 selectionEnds, cg, rightToLeft, line, zh, false );
    }
 
    bool forPrint = ( painter.device()->devType() == TQInternal::Printer );
    if ( textDocument()->drawFormattingChars() && !forPrint )
    {
        drawFormattingChars( painter, start, len,
                             lastY_pix, baseLine_pix, h_pix,
                             drawSelections,
                             format, selectionStarts,
                             selectionEnds, cg, rightToLeft,
                             line, zh, AllFormattingChars );
    }
}
 
// Copied from the original KoTextParag
// (we have to copy it here, so that color & font changes don't require changing
// a local copy of the text format)
// And we have to keep it separate from drawParagString to avoid s/startX/startX_pix/ etc.
void KoTextParag::drawParagStringInternal( TQPainter &painter, const TQString &s, int start, int len, int startX,
                                   int lastY, int baseLine, int bw, int h, bool drawSelections,
                                   KoTextFormat *format, const TQMemArray<int> &selectionStarts,
                                   const TQMemArray<int> &selectionEnds, const TQColorGroup &cg, bool rightToLeft, int line, KoTextZoomHandler* zh, bool drawingShadow )
{
#ifdef DEBUG_PAINT
    kdDebug(32500) << "KoTextParag::drawParagStringInternal start=" << start << " len=" << len << " : '" << s.mid(start,len) << "'" << endl;
    kdDebug(32500) << "In pixels:  startX=" << startX << " lastY=" << lastY << " baseLine=" << baseLine
                   << " bw=" << bw << " h=" << h << " rightToLeft=" << rightToLeft << endl;
#endif
    if ( drawingShadow && format->shadowDistanceX() == 0 && format->shadowDistanceY() == 0 )
        return;
    // 1) Sort out the color
    TQColor textColor( drawingShadow ? format->shadowColor() : format->color() );
    if ( !textColor.isValid() ) // Resolve the color at this point
        textColor = KoTextFormat::defaultTextColor( &painter );
 
    // 2) Sort out the font
    TQFont font( format->screenFont( zh ) );
    if ( format->attributeFont() == KoTextFormat::ATT_SMALL_CAPS && s[start].upper() != s[start] )
        font = format->smallCapsFont( zh, true );
 
#if 0
    TQFontInfo fi( font );
    kdDebug(32500) << "KoTextParag::drawParagStringInternal requested font " << font.pointSizeFloat() << " using font " << fi.pointSize() << "pt (format font: " << format->font().pointSizeFloat() << "pt)" << endl;
    TQFontMetrics fm( font );
    kdDebug(32500) << "Real font: " << fi.family() << ". Font height in pixels: " << fm.height() << endl;
#endif
 
    // 3) Paint
    TQString str( s );
    if ( str[ (int)str.length() - 1 ].unicode() == 0xad )
        str.remove( str.length() - 1, 1 );
    painter.setPen( TQPen( textColor ) );
    painter.setFont( font );
 
    KoTextDocument* doc = document();
 
    if ( drawSelections ) {
    const int nSels = doc ? doc->numSelections() : 1;
    for ( int j = 0; j < nSels; ++j ) {
        if ( start >= selectionStarts[ j ] && start < selectionEnds[ j ] ) {
        if ( !doc || doc->invertSelectionText( j ) )
            textColor = cg.color( TQColorGroup::HighlightedText );
            painter.setPen( TQPen( textColor ) );
                    break;
            }
        }
    }
 
    TQPainter::TextDirection dir = rightToLeft ? TQPainter::RTL : TQPainter::LTR;
 
    if ( dir != TQPainter::RTL && start + len == length() ) // don't draw the last character (trailing space)
    {
       len--;
       if ( len <= 0 )
           return;
       bw-=at(length()-1)->pixelwidth;
    }
    KoTextParag::drawFontEffects( &painter, format, zh, font, textColor, startX, baseLine, bw, lastY, h, str[start] );
 
    if ( str[ start ] != '\t' && str[ start ].unicode() != 0xad ) {
        str = format->displayedString( str ); // #### This converts the whole string, instead of from start to start+len!
    if ( format->vAlign() == KoTextFormat::AlignNormal ) {
            int posY = lastY + baseLine;
            //we must move to bottom text because we create
            //shadow to 'top'.
            int sy = format->shadowY( zh );
            if ( sy < 0)
                posY -= sy;
        painter.drawText( startX, posY, str, start, len, dir );
#ifdef BIDI_DEBUG
        painter.save();
        painter.setPen ( TQt::red );
        painter.drawLine( startX, lastY, startX, lastY + baseLine );
        painter.drawLine( startX, lastY + baseLine/2, startX + 10, lastY + baseLine/2 );
        int w = 0;
        int i = 0;
        while( i < len )
        w += painter.fontMetrics().charWidth( str, start + i++ );
        painter.setPen ( TQt::blue );
        painter.drawLine( startX + w - 1, lastY, startX + w - 1, lastY + baseLine );
        painter.drawLine( startX + w - 1, lastY + baseLine/2, startX + w - 1 - 10, lastY + baseLine/2 );
        painter.restore();
#endif
    } else if ( format->vAlign() == KoTextFormat::AlignSuperScript ) {
            int posY =lastY + baseLine - ( painter.fontMetrics().height() / 2 );
            //we must move to bottom text because we create
            //shadow to 'top'.
            int sy = format->shadowY( zh );
            if ( sy < 0)
                posY -= sy;
        painter.drawText( startX, posY, str, start, len, dir );
    } else if ( format->vAlign() == KoTextFormat::AlignSubScript ) {
            int posY =lastY + baseLine + ( painter.fontMetrics().height() / 6 );
            //we must move to bottom text because we create
            //shadow to 'top'.
            int sy = format->shadowY( zh );
            if ( sy < 0)
                posY -= sy;
        painter.drawText( startX, posY, str, start, len, dir );
    } else if ( format->vAlign() == KoTextFormat::AlignCustom ) {
            int posY = lastY + baseLine - format->offsetFromBaseLine();
            //we must move to bottom text because we create
            //shadow to 'top'.
            int sy = format->shadowY( zh );
            if ( sy < 0)
                posY -= sy;
        painter.drawText( startX, posY, str, start, len, dir );
    }
    }
    if ( str[ start ] == '\t' && m_tabCache.contains( start ) ) {
    painter.save();
    KoTextZoomHandler * zh = textDocument()->paintingZoomHandler();
    const KoTabulator& tab = m_layout.tabList()[ m_tabCache[ start ] ];
    int lineWidth = zh->zoomItY( tab.ptWidth );
    switch ( tab.filling ) {
        case TF_DOTS:
        painter.setPen( TQPen( textColor, lineWidth, TQt::DotLine ) );
        painter.drawLine( startX, lastY + baseLine, startX + bw, lastY + baseLine );
        break;
        case TF_LINE:
        painter.setPen( TQPen( textColor, lineWidth, TQt::SolidLine ) );
        painter.drawLine( startX, lastY + baseLine, startX + bw, lastY + baseLine );
                break;
            case TF_DASH:
        painter.setPen( TQPen( textColor, lineWidth, TQt::DashLine ) );
        painter.drawLine( startX, lastY + baseLine, startX + bw, lastY + baseLine );
        break;
            case TF_DASH_DOT:
        painter.setPen( TQPen( textColor, lineWidth, TQt::DashDotLine ) );
        painter.drawLine( startX, lastY + baseLine, startX + bw, lastY + baseLine );
        break;
            case TF_DASH_DOT_DOT:
        painter.setPen( TQPen( textColor, lineWidth, TQt::DashDotDotLine ) );
        painter.drawLine( startX, lastY + baseLine, startX + bw, lastY + baseLine );
        break;
 
            default:
                break;
    }
    painter.restore();
    }
 
    if ( start+len < length() && at( start+len )->lineStart )
    {
#ifdef DEBUG_PAINT
        //kdDebug(32500) << "we are drawing the end of line " << line << ". Auto-hyphenated: " << lineHyphenated( line ) << endl;
#endif
        bool drawHyphen = at( start+len-1 )->c.unicode() == 0xad;
        drawHyphen = drawHyphen || lineHyphenated( line );
        if ( drawHyphen ) {
#ifdef DEBUG_PAINT
            kdDebug(32500) << "drawing hyphen at x=" << startX+bw << endl;
#endif
            painter.drawText( startX + bw, lastY + baseLine, TQString("-") ); // \xad gives squares with some fonts (!?)
        }
    }
 
    // Paint a zigzag line for "wrong" background spellchecking checked words:
    if(
        painter.device()->devType() != TQInternal::Printer &&
        format->isMisspelled() &&
        !drawingShadow &&
        textDocument()->drawingMissingSpellLine() )
    {
        painter.save();
        painter.setPen( TQPen( TQt::red, 1 ) );
 
        // Draw 3 pixel lines with increasing offset and distance 4:
        for( int zigzag_line = 0; zigzag_line < 3; ++zigzag_line )
        {
            for( int zigzag_x = zigzag_line; zigzag_x < bw; zigzag_x += 4 )
            {
                painter.drawPoint(
                    startX + zigzag_x,
                    lastY + baseLine + h/12 - 1 + zigzag_line );
            }
        }
 
        // "Double" the pixel number for the middle line:
        for( int zigzag_x = 3; zigzag_x < bw; zigzag_x += 4 )
        {
            painter.drawPoint(
                startX + zigzag_x,
                lastY + baseLine + h/12 );
        }
 
        painter.restore();
    }
}
 
bool KoTextParag::lineHyphenated( int l ) const
{
    if ( l > (int)lineStarts.count() - 1 ) {
    kdWarning() << "KoTextParag::lineHyphenated: line " << l << " out of range!" << endl;
    return false;
    }
 
    if ( !isValid() )
    const_cast<KoTextParag*>(this)->format();
 
    TQMap<int, KoTextParagLineStart*>::ConstIterator it = lineStarts.begin();
    while ( l-- > 0 )
    ++it;
    return ( *it )->hyphenated;
}

void KoTextParag::drawCursor( TQPainter &painter, KoTextCursor *cursor, int curx, int cury, int curh, const TQColorGroup &cg )
{
    KoTextZoomHandler * zh = textDocument()->paintingZoomHandler();
    int x = zh->layoutUnitToPixelX( curx ) /*+ cursor->parag()->at( cursor->index() )->pixelxadj*/;
    //kdDebug(32500) << "  drawCursor: LU: [cur]x=" << curx << ", cury=" << cury << " -> PIX: x=" << x << ", y=" << zh->layoutUnitToPixelY( cury ) << endl;
    KoTextParag::drawCursorDefault( painter, cursor, x,
                            zh->layoutUnitToPixelY( cury ),
                            zh->layoutUnitToPixelY( cury, curh ), cg );
}
 
// Reimplemented from KoTextParag
void KoTextParag::copyParagData( KoTextParag *parag )
{
    // Style of the previous paragraph
    KoParagStyle * style = parag->style();
    // Obey "following style" setting
    bool styleApplied = false;
    if ( style )
    {
        KoParagStyle * newStyle = style->followingStyle();
        if ( newStyle && style != newStyle ) // if same style, keep paragraph-specific changes as usual
        {
            setParagLayout( newStyle->paragLayout() );
            KoTextFormat * format = &newStyle->format();
            setFormat( format );
            format->addRef();
            str->setFormat( 0, format, true ); // prepare format for text insertion
            styleApplied = true;
        }
    }
    // This should never happen in KWord, but it happens in KPresenter
    //else
    //    kdWarning() << "Paragraph has no style " << paragId() << endl;
 
    // No "following style" setting, or same style -> copy layout & format of previous paragraph
    if (!styleApplied)
    {
        setParagLayout( parag->paragLayout() );
        // Remove pagebreak flags from initial parag - they got copied to the new parag
        parag->m_layout.pageBreaking &= ~KoParagLayout::HardFrameBreakBefore;
        parag->m_layout.pageBreaking &= ~KoParagLayout::HardFrameBreakAfter;
        // Remove footnote counter text from second parag
        if ( m_layout.counter && m_layout.counter->numbering() == KoParagCounter::NUM_FOOTNOTE )
            setNoCounter();
        // Do not copy 'restart numbering at this paragraph' option (would be silly)
        if ( m_layout.counter )
            m_layout.counter->setRestartCounter(false);
 
        // set parag format to the format of the trailing space of the previous parag
        setFormat( parag->at( parag->length()-1 )->format() );
        // KoTextCursor::splitAndInsertEmptyParag takes care of setting the format
        // for the chars in the new parag
    }
 
    // Note: we don't call the original KoTextParag::copyParagData on purpose.
    // We don't want setListStyle to get called - it ruins our stylesheetitems
    // And we don't care about copying the stylesheetitems directly,
    // applying the parag layout will create them
}
 
void KoTextParag::setTabList( const KoTabulatorList &tabList )
{
    KoTabulatorList lst( tabList );
    m_layout.setTabList( lst );
    if ( !tabList.isEmpty() )
    {
        KoTextZoomHandler* zh = textDocument()->formattingZoomHandler();
        int * tabs = new int[ tabList.count() + 1 ]; // will be deleted by ~KoTextParag
        KoTabulatorList::Iterator it = lst.begin();
        unsigned int i = 0;
        for ( ; it != lst.end() ; ++it, ++i )
            tabs[i] = zh->ptToLayoutUnitPixX( (*it).ptPos );
        tabs[i] = 0;
        assert( i == tabList.count() );
        setTabArray( tabs );
    } else
    {
        setTabArray( 0 );
    }
    invalidate( 0 );
}

int KoTextParag::nextTab( int chnum, int x, int availableWidth )
{
    if ( !m_layout.tabList().isEmpty() )
    {
        // Fetch the zoomed and sorted tab positions from KoTextParag
        // We stored them there for faster access
        int * tArray = tabArray();
        int i = 0;
        if ( str->isRightToLeft() )
            i = m_layout.tabList().size() - 1;
        KoTextZoomHandler* zh = textDocument()->formattingZoomHandler();
 
        while ( i >= 0 && i < (int)m_layout.tabList().size() ) {
            //kdDebug(32500) << "KoTextParag::nextTab tArray[" << i << "]=" << tArray[i] << " type " << m_layout.tabList()[i].type << endl;
            int tab = tArray[ i ];
 
            // If a right-aligned tab is after the right edge then assume
            // that it -is- on the right edge, otherwise the last letters will fall off.
            // This is compatible with OOo's behavior.
            if ( tab > availableWidth ) {
                //kdDebug(32500) << "Tab position adjusted to availableWidth=" << availableWidth << endl;
                tab = availableWidth;
            }
 
            if ( str->isRightToLeft() )
                tab = availableWidth - tab;
 
            if ( tab > x ) {
                int type = m_layout.tabList()[i].type;
 
                // fix the tab type for right to left text
                if ( str->isRightToLeft() )
                    if ( type == T_RIGHT )
                        type = T_LEFT;
                    else if ( type == T_LEFT )
                        type = T_RIGHT;
 
                switch ( type ) {
                case T_RIGHT:
                case T_CENTER:
                {
                    // Look for the next tab (or EOL)
                    int c = chnum + 1;
                    int w = 0;
                    while ( c < str->length() - 1 && str->at( c ).c != '\t' && str->at( c ).c != '\n' )
                    {
                        KoTextStringChar & ch = str->at( c );
                        // Determine char width
                        // This must be done in the same way as in KoTextFormatter::format() or there can be different rounding errors.
                        if ( ch.isCustom() )
                            w += ch.customItem()->width;
                        else
                        {
                            KoTextFormat *charFormat = ch.format();
                            int ww = charFormat->charWidth( zh, false, &ch, this, c );
                            ww = KoTextZoomHandler::ptToLayoutUnitPt( ww );
                            w += ww;
                        }
                        ++c;
                    }
 
                    m_tabCache[chnum] = i;
 
                    if ( type == T_RIGHT )
                        return tab - w;
                    else // T_CENTER
                        return tab - w/2;
                }
                case T_DEC_PNT:
                {
                    // Look for the next tab (or EOL), and for alignChar
                    // Default to right-aligned if no decimal point found (behavior from msword)
                    int c = chnum + 1;
                    int w = 0;
                    while ( c < str->length()-1 && str->at( c ).c != '\t' && str->at( c ).c != '\n' )
                    {
                        KoTextStringChar & ch = str->at( c );
                        if ( ch.c == m_layout.tabList()[i].alignChar )
                        {
                            // Can't use ch.width yet, since the formatter hasn't run over those chars
                            int ww = ch.format()->charWidth( zh, false, &ch, this, c );
                            ww = KoTextZoomHandler::ptToLayoutUnitPt( ww );
                            if ( str->isRightToLeft() )
                            {
                                w = ww / 2; // center around the decimal point
                                ++c;
                                continue;
                            }
                            else
                            {
                                w += ww / 2; // center around the decimal point
                                break;
                            }
                        }
 
                        // Determine char width
                        if ( ch.isCustom() )
                            w += ch.customItem()->width;
                        else
                        {
                            int ww = ch.format()->charWidth( zh, false, &ch, this, c );
                            w += KoTextZoomHandler::ptToLayoutUnitPt( ww );
                        }
 
                        ++c;
                    }
                    m_tabCache[chnum] = i;
                    return tab - w;
                }
                default: // case T_LEFT:
                    m_tabCache[chnum] = i;
                    return tab;
                }
            }
            if ( str->isRightToLeft() )
                --i;
            else
                ++i;
        }
    }
    // No tab list, use tab-stop-width. qrichtext.cpp has the code :)
    return KoTextParag::nextTabDefault( chnum, x );
}
 
void KoTextParag::applyStyle( KoParagStyle *style )
{
    setParagLayout( style->paragLayout() );
    KoTextFormat *newFormat = &style->format();
    setFormat( 0, str->length(), newFormat );
    setFormat( newFormat );
}
 
void KoTextParag::setParagLayout( const KoParagLayout & layout, int flags, int marginIndex )
{
    //kdDebug(32500) << "KoTextParag::setParagLayout flags=" << flags << endl;
    if ( flags & KoParagLayout::Alignment )
        setAlign( layout.alignment );
    if ( flags & KoParagLayout::Margins ) {
        if ( marginIndex == -1 )
            setMargins( layout.margins );
        else
            setMargin( (TQStyleSheetItem::Margin)marginIndex, layout.margins[marginIndex] );
    }
    if ( flags & KoParagLayout::LineSpacing )
    {
        setLineSpacingType( layout.lineSpacingType );
        setLineSpacing( layout.lineSpacingValue() );
    }
    if ( flags & KoParagLayout::Borders )
    {
        setLeftBorder( layout.leftBorder );
        setRightBorder( layout.rightBorder );
        setTopBorder( layout.topBorder );
        setBottomBorder( layout.bottomBorder );
        setJoinBorder( layout.joinBorder );
    }
    if ( flags & KoParagLayout::BackgroundColor )
    {
        setBackgroundColor( layout.backgroundColor );
    }
    if ( flags & KoParagLayout::BulletNumber )
        setCounter( layout.counter );
    if ( flags & KoParagLayout::Tabulator )
        setTabList( layout.tabList() );
    if ( flags == KoParagLayout::All )
    {
        setDirection( static_cast<TQChar::Direction>(layout.direction) );
        // Don't call applyStyle from here, it would overwrite any paragraph-specific settings
        setStyle( layout.style );
    }
}
 
void KoTextParag::setCustomItem( int index, KoTextCustomItem * custom, KoTextFormat * currentFormat )
{
    //kdDebug(32500) << "KoTextParag::setCustomItem " << index << "  " << (void*)custom
    //               << "  currentFormat=" << (void*)currentFormat << endl;
    if ( currentFormat )
        setFormat( index, 1, currentFormat );
    at( index )->setCustomItem( custom );
    //addCustomItem();
    document()->registerCustomItem( custom, this );
    custom->recalc(); // calc value (e.g. for variables) and set initial size
    invalidate( 0 );
    setChanged( true );
}
 
void KoTextParag::removeCustomItem( int index )
{
    Q_ASSERT( at( index )->isCustom() );
    KoTextCustomItem * item = at( index )->customItem();
    at( index )->loseCustomItem();
    //KoTextParag::removeCustomItem();
    document()->unregisterCustomItem( item, this );
}
 
 
int KoTextParag::findCustomItem( const KoTextCustomItem * custom ) const
{
    int len = str->length();
    for ( int i = 0; i < len; ++i )
    {
        KoTextStringChar & ch = str->at(i);
        if ( ch.isCustom() && ch.customItem() == custom )
            return i;
    }
    kdWarning() << "KoTextParag::findCustomItem custom item " << (void*)custom
              << " not found in paragraph " << paragId() << endl;
    return 0;
}
 
#ifndef NDEBUG
void KoTextParag::printRTDebug( int info )
{
    TQString specialFlags;
    if ( str->needsSpellCheck() )
        specialFlags += " needsSpellCheck=true";
    if ( wasMovedDown() )
        specialFlags += " wasMovedDown=true";
    if ( partOfTableOfContents() )
        specialFlags += " part-of-TOC=true";
    kdDebug(32500) << "Paragraph " << this << " (" << paragId() << ") [changed="
              << hasChanged() << ", valid=" << isValid()
              << specialFlags
              << "] ------------------ " << endl;
    if ( prev() && prev()->paragId() + 1 != paragId() )
        kdWarning() << "  Previous paragraph " << prev() << " has ID " << prev()->paragId() << endl;
    if ( next() && next()->paragId() != paragId() + 1 )
        kdWarning() << "  Next paragraph " << next() << " has ID " << next()->paragId() << endl;
    //if ( !next() )
    //    kdDebug(32500) << "  next is 0L" << endl;
    kdDebug(32500) << "  Style: " << style() << " " << ( style() ? style()->name().local8Bit().data() : "NO STYLE" ) << endl;
    kdDebug(32500) << "  Text: '" << str->toString() << "'" << endl;
    if ( info == 0 ) // paragraph info
    {
        if ( m_layout.counter )
        {
            m_layout.counter->printRTDebug( this );
        }
        static const char * const s_align[] = { "Auto", "Left", "Right", "ERROR", "HCenter", "ERR", "ERR", "ERR", "Justify", };
        static const char * const s_linespacing[] = { "Single", "1.5", "2", "custom", "atLeast", "Multiple", "Fixed" };
        static const char * const s_dir[] = { "DirL", "DirR", "DirEN", "DirES", "DirET", "DirAN", "DirCS", "DirB", "DirS", "DirWS", "DirON", "DirLRE", "DirLRO", "DirAL", "DirRLE", "DirRLO", "DirPDF", "DirNSM", "DirBN" };
        kdDebug(32500) << "  align: " << s_align[alignment()] << "  resolveAlignment: " << s_align[resolveAlignment()]
                  << "  isRTL:" << str->isRightToLeft()
                  << "  dir: " << s_dir[direction()] << endl;
        TQRect pixr = pixelRect( textDocument()->paintingZoomHandler() );
        kdDebug(32500) << "  rect() : " << DEBUGRECT( rect() )
                  << "  pixelRect() : " << DEBUGRECT( pixr ) << endl;
        kdDebug(32500) << "  topMargin()=" << topMargin()
                       << " breakableTopMargin()=" << breakableTopMargin()
                       << " bottomMargin()=" << bottomMargin()
                  << " leftMargin()=" << leftMargin() << " firstLineMargin()=" << firstLineMargin()
                  << " rightMargin()=" << rightMargin() << endl;
        if ( kwLineSpacingType() != KoParagLayout::LS_SINGLE )
            kdDebug(32500) << "  linespacing type=" << s_linespacing[ -kwLineSpacingType() ]
                           << " value=" << kwLineSpacing() << endl;
        const int pageBreaking = m_layout.pageBreaking;
        TQStringList pageBreakingFlags;
        if ( pageBreaking & KoParagLayout::KeepLinesTogether )
            pageBreakingFlags.append( "KeepLinesTogether" );
        if ( pageBreaking & KoParagLayout::HardFrameBreakBefore )
            pageBreakingFlags.append( "HardFrameBreakBefore" );
        if ( pageBreaking & KoParagLayout::HardFrameBreakAfter )
            pageBreakingFlags.append( "HardFrameBreakAfter" );
        if ( pageBreaking & KoParagLayout::KeepWithPrevious )
            pageBreakingFlags.append( "KeepWithPrevious" );
        if ( pageBreaking & KoParagLayout::KeepWithNext )
            pageBreakingFlags.append( "KeepWithNext" );
        if ( !pageBreakingFlags.isEmpty() )
            kdDebug(32500) << " page Breaking: " << pageBreakingFlags.join(",") << endl;
 
        static const char * const tabtype[] = { "T_LEFT", "T_CENTER", "T_RIGHT", "T_DEC_PNT", "error!!!" };
        KoTabulatorList tabList = m_layout.tabList();
        if ( tabList.isEmpty() ) {
            if ( str->toString().find( '\t' ) != -1 )
                kdDebug(32500) << "Tab width: " << textDocument()->tabStopWidth() << endl;
        } else {
            KoTabulatorList::Iterator it = tabList.begin();
            for ( ; it != tabList.end() ; it++ )
                kdDebug(32500) << "Tab type:" << tabtype[(*it).type] << " at: " << (*it).ptPos << endl;
        }
    } else if ( info == 1 ) // formatting info
    {
        kdDebug(32500) << "  Paragraph format=" << paragFormat() << " " << paragFormat()->key()
                  << " fontsize:" << dynamic_cast<KoTextFormat *>(paragFormat())->pointSize() << endl;
 
        for ( int line = 0 ; line < lines(); ++ line ) {
            int y, h, baseLine;
            lineInfo( line, y, h, baseLine );
            int startOfLine;
            lineStartOfLine( line, &startOfLine );
            kdDebug(32500) << "  Line " << line << " y=" << y << " height=" << h << " baseLine=" << baseLine << " startOfLine(index)=" << startOfLine << endl;
        }
        kdDebug(32500) << endl;
        KoTextString * s = string();
        int lastX = 0; // pixels
        int lastW = 0; // pixels
        for ( int i = 0 ; i < s->length() ; ++i )
        {
            KoTextStringChar & ch = s->at(i);
            int pixelx =  textDocument()->formattingZoomHandler()->layoutUnitToPixelX( ch.x )
                          + ch.pixelxadj;
            if ( ch.lineStart )
                kdDebug(32500) << "LINESTART" << endl;
            TQString attrs = " ";
            if ( ch.whiteSpace )
                attrs += "whitespace ";
            if ( !ch.charStop )
                attrs += "notCharStop ";
            if ( ch.wordStop )
                attrs += "wordStop ";
            attrs.truncate( attrs.length() - 1 );
 
            kdDebug(32500) << i << ": '" << TQString(ch.c).rightJustify(2)
                           << "' (" << TQString::number( ch.c.unicode() ).rightJustify(3) << ")"
                      << " x(LU)=" << ch.x
                      << " w(LU)=" << ch.width//s->width(i)
                      << " x(PIX)=" << pixelx
                      << " (xadj=" << + ch.pixelxadj << ")"
                      << " w(PIX)=" << ch.pixelwidth
                      << " height=" << ch.height()
                      << attrs
                //      << " format=" << ch.format()
                //      << " \"" << ch.format()->key() << "\" "
                //<< " fontsize:" << dynamic_cast<KoTextFormat *>(ch.format())->pointSize()
                      << endl;
 
        // Check that the format is in the collection (i.e. its defaultFormat or in the dict)
        if ( ch.format() != textDocument()->formatCollection()->defaultFormat() )
                Q_ASSERT( textDocument()->formatCollection()->dict()[ch.format()->key()] );
 
            if ( !str->isBidi() && !ch.lineStart )
                Q_ASSERT( lastX + lastW == pixelx ); // looks like some rounding problem with justified spaces
            lastX = pixelx;
            lastW = ch.pixelwidth;
            if ( ch.isCustom() )
            {
                KoTextCustomItem * item = ch.customItem();
                kdDebug(32500) << " - custom item " << item
                          << " ownline=" << item->ownLine()
                          << " size=" << item->width << "x" << item->height
                          << " ascent=" << item->ascent()
                          << endl;
            }
        }
    }
}
#endif
 
void KoTextParag::drawFontEffects( TQPainter * p, KoTextFormat *format, KoTextZoomHandler *zh, TQFont font, const TQColor & color, int startX, int baseLine, int bw, int lastY, int /*h*/, TQChar firstChar )
{
    // This is about drawing underlines and strikeouts
    // So abort immediately if there's none to draw.
    if ( !format->isStrikedOrUnderlined() )
        return;
    //kdDebug(32500) << "drawFontEffects wordByWord=" << format->wordByWord() <<
    //    " firstChar='" << TQString(firstChar) << "'" << endl;
    // paintLines ensures that we're called word by word if wordByWord is true.
    if ( format->wordByWord() && firstChar.isSpace() )
        return;
 
    double dimd;
    int y;
    int offset = 0;
    if (format->vAlign() == KoTextFormat::AlignSubScript )
        offset = p->fontMetrics().height() / 6;
    else if (format->vAlign() == KoTextFormat::AlignSuperScript )
        offset = -p->fontMetrics().height() / 2;
 
    dimd = KoBorder::zoomWidthY( format->underLineWidth(), zh, 1 );
    if((format->vAlign() == KoTextFormat::AlignSuperScript) ||
    (format->vAlign() == KoTextFormat::AlignSubScript ) || (format->vAlign() == KoTextFormat::AlignCustom ))
    dimd*=format->relativeTextSize();
    y = lastY + baseLine + offset - ( (format->vAlign() == KoTextFormat::AlignCustom)?format->offsetFromBaseLine():0 );
 
    if ( format->doubleUnderline())
    {
        TQColor col = format->textUnderlineColor().isValid() ? format->textUnderlineColor(): color ;
    int dim=static_cast<int>(0.75*dimd);
    dim=dim?dim:1; //width of line should be at least 1
        p->save();
 
        switch( format->underlineStyle())
        {
        case KoTextFormat::U_SOLID:
            p->setPen( TQPen( col, dim, TQt::SolidLine ) );
            break;
        case KoTextFormat::U_DASH:
            p->setPen( TQPen( col, dim, TQt::DashLine ) );
            break;
        case KoTextFormat::U_DOT:
            p->setPen( TQPen( col, dim, TQt::DotLine ) );
            break;
        case KoTextFormat::U_DASH_DOT:
            p->setPen( TQPen( col, dim, TQt::DashDotLine ) );
            break;
        case KoTextFormat::U_DASH_DOT_DOT:
            p->setPen( TQPen( col, dim, TQt::DashDotDotLine ) );
            break;
        default:
            p->setPen( TQPen( color, dim, TQt::SolidLine ) );
        }
 
        y += static_cast<int>(1.125*dimd); // slightly under the baseline if possible
        p->drawLine( startX, y, startX + bw, y );
        y += static_cast<int>(1.5*dimd);
        p->drawLine( startX, y, startX + bw, y );
        p->restore();
        if ( font.underline() ) { // can this happen?
            font.setUnderline( false );
            p->setFont( font );
        }
    }
    else if ( format->underline() ||
                format->underlineType() == KoTextFormat::U_SIMPLE_BOLD)
    {
 
        TQColor col = format->textUnderlineColor().isValid() ? format->textUnderlineColor(): color ;
        p->save();
    int dim=(format->underlineType() == KoTextFormat::U_SIMPLE_BOLD)?static_cast<int>(2*dimd):static_cast<int>(dimd);
    dim=dim?dim:1; //width of line should be at least 1
        y += static_cast<int>(1.875*dimd);
 
        switch( format->underlineStyle() )
        {
        case KoTextFormat::U_SOLID:
            p->setPen( TQPen( col, dim, TQt::SolidLine ) );
            break;
        case KoTextFormat::U_DASH:
            p->setPen( TQPen( col, dim, TQt::DashLine ) );
            break;
        case KoTextFormat::U_DOT:
            p->setPen( TQPen( col, dim, TQt::DotLine ) );
            break;
        case KoTextFormat::U_DASH_DOT:
            p->setPen( TQPen( col, dim, TQt::DashDotLine ) );
            break;
        case KoTextFormat::U_DASH_DOT_DOT:
            p->setPen( TQPen( col, dim, TQt::DashDotDotLine ) );
            break;
        default:
            p->setPen( TQPen( col, dim, TQt::SolidLine ) );
        }
 
        p->drawLine( startX, y, startX + bw, y );
        p->restore();
        font.setUnderline( false );
        p->setFont( font );
    }
    else if ( format->waveUnderline() )
    {
    int dim=static_cast<int>(dimd);
    dim=dim?dim:1; //width of line should be at least 1
        y += dim;
        TQColor col = format->textUnderlineColor().isValid() ? format->textUnderlineColor(): color ;
        p->save();
    int offset = 2 * dim;
    TQPen pen(col, dim, TQt::SolidLine);
    pen.setCapStyle(TQt::RoundCap);
    p->setPen(pen);
    Q_ASSERT(offset);
    double anc=acos(1.0-2*(static_cast<double>(offset-(startX)%offset)/static_cast<double>(offset)))/3.1415*180;
    int pos=1;
    //set starting position
    if(2*((startX/offset)/2)==startX/offset)
        pos*=-1;
    //draw first part of wave
    p->drawArc( (startX/offset)*offset, y, offset, offset, 0, -tqRound(pos*anc*16) );
        //now the main part
    int zigzag_x = (startX/offset+1)*offset;
    for ( ; zigzag_x + offset <= bw+startX; zigzag_x += offset)
        {
        p->drawArc( zigzag_x, y, offset, offset, 0, pos*180*16 );
        pos*=-1;
        }
    //and here we finish
    anc=acos(1.0-2*(static_cast<double>((startX+bw)%offset)/static_cast<double>(offset)))/3.1415*180;
    p->drawArc( zigzag_x, y, offset, offset, 180*16, -tqRound(pos*anc*16) );
    p->restore();
        font.setUnderline( false );
        p->setFont( font );
    }
 
    dimd = KoBorder::zoomWidthY( static_cast<double>(format->pointSize())/18.0, zh, 1 );
    if((format->vAlign() == KoTextFormat::AlignSuperScript) ||
    (format->vAlign() == KoTextFormat::AlignSubScript ) || (format->vAlign() == KoTextFormat::AlignCustom ))
    dimd*=format->relativeTextSize();
    y = lastY + baseLine + offset - ( (format->vAlign() == KoTextFormat::AlignCustom)?format->offsetFromBaseLine():0 );
 
    if ( format->strikeOutType() == KoTextFormat::S_SIMPLE
         || format->strikeOutType() == KoTextFormat::S_SIMPLE_BOLD)
    {
        unsigned int dim = (format->strikeOutType() == KoTextFormat::S_SIMPLE_BOLD)? static_cast<int>(2*dimd) : static_cast<int>(dimd);
        p->save();
 
        switch( format->strikeOutStyle() )
        {
        case KoTextFormat::S_SOLID:
            p->setPen( TQPen( color, dim, TQt::SolidLine ) );
            break;
        case KoTextFormat::S_DASH:
            p->setPen( TQPen( color, dim, TQt::DashLine ) );
            break;
        case KoTextFormat::S_DOT:
            p->setPen( TQPen( color, dim, TQt::DotLine ) );
            break;
        case KoTextFormat::S_DASH_DOT:
            p->setPen( TQPen( color, dim, TQt::DashDotLine ) );
            break;
        case KoTextFormat::S_DASH_DOT_DOT:
            p->setPen( TQPen( color, dim, TQt::DashDotDotLine ) );
            break;
        default:
            p->setPen( TQPen( color, dim, TQt::SolidLine ) );
        }
 
        y -= static_cast<int>(5*dimd);
        p->drawLine( startX, y, startX + bw, y );
        p->restore();
        font.setStrikeOut( false );
        p->setFont( font );
    }
    else if ( format->strikeOutType() == KoTextFormat::S_DOUBLE )
    {
        unsigned int dim = static_cast<int>(dimd);
        p->save();
 
        switch( format->strikeOutStyle() )
        {
        case KoTextFormat::S_SOLID:
            p->setPen( TQPen( color, dim, TQt::SolidLine ) );
            break;
        case KoTextFormat::S_DASH:
            p->setPen( TQPen( color, dim, TQt::DashLine ) );
            break;
        case KoTextFormat::S_DOT:
            p->setPen( TQPen( color, dim, TQt::DotLine ) );
            break;
        case KoTextFormat::S_DASH_DOT:
            p->setPen( TQPen( color, dim, TQt::DashDotLine ) );
            break;
        case KoTextFormat::S_DASH_DOT_DOT:
            p->setPen( TQPen( color, dim, TQt::DashDotDotLine ) );
            break;
        default:
            p->setPen( TQPen( color, dim, TQt::SolidLine ) );
        }
 
    y -= static_cast<int>(4*dimd);
        p->drawLine( startX, y, startX + bw, y);
    y -= static_cast<int>(2*dimd);
        p->drawLine( startX, y, startX + bw, y);
        p->restore();
        font.setStrikeOut( false );
        p->setFont( font );
    }
 
}
 
// ### is this method correct for RTL text?
TQString KoTextParag::toString( int from, int length ) const
{
    TQString str;
    if ( from == 0 && m_layout.counter && m_layout.counter->numbering() != KoParagCounter::NUM_FOOTNOTE )
        str += m_layout.counter->text( this ) + ' ';
    if ( length == -1 )
        length = this->length() - 1 /*trailing space*/ - from;
    for ( int i = from ; i < (length+from) ; ++i )
    {
        KoTextStringChar *ch = at( i );
        if ( ch->isCustom() )
        {
            KoVariable * var = dynamic_cast<KoVariable *>(ch->customItem());
            if ( var )
                str += var->text(true);
            else //frame inline
                str +=' ';
        }
        else
            str += ch->c;
    }
    return str;
}
 
// we cannot use TQString::simplifyWhiteSpace() because it removes
// leading and trailing whitespace, but such whitespace is significant
// in ODF -- so we use this function to compress sequences of space characters
// into single spaces
static TQString normalizeWhitespace( const TQString& in, bool leadingSpace )
{
    TQString text = in;
    int r, w = 0;
    int len = text.length();
 
    for ( r = 0; r < len; ++r )
    {
        TQCharRef ch = text[r];
 
        // check for space, tab, line feed, carriage return
        if ( ch == ' ' || ch == '\t' ||ch == '\r' ||  ch == '\n')
        {
            // if we were lead by whitespace in some parent or previous sibling element,
            // we completely collapse this space
            if ( r != 0 || !leadingSpace )
                text[w++] = TQChar( ' ' );
 
            // find the end of the whitespace run
            while ( r < len && text[r].isSpace() )
                ++r;
 
            // and then record the next non-whitespace character
            if ( r < len )
               text[w++] = text[r];
        }
        else
        {
            text[w++] = ch;
        }
    }
 
    // and now trim off the unused part of the string
    text.truncate(w);
 
    return text;
}
 
void KoTextParag::loadOasisSpan( const TQDomElement& parent, KoOasisContext& context, uint& pos, bool stripLeadingSpace )
{
    bool dummy;
 
    return loadOasisSpan( parent, context, pos, stripLeadingSpace, &dummy );
}
 
void KoTextParag::loadOasisSpan( const TQDomElement& parent, KoOasisContext& context, uint& pos, bool stripLeadingSpace, bool *hasTrailingSpace )
{
    // Parse every child node of the parent
    // Can't use forEachElement here since we also care about text nodes
    TQDomNode node;
    for ( node = parent.firstChild(); !node.isNull(); node = node.nextSibling() )
    {
        TQDomElement ts = node.toElement();
        TQString textData;
        const TQString localName( ts.localName() );
        const bool isTextNS = ts.namespaceURI() == KoXmlNS::text;
        KoTextCustomItem* customItem = 0;
 
        // allow loadSpanTag to modify the stylestack
        context.styleStack().save();
 
        // Try to keep the order of the tag names by probability of happening
        if ( node.isText() )
        {
            textData = normalizeWhitespace( node.toText().data(), stripLeadingSpace );
            *hasTrailingSpace = stripLeadingSpace = textData[textData.length() - 1].isSpace();
        }
        else if ( isTextNS && localName == "span" ) // text:span
        {
            context.styleStack().save();
            context.fillStyleStack( ts, KoXmlNS::text, "style-name", "text" );
 
            // the ODF spec states that whitespace is compressed through tags: e.g.
            //   "Foo <text:span> Bar </text:span> Baz"
            // should only have one space between each of "Foo", "Bar", and "Baz"
            // so we need to keep track of whether there was any trailing whitespace
            // in sub-spans so that we can propogate the whitespace compression state
            // back up to the parent element
            loadOasisSpan( ts, context, pos, stripLeadingSpace, hasTrailingSpace ); // recurse
            stripLeadingSpace = *hasTrailingSpace;
            context.styleStack().restore();
        }
        else if ( isTextNS && localName == "s" ) // text:s
        {
            int howmany = 1;
            if (ts.hasAttributeNS( KoXmlNS::text, "c"))
                howmany = ts.attributeNS( KoXmlNS::text, "c", TQString()).toInt();
 
            textData.fill(32, howmany);
        }
        else if ( isTextNS && localName == "tab" ) // text:tab (it's tab-stop in OO-1.1 but tab in oasis)
        {
            textData = '\t';
        }
        else if ( isTextNS && localName == "line-break" ) // text:line-break
        {
            textData = '\n';
        }
        else if ( isTextNS && localName == "number" ) // text:number
        {
            // This is the number in front of a numbered paragraph,
            // written out to help export filters. We can ignore it.
        }
        else if ( node.isProcessingInstruction() )
        {
            TQDomProcessingInstruction pi = node.toProcessingInstruction();
            if ( pi.target() == "opendocument" && pi.data().startsWith( "cursor-position" ) )
            {
                context.setCursorPosition( this, pos );
            }
        }
        else
        {
            bool handled = false;
            // Check if it's a variable
            KoVariable* var = context.variableCollection().loadOasisField( textDocument(), ts, context );
            if ( var )
            {
                textData = "#";     // field placeholder
                customItem = var;
                handled = true;
            }
            if ( !handled )
            {
                handled = textDocument()->loadSpanTag( ts, context,
                                                       this, pos,
                                                       textData, customItem );
                if ( !handled )
                {
                    kdWarning(32500) << "Ignoring tag " << ts.tagName() << endl;
                    context.styleStack().restore();
                    continue;
                }
            }
        }
 
        const uint length = textData.length();
        if ( length )
        {
            insert( pos, textData );
            if ( customItem )
                setCustomItem( pos, customItem, 0 );
            KoTextFormat f;
            f.load( context );
            //kdDebug(32500) << "loadOasisSpan: applying formatting from " << pos << " to " << pos+length << "\n   format=" << f.key() << endl;
            setFormat( pos, length, document()->formatCollection()->format( &f ), true );
            pos += length;
        }
        context.styleStack().restore();
    }
}
 
KoParagLayout KoTextParag::loadParagLayout( KoOasisContext& context, KoStyleCollection *styleCollection, bool findStyle )
{
    KoParagLayout layout;
 
    // Only when loading paragraphs, not when loading styles
    if ( findStyle )
    {
        KoParagStyle *style;
        // Name of the style. If there is no style, then we do not supply
        // any default!
        TQString styleName = context.styleStack().userStyleName( "paragraph" );
        if ( !styleName.isEmpty() )
        {
            style = styleCollection->findStyle( styleName );
            // When pasting the style names are random, the display names matter
            if (!style)
                style = styleCollection->findStyleByDisplayName( context.styleStack().userStyleDisplayName( "paragraph" ) );
            if (!style)
            {
                kdError(32500) << "Cannot find style \"" << styleName << "\" - using Standard" << endl;
                style = styleCollection->findStyle( "Standard" );
            }
            //else kdDebug() << "KoParagLayout::KoParagLayout setting style to " << style << " " << style->name() << endl;
        }
        else
        {
            kdError(32500) << "No style name !? - using Standard" << endl;
            style = styleCollection->findStyle( "Standard" );
        }
        Q_ASSERT(style);
        layout.style = style;
    }
 
    KoParagLayout::loadOasisParagLayout( layout, context );
 
    return layout;
}
 
void KoTextParag::loadOasis( const TQDomElement& parent, KoOasisContext& context, KoStyleCollection *styleCollection, uint& pos )
{
    // First load layout from style
    KoParagLayout paragLayout = loadParagLayout( context, styleCollection, true );
    setParagLayout( paragLayout );
 
    // Load paragraph format
    KoTextFormat defaultFormat;
    defaultFormat.load( context );
    setFormat( document()->formatCollection()->format( &defaultFormat ) );
 
    // Load text
    // OO.o compatibility: ignore leading whitespace in <p> and <h> elements
    loadOasisSpan( parent, context, pos, true );
 
    // Apply default format to trailing space
    const int len = str->length();
    Q_ASSERT( len >= 1 );
    setFormat( len - 1, 1, paragFormat(), true );
 
    setChanged( true );
    invalidate( 0 );
}
 
void KoTextParag::saveOasis( KoXmlWriter& writer, KoSavingContext& context,
                             int from /* default 0 */, int to /* usually length()-2 */,
                             bool /*saveAnchorsFramesets*/ /* default false */ ) const
{
    KoGenStyles& mainStyles = context.mainStyles();
 
    // Write paraglayout to styles (with parent == the parag's style)
    TQString parentStyleName;
    if ( m_layout.style )
        parentStyleName = m_layout.style->name();
 
    KoGenStyle autoStyle( KoGenStyle::STYLE_AUTO, "paragraph", parentStyleName );
    paragFormat()->save( autoStyle, context );
    m_layout.saveOasis( autoStyle, context, false );
 
    // First paragraph is special, it includes page-layout info (for word-processing at least)
    if ( !prev() ) {
        if ( context.variableSettings() )
            autoStyle.addProperty( "style:page-number", context.variableSettings()->startingPageNumber() );
        // Well we support only one page layout, so the first parag always points to "Standard".
        autoStyle.addAttribute( "style:master-page-name", "Standard" );
    }
 
 
    TQString autoParagStyleName = mainStyles.lookup( autoStyle, "P", KoGenStyles::ForceNumbering );
 
    KoParagCounter* paragCounter = m_layout.counter;
    // outline (text:h) assumes paragCounter != 0 (because depth is mandatory)
    bool outline = m_layout.style && m_layout.style->isOutline() && paragCounter;
    bool normalList = paragCounter && paragCounter->style() != KoParagCounter::STYLE_NONE && !outline;
    if ( normalList ) // non-heading list
    {
        writer.startElement( "text:numbered-paragraph" );
        writer.addAttribute( "text:level", (int)paragCounter->depth() + 1 );
        if ( paragCounter->restartCounter() )
            writer.addAttribute( "text:start-value", paragCounter->startNumber() );
 
        KoGenStyle listStyle( KoGenStyle::STYLE_AUTO_LIST /*, no family*/ );
        paragCounter->saveOasis( listStyle );
 
        TQString autoListStyleName = mainStyles.lookup( listStyle, "L", KoGenStyles::ForceNumbering );
        writer.addAttribute( "text:style-name", autoListStyleName );
 
        TQString textNumber = m_layout.counter->text( this );
        if ( !textNumber.isEmpty() )
        {
            // This is to help export filters
            writer.startElement( "text:number" );
            writer.addTextNode( textNumber );
            writer.endElement();
        }
    }
    else if ( outline ) // heading
    {
        writer.startElement( "text:h", false /*no indent inside this tag*/ );
        writer.addAttribute( "text:style-name", autoParagStyleName );
        writer.addAttribute( "text:outline-level", (int)paragCounter->depth() + 1 );
        if ( paragCounter->numbering() == KoParagCounter::NUM_NONE )
            writer.addAttribute( "text:is-list-header", "true" );
 
        TQString textNumber = paragCounter->text( this );
        if ( !textNumber.isEmpty() )
        {
            // This is to help export filters
            writer.startElement( "text:number" );
            writer.addTextNode( textNumber );
            writer.endElement();
        }
    }
 
    if ( !outline ) // normal (non-numbered) paragraph, or normalList
    {
        writer.startElement( "text:p", false /*no indent inside this tag*/ );
        writer.addAttribute( "text:style-name", autoParagStyleName );
    }
 
    TQString text = str->toString();
    Q_ASSERT( text.right(1)[0] == ' ' );
 
    const int cursorIndex = context.cursorTextParagraph() == this ? context.cursorTextIndex() : -1;
 
    //kdDebug() << k_funcinfo << "'" << text << "' from=" << from << " to=" << to << " cursorIndex=" << cursorIndex << endl;
 
    // A helper method would need no less than 7 params...
#define WRITESPAN( next ) { \
        if ( curFormat == paragFormat() ) {                             \
            writer.addTextSpan( text.mid( startPos, next - startPos ), m_tabCache ); \
        } else {                                                        \
            KoGenStyle gs( KoGenStyle::STYLE_AUTO, "text" );            \
            curFormat->save( gs, context, paragFormat() );              \
            writer.startElement( "text:span" );                         \
            if ( !gs.isEmpty() ) {                                      \
                const TQString autoStyleName = mainStyles.lookup( gs, "T" ); \
                writer.addAttribute( "text:style-name", autoStyleName );    \
            }                                                           \
            writer.addTextSpan( text.mid( startPos, next - startPos ), m_tabCache ); \
            writer.endElement();                                        \
        }                                                               \
    }
#define ISSTARTBOOKMARK( i ) bkStartIter != bookmarkStarts.end() && (*bkStartIter).pos == i
#define ISENDBOOKMARK( i ) bkEndIter != bookmarkEnds.end() && (*bkEndIter).pos == i
#define CHECKPOS( i ) \
        if ( cursorIndex == i ) { \
            writer.addProcessingInstruction( "opendocument cursor-position" ); \
        } \
        if ( ISSTARTBOOKMARK( i ) ) { \
            if ( (*bkStartIter).startEqualsEnd ) \
                writer.startElement( "text:bookmark" ); \
            else \
                writer.startElement( "text:bookmark-start" ); \
            writer.addAttribute( "text:name", (*bkStartIter).name ); \
            writer.endElement(); \
            ++bkStartIter; \
        } \
        if ( ISENDBOOKMARK( i ) ) { \
            writer.startElement( "text:bookmark-end" ); \
            writer.addAttribute( "text:name", (*bkEndIter).name ); \
            writer.endElement(); \
            ++bkEndIter; \
        }
 
 
 
    // Make (shallow) copy of bookmark list, since saving an inline frame might overwrite it
    // from the context while we're saving this paragraph.
    typedef KoSavingContext::BookmarkPositions BookmarkPositions;
    BookmarkPositions bookmarkStarts = context.bookmarkStarts();
    BookmarkPositions::const_iterator bkStartIter = bookmarkStarts.begin();
    while ( bkStartIter != bookmarkStarts.end() && (*bkStartIter).pos < from )
        ++bkStartIter;
    //int nextBookmarkStart = bkStartIter == bookmarkStarts.end() ? -1 : (*bkStartIter).pos;
    BookmarkPositions bookmarkEnds = context.bookmarkEnds();
    BookmarkPositions::const_iterator bkEndIter = bookmarkEnds.begin();
    while ( bkEndIter != bookmarkEnds.end() && (*bkEndIter).pos < from )
        ++bkEndIter;
 
    KoTextFormat *curFormat = 0;
    KoTextFormat *lastFormatRaw = 0; // this is for speeding up "removing misspelled" from each char
    KoTextFormat *lastFormatFixed = 0; // raw = as stored in the chars; fixed = after removing misspelled
    int startPos = from;
    for ( int i = from; i <= to; ++i ) {
        KoTextStringChar & ch = str->at(i);
        KoTextFormat * newFormat = static_cast<KoTextFormat *>( ch.format() );
        if ( newFormat->isMisspelled() ) {
            if ( newFormat == lastFormatRaw )
                newFormat = lastFormatFixed; // the fast way
            else
            {
                lastFormatRaw = newFormat;
                // Remove isMisspelled from format, to avoid useless derived styles
                // (which would be indentical to their parent style)
                KoTextFormat tmpFormat( *newFormat );
                tmpFormat.setMisspelled( false );
                newFormat = formatCollection()->format( &tmpFormat );
                lastFormatFixed = newFormat;
            }
        }
        if ( !curFormat )
            curFormat = newFormat;
        if ( newFormat != curFormat  // Format changed, save previous one.
             || ch.isCustom() || cursorIndex == i || ISSTARTBOOKMARK( i ) || ISENDBOOKMARK( i ) )
        {
            WRITESPAN( i ) // write text up to i-1
            startPos = i;
            curFormat = newFormat;
        }
        CHECKPOS( i ) // do cursor position and bookmarks
        if ( ch.isCustom() ) {
            KoGenStyle gs( KoGenStyle::STYLE_AUTO, "text" );
            curFormat->save( gs, context, paragFormat() );
            writer.startElement( "text:span" );
            if ( !gs.isEmpty() ) {
                const TQString autoStyleName = mainStyles.lookup( gs, "T" );
                writer.addAttribute( "text:style-name", autoStyleName );
            }
            KoTextCustomItem* customItem = ch.customItem();
            customItem->saveOasis( writer, context );
            writer.endElement();
            startPos = i + 1;
        }
    }
 
    //kdDebug() << k_funcinfo << "startPos=" << startPos << " to=" << to << " curFormat=" << curFormat << endl;
 
    if ( to >= startPos ) { // Save last format
        WRITESPAN( to + 1 )
    }
    CHECKPOS( to + 1 ) // do cursor position and bookmarks
 
    writer.endElement(); // text:p or text:h
    if ( normalList )
        writer.endElement(); // text:numbered-paragraph (englobing a text:p)
}
 
void KoTextParag::applyListStyle( KoOasisContext& context, int restartNumbering, bool orderedList, bool heading, int level )
{
    //kdDebug(32500) << k_funcinfo << "applyListStyle to parag " << this << " heading=" << heading << endl;
    delete m_layout.counter;
    m_layout.counter = new KoParagCounter;
    m_layout.counter->loadOasis( context, restartNumbering, orderedList, heading, level );
    // We emulate space-before with a left paragraph indent (#109223)
    const TQDomElement listStyleProperties = context.listStyleStack().currentListStyleProperties();
    if ( listStyleProperties.hasAttributeNS( KoXmlNS::text, "space-before" ) )
    {
        double spaceBefore = KoUnit::parseValue( listStyleProperties.attributeNS( KoXmlNS::text, "space-before", TQString() ) );
        m_layout.margins[ TQStyleSheetItem::MarginLeft ] += spaceBefore; // added to left-margin, see 15.12 in spec.
    }
    // need to call invalidateCounters() ? Not during the initial loading at least.
}
 
int KoTextParag::documentWidth() const
{
    return doc ? doc->width() : 0; //docRect.width();
}
 
//int KoTextParag::documentVisibleWidth() const
//{
//    return doc ? doc->visibleWidth() : 0; //docRect.width();
//}
 
int KoTextParag::documentX() const
{
    return doc ? doc->x() : 0; //docRect.x();
}
 
int KoTextParag::documentY() const
{
    return doc ? doc->y() : 0; //docRect.y();
}
 
void KoTextParag::fixParagWidth( bool viewFormattingChars )
{
    // Fixing the parag rect for the formatting chars (only CR here, KWord handles framebreak).
    if ( viewFormattingChars && lineStartList().count() == 1 ) // don't use lines() here, parag not formatted yet
    {
        KoTextFormat * lastFormat = at( length() - 1 )->format();
        setWidth( TQMIN( rect().width() + lastFormat->width('x'), doc->width() ) );
    }
    // Warning, if adding anything else here, adjust KWTextFrameSet::fixParagWidth
}
 
// Called by KoTextParag::drawParagString - all params are in pixel coordinates
void KoTextParag::drawFormattingChars( TQPainter &painter, int start, int len,
                                       int lastY_pix, int baseLine_pix, int h_pix, // in pixels
                                       bool /*drawSelections*/,
                                       KoTextFormat * /*lastFormat*/, const TQMemArray<int> &/*selectionStarts*/,
                                       const TQMemArray<int> &/*selectionEnds*/, const TQColorGroup & /*cg*/,
                                       bool rightToLeft, int /*line*/, KoTextZoomHandler* zh,
                                       int whichFormattingChars )
{
    if ( !whichFormattingChars )
        return;
    painter.save();
    //TQPen pen( cg.color( TQColorGroup::Highlight ) );
    TQPen pen( TDEGlobalSettings::linkColor() ); // #101820
    painter.setPen( pen );
    //kdDebug() << "KWTextParag::drawFormattingChars start=" << start << " len=" << len << " length=" << length() << endl;
    if ( start + len == length() && ( whichFormattingChars & FormattingEndParag ) )
    {
        // drawing the end of the parag
        KoTextStringChar &ch = str->at( length() - 1 );
        KoTextFormat* format = static_cast<KoTextFormat *>( ch.format() );
        int w = format->charWidth( zh, true, &ch, this, 'X' );
        int size = TQMIN( w, h_pix * 3 / 4 );
        // x,y is the bottom right corner of the
        //kdDebug() << "startX=" << startX << " bw=" << bw << " w=" << w << endl;
        int x;
        if ( rightToLeft )
            x = zh->layoutUnitToPixelX( ch.x ) /*+ ch.pixelxadj*/ + ch.pixelwidth - 1;
        else
            x = zh->layoutUnitToPixelX( ch.x ) /*+ ch.pixelxadj*/ + w;
        int y = lastY_pix + baseLine_pix;
        //kdDebug() << "KWTextParag::drawFormattingChars drawing CR at " << x << "," << y << endl;
        painter.drawLine( (int)(x - size * 0.2), y - size, (int)(x - size * 0.2), y );
        painter.drawLine( (int)(x - size * 0.5), y - size, (int)(x - size * 0.5), y );
        painter.drawLine( x, y, (int)(x - size * 0.7), y );
        painter.drawLine( x, y - size, (int)(x - size * 0.5), y - size);
        painter.drawArc( x - size, y - size, size, (int)(size / 2), -90*16, -180*16 );
#ifdef DEBUG_FORMATTING
        painter.setPen( TQt::blue );
        painter.drawRect( zh->layoutUnitToPixelX( ch.x ) /*+ ch.pixelxadj*/ - 1, lastY_pix, ch.pixelwidth, baseLine_pix );
        TQPen pen( cg.color( TQColorGroup::Highlight ) );
        painter.setPen( pen );
#endif
    }
 
    // Now draw spaces, tabs and newlines
    if ( (whichFormattingChars & FormattingSpace) ||
         (whichFormattingChars & FormattingTabs) ||
         (whichFormattingChars & FormattingBreak) )
    {
        int end = TQMIN( start + len, length() - 1 ); // don't look at the trailing space
        for ( int i = start ; i < end ; ++i )
        {
            KoTextStringChar &ch = str->at(i);
#ifdef DEBUG_FORMATTING
            painter.setPen( (i % 2)? TQt::red: TQt::green );
            painter.drawRect( zh->layoutUnitToPixelX( ch.x ) /*+ ch.pixelxadj*/ - 1, lastY_pix, ch.pixelwidth, baseLine_pix );
            TQPen pen( cg.color( TQColorGroup::Highlight ) );
            painter.setPen( pen );
#endif
            if ( ch.isCustom() )
                continue;
            if ( (ch.c == ' ' || ch.c.unicode() == 0x00a0U)
                 && (whichFormattingChars & FormattingSpace))
            {
                // Don't use ch.pixelwidth here. We want a square with
                // the same size for all spaces, even the justified ones
                int w = zh->layoutUnitToPixelX( ch.format()->width( ' ' ) );
                int height = zh->layoutUnitToPixelY( ch.ascent() );
                int size = TQMAX( 2, TQMIN( w/2, height/3 ) ); // Enfore that it's a square, and that it's visible
                int x = zh->layoutUnitToPixelX( ch.x ); // + ch.pixelxadj;
                TQRect spcRect( x + (ch.pixelwidth - size) / 2, lastY_pix + baseLine_pix - (height - size) / 2, size, size );
                if ( ch.c == ' ' )
                    painter.drawRect( spcRect );
                else // nbsp
                    painter.fillRect( spcRect, pen.color() );
            }
            else if ( ch.c == '\t' && (whichFormattingChars & FormattingTabs) )
            {
                /*KoTextStringChar &nextch = str->at(i+1);
                  int nextx = (nextch.x > ch.x) ? nextch.x : rect().width();
                  //kdDebug() << "tab x=" << ch.x << " nextch.x=" << nextch.x
                  //          << " nextx=" << nextx << " startX=" << startX << " bw=" << bw << endl;
                  int availWidth = nextx - ch.x - 1;
                  availWidth=zh->layoutUnitToPixelX(availWidth);*/
 
                int availWidth = ch.pixelwidth;
 
                KoTextFormat* format = ch.format();
                int x = zh->layoutUnitToPixelX( ch.x ) /*+ ch.pixelxadj*/ + availWidth / 2;
                int charWidth = format->screenFontMetrics( zh ).width( 'W' );
                int size = TQMIN( availWidth, charWidth ) / 2 ; // actually the half size
                int y = lastY_pix + baseLine_pix - zh->layoutUnitToPixelY( ch.ascent()/2 );
                int arrowsize = zh->zoomItY( 2 );
                painter.drawLine( x - size, y, x + size, y );
                if ( rightToLeft )
                {
                    painter.drawLine( x - size, y, x - size + arrowsize, y - arrowsize );
                    painter.drawLine( x - size, y, x - size + arrowsize, y + arrowsize );
                }
                else
                {
                    painter.drawLine( x + size, y, x + size - arrowsize, y - arrowsize );
                    painter.drawLine( x + size, y, x + size - arrowsize, y + arrowsize );
                }
            }
            else if ( ch.c == '\n' && (whichFormattingChars & FormattingBreak) )
            {
                // draw line break
                KoTextFormat* format = static_cast<KoTextFormat *>( ch.format() );
                int w = format->charWidth( zh, true, &ch, this, 'X' );
                int size = TQMIN( w, h_pix * 3 / 4 );
                int arrowsize = zh->zoomItY( 2 );
                // x,y is the bottom right corner of the reversed L
                //kdDebug() << "startX=" << startX << " bw=" << bw << " w=" << w << endl;
                int y = lastY_pix + baseLine_pix - arrowsize;
                //kdDebug() << "KWTextParag::drawFormattingChars drawing Line Break at " << x << "," << y << endl;
                if ( rightToLeft )
                {
                    int x = zh->layoutUnitToPixelX( ch.x ) /*+ ch.pixelxadj*/ + ch.pixelwidth - 1;
                    painter.drawLine( x - size, y - size, x - size, y );
                    painter.drawLine( x - size, y, (int)(x - size * 0.3), y );
                    // Now the arrow
                    painter.drawLine( (int)(x - size * 0.3), y, (int)(x - size * 0.3 - arrowsize), y - arrowsize );
                    painter.drawLine( (int)(x - size * 0.3), y, (int)(x - size * 0.3 - arrowsize), y + arrowsize );
                }
                else
                {
                    int x = zh->layoutUnitToPixelX( ch.x ) /*+ ch.pixelxadj*/ + w - 1;
                    painter.drawLine( x, y - size, x, y );
                    painter.drawLine( x, y, (int)(x - size * 0.7), y );
                    // Now the arrow
                    painter.drawLine( (int)(x - size * 0.7), y, (int)(x - size * 0.7 + arrowsize), y - arrowsize );
                    painter.drawLine( (int)(x - size * 0.7), y, (int)(x - size * 0.7 + arrowsize), y + arrowsize );
                }
            }
        }
        painter.restore();
    }
}
 
int KoTextParag::heightForLineSpacing( int startChar, int lastChar ) const
{
    int h = 0;
    int end = TQMIN( lastChar, length() - 1 ); // don't look at the trailing space
    for( int i = startChar; i <= end; ++i )
    {
        const KoTextStringChar &chr = str->at( i );
        if ( !chr.isCustom() )
            h = TQMAX( h, chr.format()->height() );
    }
    return h;
}