qtextedit.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qtextedit.cpp,v 1.5 2004/06/10 22:34:29 ar Exp $
**
** Implementation of the QTextEdit class
**
** Created : 990101
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the widgets module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "qtextedit.h"

#include "qrichtext_p.h"
#include "qlistbox.h"
#include "qclipboard.h"
#include "qpopupmenu.h"

#define ACCEL_KEY(k) "\t" + QString("Ctrl+" #k)

using namespace Qt3;

static bool qt_enable_richtext_copy = FALSE;

struct QUndoRedoInfoPrivate
{
    QTextString text;
};

namespace Qt3 {

class QTextEditPrivate
{
public:
    QTextEditPrivate()
    :preeditStart(-1),preeditLength(-1),ensureCursorVisibleInShowEvent(FALSE)
    {
    for ( int i=0; i<7; i++ )
        id[i] = 0;
    }
    int id[ 7 ];
    int preeditStart;
    int preeditLength;
    bool ensureCursorVisibleInShowEvent;
    QString scrollToAnchor; // used to deferr scrollToAnchor() until the show event when we are resized
};

}

static bool block_set_alignment = FALSE;

QTextEdit::QTextEdit( QWidget *parent, const char *name )
    : QScrollView( parent, name, WStaticContents | WRepaintNoErase | WResizeNoErase ),
      doc( new QTextDocument( 0 ) ), undoRedoInfo( doc )
{
    init();
}

QTextEdit::QTextEdit( const QString& text, const QString& context,
              QWidget *parent, const char *name)
    : QScrollView( parent, name, WStaticContents | WRepaintNoErase | WResizeNoErase ),
      doc( new QTextDocument( 0 ) ), undoRedoInfo( doc )
{
    init();
    setText( text, context );
}

QTextEdit::~QTextEdit()
{
    delete undoRedoInfo.d;
    undoRedoInfo.d = 0;
    delete cursor;
    delete doc;
    delete d;
}

void QTextEdit::init()
{
    setFrameStyle( Sunken );
    setVScrollBarMode( AlwaysOn );
    undoEnabled = TRUE;
    readonly = TRUE;
    setReadOnly( FALSE );
    d = new QTextEditPrivate;
    connect( doc, SIGNAL( minimumWidthChanged(int) ),
         this, SLOT( documentWidthChanged(int) ) );

    mousePressed = FALSE;
    inDoubleClick = FALSE;
    modified = FALSE;
    onLink = QString::null;
    overWrite = FALSE;
    wrapMode = WidgetWidth;
    wrapWidth = -1;
    wPolicy = AtWhiteSpace;
    inDnD = FALSE;

    doc->setFormatter( new QTextFormatterBreakWords );
    doc->formatCollection()->defaultFormat()->setFont( QScrollView::font() );
    doc->formatCollection()->defaultFormat()->setColor( colorGroup().color( QColorGroup::Text ) );
    currentFormat = doc->formatCollection()->defaultFormat();
    currentAlignment = Qt3::AlignAuto;

    viewport()->setBackgroundMode( PaletteBase );
    viewport()->setAcceptDrops( TRUE );
    resizeContents( 0, doc->lastParagraph() ?
            ( doc->lastParagraph()->paragId() + 1 ) * doc->formatCollection()->defaultFormat()->height() : 0 );

    setKeyCompression( TRUE );
    viewport()->setMouseTracking( TRUE );
#ifndef QT_NO_CURSOR
    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
    cursor = new QTextCursor( doc );

    formatTimer = new QTimer( this );
    connect( formatTimer, SIGNAL( timeout() ),
         this, SLOT( formatMore() ) );
    lastFormatted = doc->firstParagraph();

    scrollTimer = new QTimer( this );
    connect( scrollTimer, SIGNAL( timeout() ),
         this, SLOT( autoScrollTimerDone() ) );

    interval = 0;
    changeIntervalTimer = new QTimer( this );
    connect( changeIntervalTimer, SIGNAL( timeout() ),
         this, SLOT( doChangeInterval() ) );

    cursorVisible = TRUE;
    blinkTimer = new QTimer( this );
    connect( blinkTimer, SIGNAL( timeout() ),
         this, SLOT( blinkCursor() ) );

#ifndef QT_NO_DRAGANDDROP
    dragStartTimer = new QTimer( this );
    connect( dragStartTimer, SIGNAL( timeout() ),
         this, SLOT( startDrag() ) );
#endif


    formatMore();

    blinkCursorVisible = FALSE;

    viewport()->setFocusProxy( this );
    viewport()->setFocusPolicy( WheelFocus );
    viewport()->installEventFilter( this );
    installEventFilter( this );
}

void QTextEdit::paintDocument( bool drawAll, QPainter *p, int cx, int cy, int cw, int ch )
{
    bool drawCur = hasFocus() || viewport()->hasFocus();
    if ( hasSelectedText() || isReadOnly() || !cursorVisible )
    drawCur = FALSE;
    QColorGroup g = colorGroup();
    if ( doc->paper() )
    g.setBrush( QColorGroup::Base, *doc->paper() );

    if ( contentsY() < doc->y() ) {
    p->fillRect( contentsX(), contentsY(), visibleWidth(), doc->y(),
             g.brush( QColorGroup::Base ) );
    }
    if ( drawAll && doc->width() - contentsX() < cx + cw ) {
    p->fillRect( doc->width() - contentsX(), cy, cx + cw - doc->width() + contentsX(), ch,
             g.brush( QColorGroup::Base ) );
    }

    p->setBrushOrigin( -contentsX(), -contentsY() );

    lastFormatted = doc->draw( p, cx, cy, cw, ch, g, !drawAll, drawCur, cursor );

    if ( lastFormatted == doc->lastParagraph() )
    resizeContents( contentsWidth(), doc->height() );

    if ( contentsHeight() < visibleHeight() && ( !doc->lastParagraph() || doc->lastParagraph()->isValid() ) && drawAll )
    p->fillRect( 0, contentsHeight(), visibleWidth(),
             visibleHeight() - contentsHeight(), g.brush( QColorGroup::Base ) );
}

void QTextEdit::drawContents( QPainter *p, int cx, int cy, int cw, int ch )
{
    paintDocument( TRUE, p, cx, cy, cw, ch );
    int v;
    p->setPen( foregroundColor() );
    if ( document()->isPageBreakEnabled() &&  ( v = document()->flow()->pageSize() ) > 0 ) {
    int l = int(cy / v) * v;
    while ( l < cy + ch ) {
        p->drawLine( cx, l, cx + cw - 1, l );
        l += v;
    }
    }

}

void QTextEdit::drawContents( QPainter * )
{
}

bool QTextEdit::event( QEvent *e )
{
    if ( e->type() == QEvent::AccelOverride && !isReadOnly() ) {
    QKeyEvent* ke = (QKeyEvent*) e;
    if ( ke->state() == NoButton || ke->state() == Keypad ) {
        if ( ke->key() < Key_Escape ) {
        ke->accept();
        } else {
        switch ( ke->key() ) {
        case Key_Return:
        case Key_Enter:
        case Key_Delete:
        case Key_Home:
        case Key_End:
        case Key_Backspace:
            ke->accept();
        default:
            break;
        }
        }
    } else if ( ke->state() & ControlButton ) {
        switch ( ke->key() ) {
// Those are too frequently used for application functionality
/*      case Key_A:
        case Key_B:
        case Key_D:
        case Key_E:
        case Key_F:
        case Key_H:
        case Key_I:
        case Key_K:
        case Key_N:
        case Key_P:
        case Key_T:
*/
        case Key_C:
        case Key_V:
        case Key_X:
        case Key_Y:
        case Key_Z:
        case Key_Left:
        case Key_Right:
        case Key_Up:
        case Key_Down:
        case Key_Home:
        case Key_End:
        case Key_Tab:
#if defined (Q_WS_WIN)
        case Key_Insert:
        case Key_Delete:
#endif
        ke->accept();
        default:
        break;
        }
    } else {
        switch ( ke->key() ) {
#if defined (Q_WS_WIN)
        case Key_Insert:
        ke->accept();
#endif
        default:
        break;
        }
    }
    }

    if ( e->type() == QEvent::Show ) {
    if ( d->ensureCursorVisibleInShowEvent ) {
        sync();
        ensureCursorVisible();
        d->ensureCursorVisibleInShowEvent = FALSE;
    }
    if ( !d->scrollToAnchor.isEmpty()  ) {
        scrollToAnchor( d->scrollToAnchor );
        d->scrollToAnchor = QString::null;
    }
    }
    return QWidget::event( e );
}

void QTextEdit::keyPressEvent( QKeyEvent *e )
{
    changeIntervalTimer->stop();
    interval = 10;
    bool unknown = FALSE;
    if ( isReadOnly() ) {
    if ( !handleReadOnlyKeyEvent( e ) )
        QScrollView::keyPressEvent( e );
    changeIntervalTimer->start( 100, TRUE );
    return;
    }


    bool selChanged = FALSE;
    for ( int i = 1; i < doc->numSelections(); ++i ) // start with 1 as we don't want to remove the Standard-Selection
    selChanged = doc->removeSelection( i ) || selChanged;

    if ( selChanged ) {
    cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
    repaintChanged();
    }

    bool clearUndoRedoInfo = TRUE;


    switch ( e->key() ) {
    case Key_Left:
    case Key_Right: {
    // a bit hacky, but can't change this without introducing new enum values for move and keeping the
    // correct semantics and movement for BiDi and non BiDi text.
    CursorAction a;
    if ( cursor->paragraph()->string()->isRightToLeft() == (e->key() == Key_Right) )
        a = e->state() & ControlButton ? MoveWordBackward : MoveBackward;
    else
        a = e->state() & ControlButton ? MoveWordForward : MoveForward;
    moveCursor( a, e->state() & ShiftButton );
    break;
    }
    case Key_Up:
    moveCursor( e->state() & ControlButton ? MovePgUp : MoveUp, e->state() & ShiftButton );
    break;
    case Key_Down:
    moveCursor( e->state() & ControlButton ? MovePgDown : MoveDown, e->state() & ShiftButton );
    break;
    case Key_Home:
    moveCursor( e->state() & ControlButton ? MoveHome : MoveLineStart, e->state() & ShiftButton );
    break;
    case Key_End:
    moveCursor( e->state() & ControlButton ? MoveEnd : MoveLineEnd, e->state() & ShiftButton );
    break;
    case Key_Prior:
    moveCursor( MovePgUp, e->state() & ShiftButton );
    break;
    case Key_Next:
    moveCursor( MovePgDown, e->state() & ShiftButton );
    break;
    case Key_Return: case Key_Enter:
    if ( doc->hasSelection( QTextDocument::Standard, FALSE ) )
        removeSelectedText();
    if ( textFormat() == Qt::RichText && ( e->state() & ControlButton ) ) {
        // Ctrl-Enter inserts a line break in rich text mode
        insert( QString( QChar( 0x2028) ), TRUE, FALSE, TRUE );
    } else {
#ifndef QT_NO_CURSOR
        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
        clearUndoRedoInfo = FALSE;
        doKeyboardAction( ActionReturn );
        emit returnPressed();
    }
    break;
    case Key_Delete:
#if defined (Q_WS_WIN)
    if ( e->state() & ShiftButton ) {
        cut();
        break;
    } else
#endif
        if ( doc->hasSelection( QTextDocument::Standard, TRUE ) ) {
        removeSelectedText();
        break;
    }
    doKeyboardAction( ActionDelete );
    clearUndoRedoInfo = FALSE;

    break;
    case Key_Insert:
    if ( e->state() & ShiftButton )
        paste();
#if defined (Q_WS_WIN)
    else if ( e->state() & ControlButton )
        copy();
#endif
    break;
    case Key_Backspace:
    if ( doc->hasSelection( QTextDocument::Standard, TRUE ) ) {
        removeSelectedText();
        break;
    }

    doKeyboardAction( ActionBackspace );
    clearUndoRedoInfo = FALSE;

    break;
    case Key_F16: // Copy key on Sun keyboards
    copy();
    break;
    case Key_F18:  // Paste key on Sun keyboards
    paste();
    break;
    case Key_F20:  // Cut key on Sun keyboards
    cut();
    break;
    default: {
        if ( e->text().length() &&
        ( !( e->state() & ControlButton ) &&
          !( e->state() & AltButton ) ||
         ( ( e->state() & ControlButton | AltButton ) == (ControlButton|AltButton) ) ) &&
         ( !e->ascii() || e->ascii() >= 32 || e->text() == "\t" ) ) {
        clearUndoRedoInfo = FALSE;
        if ( e->key() == Key_Tab ) {
            if ( textFormat() == Qt::RichText && cursor->paragraph()->isListItem() ) {
            clearUndoRedo();
            undoRedoInfo.type = UndoRedoInfo::Style;
            undoRedoInfo.id = cursor->paragraph()->paragId();
            undoRedoInfo.eid = undoRedoInfo.id;
            undoRedoInfo.styleInformation = QTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
            cursor->paragraph()->setListDepth( cursor->paragraph()->listDepth() +1 );
            clearUndoRedo();
            drawCursor( FALSE );
            repaintChanged();
            drawCursor( TRUE );
            break;
            }
        }

        if ( textFormat() == Qt::RichText && !cursor->paragraph()->isListItem() ) {
            if ( cursor->index() == 0 && ( e->text()[0] == '-' || e->text()[0] == '*' ) ) {
            clearUndoRedo();
            undoRedoInfo.type = UndoRedoInfo::Style;
            undoRedoInfo.id = cursor->paragraph()->paragId();
            undoRedoInfo.eid = undoRedoInfo.id;
            undoRedoInfo.styleInformation = QTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
            setParagType( QStyleSheetItem::DisplayListItem, QStyleSheetItem::ListDisc );
            clearUndoRedo();
            drawCursor( FALSE );
            repaintChanged();
            drawCursor( TRUE );
            break;
            }
        }
        if ( overWrite && !cursor->atParagEnd() )
            cursor->remove();
        QString t = e->text();
        QTextParagraph *p = cursor->paragraph();
        if ( p && p->string() && p->string()->isRightToLeft() ) {
            QChar *c = (QChar *)t.unicode();
            int l = t.length();
            while( l-- ) {
            if ( c->mirrored() )
                *c = c->mirroredChar();
            c++;
            }
        }
        insert( t, TRUE, FALSE, TRUE );
        break;
        } else if ( e->state() & ControlButton ) {
        switch ( e->key() ) {
        case Key_C: case Key_F16: // Copy key on Sun keyboards
            copy();
            break;
        case Key_V:
            paste();
            break;
        case Key_X:
            cut();
            break;
        case Key_I: case Key_T: case Key_Tab:
            indent();
            break;
        case Key_A:
#if defined(Q_WS_X11)
            moveCursor( MoveLineStart, e->state() & ShiftButton );
#else
            selectAll( TRUE );
#endif
            break;
        case Key_B:
            moveCursor( MoveBackward, e->state() & ShiftButton );
            break;
        case Key_F:
            moveCursor( MoveForward, e->state() & ShiftButton );
            break;
        case Key_D:
            if ( doc->hasSelection( QTextDocument::Standard ) ) {
            removeSelectedText();
            break;
            }
            doKeyboardAction( ActionDelete );
            clearUndoRedoInfo = FALSE;
            break;
        case Key_H:
            if ( doc->hasSelection( QTextDocument::Standard ) ) {
            removeSelectedText();
            break;
            }
            if ( !cursor->paragraph()->prev() &&
             cursor->atParagStart() )
            break;

            doKeyboardAction( ActionBackspace );
            clearUndoRedoInfo = FALSE;
            break;
        case Key_E:
            moveCursor( MoveLineEnd, e->state() & ShiftButton );
            break;
        case Key_N:
            moveCursor( MoveDown, e->state() & ShiftButton );
            break;
        case Key_P:
            moveCursor( MoveUp, e->state() & ShiftButton );
            break;
        case Key_Z:
            if(e->state() & ShiftButton)
            redo();
            else
            undo();
            break;
        case Key_Y:
            redo();
            break;
        case Key_K:
            doKeyboardAction( ActionKill );
            break;
#if defined(Q_WS_WIN)
        case Key_Insert:
            copy();
            break;
        case Key_Delete:
            del();
            break;
#endif
        default:
            unknown = FALSE;
            break;
        }
        } else {
        unknown = TRUE;
        }
        }
    }

    emit cursorPositionChanged( cursor );
    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
    if ( clearUndoRedoInfo )
    clearUndoRedo();
    changeIntervalTimer->start( 100, TRUE );
    if ( unknown )
    e->ignore();
}

void QTextEdit::doKeyboardAction( KeyboardAction action )
{
    if ( isReadOnly() )
    return;

    if ( cursor->nestedDepth() != 0 ) // #### for 3.0, disable editing of tables as this is not advanced enough
    return;

    lastFormatted = cursor->paragraph();
    drawCursor( FALSE );
    bool doUpdateCurrentFormat = TRUE;

    switch ( action ) {
    case ActionDelete:
    if ( !cursor->atParagEnd() ) {
        checkUndoRedoInfo( UndoRedoInfo::Delete );
        if ( !undoRedoInfo.valid() ) {
        undoRedoInfo.id = cursor->paragraph()->paragId();
        undoRedoInfo.index = cursor->index();
        undoRedoInfo.d->text = QString::null;
        }
        undoRedoInfo.d->text.insert( undoRedoInfo.d->text.length(), cursor->paragraph()->at( cursor->index() ), TRUE );
        cursor->remove();
    } else {
        clearUndoRedo();
        doc->setSelectionStart( QTextDocument::Temp, *cursor );
        cursor->gotoNextLetter();
        doc->setSelectionEnd( QTextDocument::Temp, *cursor );
        removeSelectedText( QTextDocument::Temp );
    }
    break;
    case ActionBackspace:
    if ( textFormat() == Qt::RichText && cursor->paragraph()->isListItem() && cursor->index() == 0 ) {
        clearUndoRedo();
        undoRedoInfo.type = UndoRedoInfo::Style;
        undoRedoInfo.id = cursor->paragraph()->paragId();
        undoRedoInfo.eid = undoRedoInfo.id;
        undoRedoInfo.styleInformation = QTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
        int ldepth = cursor->paragraph()->listDepth();
        ldepth = QMAX( ldepth-1, 0 );
        cursor->paragraph()->setListDepth( ldepth );
        if ( ldepth == 0 )
        cursor->paragraph()->setListItem( FALSE );
        clearUndoRedo();
        lastFormatted = cursor->paragraph();
        repaintChanged();
        drawCursor( TRUE );
        return;
    }
    if ( !cursor->atParagStart() ) {
        checkUndoRedoInfo( UndoRedoInfo::Delete );
        if ( !undoRedoInfo.valid() ) {
        undoRedoInfo.id = cursor->paragraph()->paragId();
        undoRedoInfo.index = cursor->index();
        undoRedoInfo.d->text = QString::null;
        }
        cursor->gotoPreviousLetter();
        undoRedoInfo.d->text.insert( 0, cursor->paragraph()->at( cursor->index() ), TRUE );
        undoRedoInfo.index = cursor->index();
        cursor->remove();
        lastFormatted = cursor->paragraph();
    } else if ( cursor->paragraph()->prev() ){
        clearUndoRedo();
        doc->setSelectionStart( QTextDocument::Temp, *cursor );
        cursor->gotoPreviousLetter();
        doc->setSelectionEnd( QTextDocument::Temp, *cursor );
        removeSelectedText( QTextDocument::Temp );
    }
    break;
    case ActionReturn:
    checkUndoRedoInfo( UndoRedoInfo::Return );
    if ( !undoRedoInfo.valid() ) {
        undoRedoInfo.id = cursor->paragraph()->paragId();
        undoRedoInfo.index = cursor->index();
        undoRedoInfo.d->text = QString::null;
    }
    undoRedoInfo.d->text += "\n";
    cursor->splitAndInsertEmptyParagraph();
    if ( cursor->paragraph()->prev() ) {
        lastFormatted = cursor->paragraph()->prev();
        lastFormatted->invalidate( 0 );
    }
    doUpdateCurrentFormat = FALSE;
    break;
    case ActionKill:
        clearUndoRedo();
        doc->setSelectionStart( QTextDocument::Temp, *cursor );
        if ( cursor->atParagEnd() )
        cursor->gotoNextLetter();
        else
        cursor->setIndex( cursor->paragraph()->length() - 1 );
        doc->setSelectionEnd( QTextDocument::Temp, *cursor );
        removeSelectedText( QTextDocument::Temp );
        break;
    }

    formatMore();
    repaintChanged();
    ensureCursorVisible();
    drawCursor( TRUE );
    updateMicroFocusHint();
    if ( doUpdateCurrentFormat )
    updateCurrentFormat();
    setModified();
    emit textChanged();
}

void QTextEdit::readFormats( QTextCursor &c1, QTextCursor &c2, QTextString &text, bool fillStyles )
{
    QDataStream styleStream( undoRedoInfo.styleInformation, IO_WriteOnly );
    c2.restoreState();
    c1.restoreState();
    int lastIndex = text.length();
    if ( c1.paragraph() == c2.paragraph() ) {
    for ( int i = c1.index(); i < c2.index(); ++i )
        text.insert( lastIndex + i - c1.index(), c1.paragraph()->at( i ), TRUE );
    if ( fillStyles ) {
        styleStream << (int) 1;
        c1.paragraph()->writeStyleInformation( styleStream );
    }
    } else {
    int i;
    for ( i = c1.index(); i < c1.paragraph()->length()-1; ++i )
        text.insert( lastIndex++, c1.paragraph()->at( i ), TRUE );
    int num = 2; // start and end, being different
    text += "\n"; lastIndex++;
    QTextParagraph *p = c1.paragraph()->next();
    while ( p && p != c2.paragraph() ) {
        for ( i = 0; i < p->length()-1; ++i )
        text.insert( lastIndex++ , p->at( i ), TRUE );
        text += "\n"; num++; lastIndex++;
        p = p->next();
    }
    for ( i = 0; i < c2.index(); ++i )
        text.insert( i + lastIndex, c2.paragraph()->at( i ), TRUE );
    if ( fillStyles ) {
        styleStream << num;
        for ( QTextParagraph *p = c1.paragraph(); --num >= 0; p = p->next() )
        p->writeStyleInformation( styleStream );
    }
    }
}

void QTextEdit::removeSelection( int selNum )
{
    doc->removeSelection( selNum );
    repaintChanged();
}

void QTextEdit::removeSelectedText( int selNum )
{
    if ( isReadOnly() )
    return;

    QTextCursor c1 = doc->selectionStartCursor( selNum );
    c1.restoreState();
    QTextCursor c2 = doc->selectionEndCursor( selNum );
    c2.restoreState();

    // ### no support for editing tables yet, plus security for broken selections
    if ( c1.nestedDepth() || c2.nestedDepth() )
    return;

    for ( int i = 0; i < (int)doc->numSelections(); ++i ) {
    if ( i == selNum )
        continue;
    doc->removeSelection( i );
    }

    drawCursor( FALSE );
    checkUndoRedoInfo( UndoRedoInfo::RemoveSelected );
    if ( !undoRedoInfo.valid() ) {
    doc->selectionStart( selNum, undoRedoInfo.id, undoRedoInfo.index );
    undoRedoInfo.d->text = QString::null;
    }
    readFormats( c1, c2, undoRedoInfo.d->text, TRUE );


    doc->removeSelectedText( selNum, cursor );
    if ( cursor->isValid() ) {
    ensureCursorVisible();
    lastFormatted = cursor->paragraph();
    formatMore();
    repaintChanged();
    ensureCursorVisible();
    drawCursor( TRUE );
    clearUndoRedo();
#if defined(Q_WS_WIN)
    // there seems to be a problem with repainting or erasing the area
    // of the scrollview which is not the contents on windows
    if ( contentsHeight() < visibleHeight() )
        viewport()->repaint( 0, contentsHeight(), visibleWidth(), visibleHeight() - contentsHeight(), TRUE );
#endif
#ifndef QT_NO_CURSOR
    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
    updateMicroFocusHint();
    } else {
    delete cursor;
    cursor = new QTextCursor( doc );
    drawCursor( TRUE );
    viewport()->repaint( TRUE );
    }
    setModified();
    emit textChanged();
    emit selectionChanged();
}

void QTextEdit::moveCursor( CursorAction action, bool select )
{
    drawCursor( FALSE );
    if ( select ) {
    if ( !doc->hasSelection( QTextDocument::Standard ) )
        doc->setSelectionStart( QTextDocument::Standard, *cursor );
    moveCursor( action );
    if ( doc->setSelectionEnd( QTextDocument::Standard, *cursor ) ) {
        cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
        repaintChanged();
    } else {
        drawCursor( TRUE );
    }
    ensureCursorVisible();
    emit selectionChanged();
    emit copyAvailable( doc->hasSelection( QTextDocument::Standard ) );
    } else {
    bool redraw = doc->removeSelection( QTextDocument::Standard );
    moveCursor( action );
    if ( !redraw ) {
        ensureCursorVisible();
        drawCursor( TRUE );
    } else {
        cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
        repaintChanged();
        ensureCursorVisible();
        drawCursor( TRUE );
#ifndef QT_NO_CURSOR
        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
    }
    if ( redraw ) {
        emit copyAvailable( doc->hasSelection( QTextDocument::Standard ) );
        emit selectionChanged();
    }
    }

    drawCursor( TRUE );
    updateCurrentFormat();
    updateMicroFocusHint();
}

void QTextEdit::moveCursor( CursorAction action )
{
    switch ( action ) {
    case MoveBackward:
    cursor->gotoPreviousLetter();
    break;
    case MoveWordBackward:
    cursor->gotoPreviousWord();
    break;
    case MoveForward:
    cursor->gotoNextLetter();
    break;
    case MoveWordForward:
    cursor->gotoNextWord();
    break;
    case MoveUp:
    cursor->gotoUp();
    break;
    case MovePgUp:
    cursor->gotoPageUp( visibleHeight() );
    break;
    case MoveDown:
    cursor->gotoDown();
    break;
    case MovePgDown:
    cursor->gotoPageDown( visibleHeight() );
    break;
    case MoveLineStart:
    cursor->gotoLineStart();
    break;
    case MoveHome:
    cursor->gotoHome();
    break;
    case MoveLineEnd:
    cursor->gotoLineEnd();
    break;
    case MoveEnd:
    ensureFormatted( doc->lastParagraph() );
    cursor->gotoEnd();
    break;
    }
    updateMicroFocusHint();
    updateCurrentFormat();
}

void QTextEdit::resizeEvent( QResizeEvent *e )
{
    QScrollView::resizeEvent( e );
    if ( doc->visibleWidth() == 0 )
    doResize();
}

void QTextEdit::viewportResizeEvent( QResizeEvent *e )
{
    QScrollView::viewportResizeEvent( e );
    if ( e->oldSize().width() != e->size().width() ) {
    bool stayAtBottom = e->oldSize().height() != e->size().height() &&
           contentsY() > 0 && contentsY() >= doc->height() - e->oldSize().height();
    doResize();
    if ( stayAtBottom )
        scrollToBottom();
    }
}

void QTextEdit::ensureCursorVisible()
{
    if ( !isVisible() ) {
    d->ensureCursorVisibleInShowEvent = TRUE;
    return;
    }
    lastFormatted = cursor->paragraph();
    formatMore();
    QTextStringChar *chr = cursor->paragraph()->at( cursor->index() );
    int h = cursor->paragraph()->lineHeightOfChar( cursor->index() );
    int x = cursor->paragraph()->rect().x() + chr->x + cursor->offsetX();
    int y = 0; int dummy;
    cursor->paragraph()->lineHeightOfChar( cursor->index(), &dummy, &y );
    y += cursor->paragraph()->rect().y() + cursor->offsetY();
    int w = 1;
    ensureVisible( x, y + h / 2, w, h / 2 + 2 );
}

void QTextEdit::drawCursor( bool visible )
{
    if ( !isUpdatesEnabled() ||
     !viewport()->isUpdatesEnabled() ||
     !cursor->paragraph() ||
     !cursor->paragraph()->isValid() ||
     !selectedText().isEmpty() ||
     ( visible && !hasFocus() && !viewport()->hasFocus() && !inDnD ) ||
     isReadOnly() )
    return;

    QPainter p( viewport() );
    QRect r( cursor->topParagraph()->rect() );
    cursor->paragraph()->setChanged( TRUE );
    p.translate( -contentsX() + cursor->totalOffsetX(), -contentsY() + cursor->totalOffsetY() );
    QPixmap *pix = 0;
    QColorGroup cg( colorGroup() );
    if ( cursor->paragraph()->background() )
    cg.setBrush( QColorGroup::Base, *cursor->paragraph()->background() );
    else if ( doc->paper() )
    cg.setBrush( QColorGroup::Base, *doc->paper() );
    p.setBrushOrigin( -contentsX(), -contentsY() );
    cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
    if ( !cursor->nestedDepth() ) {
    int h = cursor->paragraph()->lineHeightOfChar( cursor->index() );
    int dist = 5;
    if ( ( cursor->paragraph()->alignment() & Qt3::AlignJustify ) == Qt3::AlignJustify )
        dist = 50;
    int x = r.x() - cursor->totalOffsetX() + cursor->x() - dist;
    x = QMAX( x, 0 );
    p.setClipRect( QRect( x - contentsX(),
                  r.y() - cursor->totalOffsetY() + cursor->y() - contentsY(), 2 * dist, h ) );
    doc->drawParagraph( &p, cursor->paragraph(), x,
            r.y() - cursor->totalOffsetY() + cursor->y(), 2 * dist, h, pix, cg, visible, cursor );
    } else {
    doc->drawParagraph( &p, cursor->paragraph(), r.x() - cursor->totalOffsetX(),
            r.y() - cursor->totalOffsetY(), r.width(), r.height(),
            pix, cg, visible, cursor );
    }
    cursorVisible = visible;
}

enum {
    IdUndo = 0,
    IdRedo = 1,
    IdCut = 2,
    IdCopy = 3,
    IdPaste = 4,
    IdClear = 5,
    IdSelectAll = 6
};

#ifndef QT_NO_WHEELEVENT
void QTextEdit::contentsWheelEvent( QWheelEvent *e )
{
    if ( isReadOnly() ) {
    if ( e->state() & ControlButton ) {
        if ( e->delta() > 0 )
        zoomOut();
        else if ( e->delta() < 0 )
        zoomIn();
        return;
    }
    }
    QScrollView::contentsWheelEvent( e );
}
#endif

void QTextEdit::contentsMousePressEvent( QMouseEvent *e )
{
    clearUndoRedo();
    QTextCursor oldCursor = *cursor;
    QTextCursor c = *cursor;
    mousePos = e->pos();
    mightStartDrag = FALSE;
    pressedLink = QString::null;

    if ( e->button() == LeftButton ) {
    mousePressed = TRUE;
    drawCursor( FALSE );
    placeCursor( e->pos() );
    ensureCursorVisible();

    if ( isReadOnly() && linksEnabled() ) {
        QTextCursor c = *cursor;
        placeCursor( e->pos(), &c, TRUE );
        if ( c.paragraph() && c.paragraph()->at( c.index() ) &&
         c.paragraph()->at( c.index() )->isAnchor() ) {
        pressedLink = c.paragraph()->at( c.index() )->anchorHref();
        }
    }

#ifndef QT_NO_DRAGANDDROP
    if ( doc->inSelection( QTextDocument::Standard, e->pos() ) ) {
        mightStartDrag = TRUE;
        drawCursor( TRUE );
        dragStartTimer->start( QApplication::startDragTime(), TRUE );
        dragStartPos = e->pos();
        return;
    }
#endif

    bool redraw = FALSE;
    if ( doc->hasSelection( QTextDocument::Standard ) ) {
        if ( !( e->state() & ShiftButton ) ) {
        redraw = doc->removeSelection( QTextDocument::Standard );
        doc->setSelectionStart( QTextDocument::Standard, *cursor );
        } else {
        redraw = doc->setSelectionEnd( QTextDocument::Standard, *cursor ) || redraw;
        }
    } else {
        if ( isReadOnly() || !( e->state() & ShiftButton ) ) {
        doc->setSelectionStart( QTextDocument::Standard, *cursor );
        } else {
        doc->setSelectionStart( QTextDocument::Standard, c );
        redraw = doc->setSelectionEnd( QTextDocument::Standard, *cursor ) || redraw;
        }
    }

    for ( int i = 1; i < doc->numSelections(); ++i ) // start with 1 as we don't want to remove the Standard-Selection
        redraw = doc->removeSelection( i ) || redraw;

    if ( !redraw ) {
        drawCursor( TRUE );
    } else {
        repaintChanged();
#ifndef QT_NO_CURSOR
        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
    }
    } else if ( e->button() == MidButton ) {
    bool redraw = doc->removeSelection( QTextDocument::Standard );
    if ( !redraw ) {
        drawCursor( TRUE );
    } else {
        repaintChanged();
#ifndef QT_NO_CURSOR
        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
    }
    }

    if ( *cursor != oldCursor )
    updateCurrentFormat();
}

void QTextEdit::contentsMouseMoveEvent( QMouseEvent *e )
{
    if ( mousePressed ) {
#ifndef QT_NO_DRAGANDDROP
    if ( mightStartDrag ) {
        dragStartTimer->stop();
        if ( ( e->pos() - dragStartPos ).manhattanLength() > QApplication::startDragDistance() )
        startDrag();
#ifndef QT_NO_CURSOR
        if ( !isReadOnly() )
        viewport()->setCursor( ibeamCursor );
#endif
        return;
    }
#endif
    mousePos = e->pos();
    handleMouseMove( mousePos );
    oldMousePos = mousePos;
    }

#ifndef QT_NO_CURSOR
    if ( !isReadOnly() && !mousePressed ) {
    if ( doc->hasSelection( QTextDocument::Standard ) && doc->inSelection( QTextDocument::Standard, e->pos() ) )
        viewport()->setCursor( arrowCursor );
    else
        viewport()->setCursor( ibeamCursor );
    }
#endif
    updateCursor( e->pos() );
}

void QTextEdit::contentsMouseReleaseEvent( QMouseEvent * e )
{
    QTextCursor oldCursor = *cursor;
    if ( scrollTimer->isActive() )
    scrollTimer->stop();
#ifndef QT_NO_DRAGANDDROP
    if ( dragStartTimer->isActive() )
    dragStartTimer->stop();
    if ( mightStartDrag ) {
    selectAll( FALSE );
    mousePressed = FALSE;
    }
#endif
    if ( mousePressed ) {
    mousePressed = FALSE;
    }
    emit cursorPositionChanged( cursor );
    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
    if ( oldCursor != *cursor )
    updateCurrentFormat();
    inDoubleClick = FALSE;

#ifndef QT_NO_NETWORKPROTOCOL
    if ( !onLink.isEmpty() && onLink == pressedLink && linksEnabled() ) {
    QUrl u( doc->context(), onLink, TRUE );
    emitLinkClicked( u.toString( FALSE, FALSE ) );

    // emitting linkClicked() may result in that the cursor winds
    // up hovering over a different valid link - check this and
    // set the appropriate cursor shape
    updateCursor( e->pos() );
    }
#endif
    drawCursor( TRUE );
    if ( !doc->hasSelection( QTextDocument::Standard, TRUE ) )
    doc->removeSelection( QTextDocument::Standard );

    emit copyAvailable( doc->hasSelection( QTextDocument::Standard ) );
    emit selectionChanged();
}

void QTextEdit::contentsMouseDoubleClickEvent( QMouseEvent * )
{
    QTextCursor c1 = *cursor;
    QTextCursor c2 = *cursor;
    if ( cursor->index() > 0 && !cursor->paragraph()->at( cursor->index()-1 )->c.isSpace() )
    c1.gotoPreviousWord();
    if ( !cursor->paragraph()->at( cursor->index() )->c.isSpace() && !cursor->atParagEnd() )
    c2.gotoNextWord();

    doc->setSelectionStart( QTextDocument::Standard, c1 );
    doc->setSelectionEnd( QTextDocument::Standard, c2 );

    *cursor = c2;

    repaintChanged();

    inDoubleClick = TRUE;
    mousePressed = TRUE;
}

#ifndef QT_NO_DRAGANDDROP

void QTextEdit::contentsDragEnterEvent( QDragEnterEvent *e )
{
    if ( isReadOnly() || !QTextDrag::canDecode( e ) ) {
    e->ignore();
    return;
    }
    e->acceptAction();
    inDnD = TRUE;
}

void QTextEdit::contentsDragMoveEvent( QDragMoveEvent *e )
{
    if ( isReadOnly() || !QTextDrag::canDecode( e ) ) {
    e->ignore();
    return;
    }
    drawCursor( FALSE );
    placeCursor( e->pos(),  cursor );
    drawCursor( TRUE );
    e->acceptAction();
}

void QTextEdit::contentsDragLeaveEvent( QDragLeaveEvent * )
{
    inDnD = FALSE;
}

void QTextEdit::contentsDropEvent( QDropEvent *e )
{
    if ( isReadOnly() )
    return;
    inDnD = FALSE;
    e->acceptAction();
    QString text;
    bool intern = FALSE;
    if ( QTextDrag::decode( e, text ) ) {
    bool hasSel = doc->hasSelection( QTextDocument::Standard );
    bool internalDrag = e->source() == this || e->source() == viewport();
    int dropId, dropIndex;
    QTextCursor insertCursor = *cursor;
    dropId = cursor->paragraph()->paragId();
    dropIndex = cursor->index();
    if ( hasSel && internalDrag ) {
        QTextCursor c1, c2;
        int selStartId, selStartIndex;
        int selEndId, selEndIndex;
        c1 = doc->selectionStartCursor( QTextDocument::Standard );
        c1.restoreState();
        c2 = doc->selectionEndCursor( QTextDocument::Standard );
        c2.restoreState();
        selStartId = c1.paragraph()->paragId();
        selStartIndex = c1.index();
        selEndId = c2.paragraph()->paragId();
        selEndIndex = c2.index();
        if ( ( ( dropId > selStartId ) ||
           ( dropId == selStartId && dropIndex > selStartIndex ) ) &&
         ( ( dropId < selEndId ) ||
           ( dropId == selEndId && dropIndex <= selEndIndex ) ) )
        insertCursor = c1;
        if ( dropId == selEndId && dropIndex > selEndIndex ) {
        insertCursor = c1;
        if ( selStartId == selEndId ) {
            insertCursor.setIndex( dropIndex -
                       ( selEndIndex - selStartIndex ) );
        } else {
            insertCursor.setIndex( dropIndex - selEndIndex +
                       selStartIndex );
        }
        }
     }

    if ( internalDrag && e->action() == QDropEvent::Move ) {
        removeSelectedText();
        intern = TRUE;
    } else {
        doc->removeSelection( QTextDocument::Standard );
#ifndef QT_NO_CURSOR
        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
    }
    drawCursor( FALSE );
    cursor->setParagraph( insertCursor.paragraph() );
    cursor->setIndex( insertCursor.index() );
    drawCursor( TRUE );
    if ( !cursor->nestedDepth() ) {
        insert( text, FALSE, TRUE, FALSE );
    } else {
        if ( intern )
        undo();
        e->ignore();
    }
    }
}

#endif

void QTextEdit::autoScrollTimerDone()
{
    if ( mousePressed )
    handleMouseMove(  viewportToContents( viewport()->mapFromGlobal( QCursor::pos() )  ) );
}

void QTextEdit::handleMouseMove( const QPoint& pos )
{
    if ( !mousePressed )
    return;

    if ( !scrollTimer->isActive() && pos.y() < contentsY() || pos.y() > contentsY() + visibleHeight() )
    scrollTimer->start( 100, FALSE );
    else if ( scrollTimer->isActive() && pos.y() >= contentsY() && pos.y() <= contentsY() + visibleHeight() )
    scrollTimer->stop();

    drawCursor( FALSE );
    QTextCursor oldCursor = *cursor;

    placeCursor( pos );

    if ( inDoubleClick ) {
    QTextCursor cl = *cursor;
    cl.gotoPreviousWord();
    QTextCursor cr = *cursor;
    cr.gotoNextWord();

    int diff = QABS( oldCursor.paragraph()->at( oldCursor.index() )->x - mousePos.x() );
    int ldiff = QABS( cl.paragraph()->at( cl.index() )->x - mousePos.x() );
    int rdiff = QABS( cr.paragraph()->at( cr.index() )->x - mousePos.x() );


    if ( cursor->paragraph()->lineStartOfChar( cursor->index() ) !=
         oldCursor.paragraph()->lineStartOfChar( oldCursor.index() ) )
        diff = 0xFFFFFF;

    if ( rdiff < diff && rdiff < ldiff )
        *cursor = cr;
    else if ( ldiff < diff && ldiff < rdiff )
        *cursor = cl;
    else
        *cursor = oldCursor;

    }
    ensureCursorVisible();

    bool redraw = FALSE;
    if ( doc->hasSelection( QTextDocument::Standard ) ) {
    redraw = doc->setSelectionEnd( QTextDocument::Standard, *cursor ) || redraw;
    }

    if ( !redraw ) {
    drawCursor( TRUE );
    } else {
    repaintChanged();
    drawCursor( TRUE );
    }

    if ( currentFormat && currentFormat->key() != cursor->paragraph()->at( cursor->index() )->format()->key() ) {
    currentFormat->removeRef();
    currentFormat = doc->formatCollection()->format( cursor->paragraph()->at( cursor->index() )->format() );
    if ( currentFormat->isMisspelled() ) {
        currentFormat->removeRef();
        currentFormat = doc->formatCollection()->format( currentFormat->font(), currentFormat->color() );
    }
    emit currentFontChanged( currentFormat->font() );
    emit currentColorChanged( currentFormat->color() );
    emit currentVerticalAlignmentChanged( (VerticalAlignment)currentFormat->vAlign() );
    }

    if ( currentAlignment != cursor->paragraph()->alignment() ) {
    currentAlignment = cursor->paragraph()->alignment();
    block_set_alignment = TRUE;
    emit currentAlignmentChanged( currentAlignment );
    block_set_alignment = FALSE;
    }
}

void QTextEdit::placeCursor( const QPoint &pos, QTextCursor *c, bool link )
{
    if ( !c )
    c = cursor;

    c->restoreState();
    QTextParagraph *s = doc->firstParagraph();
    c->place( pos, s, link );
    updateMicroFocusHint();
}


void QTextEdit::updateMicroFocusHint()
{
    QTextCursor c( *cursor );
    if ( d->preeditStart != -1 )
    c.setIndex( d->preeditStart );

    if ( hasFocus() || viewport()->hasFocus() ) {
    int h = c.paragraph()->lineHeightOfChar( cursor->index() );
    if ( !readonly ) {
        QFont f = c.paragraph()->at( c.index() )->format()->font();
        setMicroFocusHint( c.x() - contentsX() + frameWidth(),
                   c.y() + cursor->paragraph()->rect().y() - contentsY() + frameWidth(), 0, h, TRUE );
    }
    }
}



void QTextEdit::formatMore()
{
    if ( !lastFormatted )
    return;

    int bottom = contentsHeight();
    int lastBottom = -1;
    int to = 20;
    bool firstVisible = FALSE;
    QRect cr( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
    for ( int i = 0; ( i < to || firstVisible ) && lastFormatted; ++i ) {
    lastFormatted->format();
    if ( i == 0 )
        firstVisible = lastFormatted->rect().intersects( cr );
    else if ( firstVisible )
        firstVisible = lastFormatted->rect().intersects( cr );
    bottom = QMAX( bottom, lastFormatted->rect().top() +
               lastFormatted->rect().height() );
    lastBottom = lastFormatted->rect().top() + lastFormatted->rect().height();
    lastFormatted = lastFormatted->next();
    if ( lastFormatted )
        lastBottom = -1;
    }

    if ( bottom > contentsHeight() ) {
    resizeContents( contentsWidth(), QMAX( doc->height(), bottom ) );
    } else if ( lastBottom != -1 && lastBottom < contentsHeight() ) {
    resizeContents( contentsWidth(), QMAX( doc->height(), lastBottom ) );
    if ( contentsHeight() < visibleHeight() )
        updateContents( 0, contentsHeight(), visibleWidth(),
                visibleHeight() - contentsHeight() );
    }

    if ( lastFormatted )
    formatTimer->start( interval, TRUE );
    else
    interval = QMAX( 0, interval );
}

void QTextEdit::doResize()
{
    if ( wrapMode == FixedPixelWidth )
    return;
    doc->setMinimumWidth( -1 );
    resizeContents( 0, 0 );
    doc->setWidth( visibleWidth() );
    doc->invalidate();
    lastFormatted = doc->firstParagraph();
    interval = 0;
    formatMore();
    repaintContents( contentsX(), contentsY(), visibleWidth(), visibleHeight(), FALSE );
}

void QTextEdit::doChangeInterval()
{
    interval = 0;
}

bool QTextEdit::eventFilter( QObject *o, QEvent *e )
{
    if ( o == this || o == viewport() ) {
    if ( e->type() == QEvent::FocusIn ) {
        blinkTimer->start( QApplication::cursorFlashTime() / 2 );
        drawCursor( TRUE );
        updateMicroFocusHint();
    } else if ( e->type() == QEvent::FocusOut ) {
        blinkTimer->stop();
        drawCursor( FALSE );
    }
    }

    return QScrollView::eventFilter( o, e );
}

void QTextEdit::insert( const QString &text, bool indent, bool checkNewLine, bool removeSelected )
{
    if ( cursor->nestedDepth() != 0 ) // #### for 3.0, disable editing of tables as this is not advanced enough
    return;
    QString txt( text );
    drawCursor( FALSE );
    if ( !isReadOnly() && doc->hasSelection( QTextDocument::Standard ) && removeSelected )
    removeSelectedText();
    QTextCursor c2 = *cursor;
    int oldLen = 0;

    if ( undoEnabled && !isReadOnly() ) {
    checkUndoRedoInfo( UndoRedoInfo::Insert );
    if ( !undoRedoInfo.valid() ) {
        undoRedoInfo.id = cursor->paragraph()->paragId();
        undoRedoInfo.index = cursor->index();
        undoRedoInfo.d->text = QString::null;
    }
    oldLen = undoRedoInfo.d->text.length();
    }

    lastFormatted = checkNewLine && cursor->paragraph()->prev() ?
            cursor->paragraph()->prev() : cursor->paragraph();
    QTextCursor oldCursor = *cursor;
    cursor->insert( txt, checkNewLine );
    if ( doc->useFormatCollection() ) {
    doc->setSelectionStart( QTextDocument::Temp, oldCursor );
    doc->setSelectionEnd( QTextDocument::Temp, *cursor );
    doc->setFormat( QTextDocument::Temp, currentFormat, QTextFormat::Format );
    doc->removeSelection( QTextDocument::Temp );
    }

    if ( indent && ( txt == "{" || txt == "}" || txt == ":" || txt == "#" ) )
    cursor->indent();
    formatMore();
    repaintChanged();
    ensureCursorVisible();
    drawCursor( TRUE );

    if ( undoEnabled && !isReadOnly() ) {
    undoRedoInfo.d->text += txt;
    if ( !doc->preProcessor() ) {
        for ( int i = 0; i < (int)txt.length(); ++i ) {
        if ( txt[ i ] != '\n' && c2.paragraph()->at( c2.index() )->format() ) {
            c2.paragraph()->at( c2.index() )->format()->addRef();
            undoRedoInfo.d->text.setFormat( oldLen + i, c2.paragraph()->at( c2.index() )->format(), TRUE );
        }
        c2.gotoNextLetter();
        }
    }
    }

    if ( !removeSelected ) {
    doc->setSelectionStart( QTextDocument::Standard, oldCursor );
    doc->setSelectionEnd( QTextDocument::Standard, *cursor );
    repaintChanged();
    }
    updateMicroFocusHint();
    setModified();
    emit textChanged();
}

void QTextEdit::insertAt( const QString &text, int para, int index )
{
    removeSelection( QTextDocument::Standard );
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return;
    QTextCursor tmp = *cursor;
    cursor->setParagraph( p );
    cursor->setIndex( index );
    insert( text, FALSE, TRUE, FALSE );
    *cursor = tmp;
    removeSelection( QTextDocument::Standard );
}

void QTextEdit::insertParagraph( const QString &text, int para )
{
    QTextParagraph *p = doc->paragAt( para );
    if ( p ) {
    QTextCursor tmp( doc );
    tmp.setParagraph( p );
    tmp.setIndex( 0 );
    tmp.insert( text, TRUE );
    tmp.splitAndInsertEmptyParagraph();
    repaintChanged();
    } else {
    append( text );
    }
}

void QTextEdit::removeParagraph( int para )
{
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return;
    for ( int i = 0; i < doc->numSelections(); ++i )
    doc->removeSelection( i );

    if ( p == doc->firstParagraph() && p == doc->lastParagraph() ) {
    p->remove( 0, p->length() - 1 );
    repaintChanged();
    return;
    }
    drawCursor( FALSE );
    bool resetCursor = cursor->paragraph() == p;
    if ( p->prev() )
    p->prev()->setNext( p->next() );
    else
    doc->setFirstParagraph( p->next() );
    if ( p->next() )
    p->next()->setPrev( p->prev() );
    else
    doc->setLastParagraph( p->prev() );
    QTextParagraph *start = p->next();
    int h = p->rect().height();
    delete p;
    p = start;
    int dy = -h;
    while ( p ) {
    p->setParagId( p->prev() ? p->prev()->paragId() + 1 : 0 );
    p->move( dy );
    p->invalidate( 0 );
    p->setEndState( -1 );
    p = p->next();
    }

    if ( resetCursor ) {
    cursor->setParagraph( doc->firstParagraph() );
    cursor->setIndex( 0 );
    }
    repaintChanged();
    drawCursor( TRUE );
}

void QTextEdit::undo()
{
    // XXX FIXME The next line is here because there may be a command
    // that needs to be 'flushed'.  The FIXME is because I am not
    // 100% certain this is the right call to do this.
    clearUndoRedo();
    if ( isReadOnly() || !doc->commands()->isUndoAvailable() || !undoEnabled )
    return;

    for ( int i = 0; i < (int)doc->numSelections(); ++i )
    doc->removeSelection( i );

#ifndef QT_NO_CURSOR
    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif

    clearUndoRedo();
    drawCursor( FALSE );
    QTextCursor *c = doc->undo( cursor );
    if ( !c ) {
    drawCursor( TRUE );
    return;
    }
    lastFormatted = 0;
    ensureCursorVisible();
    repaintChanged();
    drawCursor( TRUE );
    updateMicroFocusHint();
    setModified();
    emit textChanged();
}

void QTextEdit::redo()
{
    if ( isReadOnly() || !doc->commands()->isRedoAvailable() || !undoEnabled )
    return;

    for ( int i = 0; i < (int)doc->numSelections(); ++i )
    doc->removeSelection( i );

#ifndef QT_NO_CURSOR
    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif

    clearUndoRedo();
    drawCursor( FALSE );
    QTextCursor *c = doc->redo( cursor );
    if ( !c ) {
    drawCursor( TRUE );
    return;
    }
    lastFormatted = 0;
    ensureCursorVisible();
    repaintChanged();
    ensureCursorVisible();
    drawCursor( TRUE );
    updateMicroFocusHint();
    setModified();
    emit textChanged();
}

void QTextEdit::paste()
{
#ifndef QT_NO_CLIPBOARD
    if ( isReadOnly() )
    return;
    pasteSubType( "plain" );
    updateMicroFocusHint();
#endif
}

void QTextEdit::checkUndoRedoInfo( UndoRedoInfo::Type t )
{
    if ( undoRedoInfo.valid() && t != undoRedoInfo.type ) {
    clearUndoRedo();
    }
    undoRedoInfo.type = t;
}

void QTextEdit::repaintChanged()
{
    if ( !isUpdatesEnabled() || !viewport()->isUpdatesEnabled() )
    return;
    QPainter p( viewport() );
    p.translate( -contentsX(), -contentsY() );
    paintDocument( FALSE, &p, contentsX(), contentsY(), visibleWidth(), visibleHeight() );
}

void QTextEdit::cut()
{
    if ( isReadOnly() )
    return;

    QString t;
    if ( doc->hasSelection( QTextDocument::Standard ) &&
     !( t = doc->selectedText( QTextDocument::Standard, qt_enable_richtext_copy ) ).isEmpty() ) {
    QApplication::clipboard()->setText( t );
    removeSelectedText();
    }
    updateMicroFocusHint();
}

void QTextEdit::copy()
{
    QString t = doc->selectedText( QTextDocument::Standard, qt_enable_richtext_copy );
    if ( doc->hasSelection( QTextDocument::Standard ) &&
     !t.isEmpty() && t.simplifyWhiteSpace() != "<selstart/>" )
    QApplication::clipboard()->setText( t );
}

void QTextEdit::indent()
{
    if ( isReadOnly() )
    return;

    drawCursor( FALSE );
    if ( !doc->hasSelection( QTextDocument::Standard ) )
    cursor->indent();
    else
    doc->indentSelection( QTextDocument::Standard );
    repaintChanged();
    drawCursor( TRUE );
    setModified();
    emit textChanged();
}

bool QTextEdit::focusNextPrevChild( bool n )
{
    if ( !isReadOnly() || !linksEnabled() )
    return FALSE;
    bool b = doc->focusNextPrevChild( n );
    repaintChanged();
    if ( b )
    //##### this does not work with tables. The focusIndicator
    //should really be a QTextCursor. Fix 3.1
    makeParagVisible( doc->focusIndicator.parag );
    return b;
}

void QTextEdit::setFormat( QTextFormat *f, int flags )
{
    if ( doc->hasSelection( QTextDocument::Standard ) ) {
    drawCursor( FALSE );
    QTextCursor c1 = doc->selectionStartCursor( QTextDocument::Standard );
    c1.restoreState();
    QTextCursor c2 = doc->selectionEndCursor( QTextDocument::Standard );
    c2.restoreState();
    clearUndoRedo();
    undoRedoInfo.type = UndoRedoInfo::Format;
    undoRedoInfo.id = c1.paragraph()->paragId();
    undoRedoInfo.index = c1.index();
    undoRedoInfo.eid = c2.paragraph()->paragId();
    undoRedoInfo.eindex = c2.index();
    readFormats( c1, c2, undoRedoInfo.d->text );
    undoRedoInfo.format = f;
    undoRedoInfo.flags = flags;
    clearUndoRedo();
    doc->setFormat( QTextDocument::Standard, f, flags );
    repaintChanged();
    formatMore();
    drawCursor( TRUE );
    setModified();
    emit textChanged();
    }
    if ( currentFormat && currentFormat->key() != f->key() ) {
    currentFormat->removeRef();
    currentFormat = doc->formatCollection()->format( f );
    if ( currentFormat->isMisspelled() ) {
        currentFormat->removeRef();
        currentFormat = doc->formatCollection()->format( currentFormat->font(), currentFormat->color() );
    }
    emit currentFontChanged( currentFormat->font() );
    emit currentColorChanged( currentFormat->color() );
    emit currentVerticalAlignmentChanged( (VerticalAlignment)currentFormat->vAlign() );
    if ( cursor->index() == cursor->paragraph()->length() - 1 ) {
        currentFormat->addRef();
        cursor->paragraph()->string()->setFormat( cursor->index(), currentFormat, TRUE );
        if ( cursor->paragraph()->length() == 1 ) {
        cursor->paragraph()->invalidate( 0 );
        cursor->paragraph()->format();
        repaintChanged();
        }
    }
    }
}

void QTextEdit::setPalette( const QPalette &p )
{
    QScrollView::setPalette( p );
    if ( textFormat() == PlainText ) {
    QTextFormat *f = doc->formatCollection()->defaultFormat();
    f->setColor( colorGroup().text() );
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
    }
}

void QTextEdit::setParagType( QStyleSheetItem::DisplayMode dm, QStyleSheetItem::ListStyle listStyle )
{
    if ( isReadOnly() )
    return;

    drawCursor( FALSE );
    QTextParagraph *start = cursor->paragraph();
    QTextParagraph *end = start;
    if ( doc->hasSelection( QTextDocument::Standard ) ) {
    start = doc->selectionStartCursor( QTextDocument::Standard ).topParagraph();
    end = doc->selectionEndCursor( QTextDocument::Standard ).topParagraph();
    if ( end->paragId() < start->paragId() )
        return; // do not trust our selections
    }

    clearUndoRedo();
    undoRedoInfo.type = UndoRedoInfo::Style;
    undoRedoInfo.id = start->paragId();
    undoRedoInfo.eid = end->paragId();
    undoRedoInfo.styleInformation = QTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );

    while ( start != end->next() ) {
    start->setListStyle( listStyle );
    if ( dm == QStyleSheetItem::DisplayListItem ) {
        start->setListItem( TRUE );
        if( start->listDepth() == 0 )
        start->setListDepth( 1 );
    } else if ( start->isListItem() ) {
        start->setListItem( FALSE );
        start->setListDepth( QMAX( start->listDepth()-1, 0 ) );
    }
    start = start->next();
    }

    clearUndoRedo();
    repaintChanged();
    formatMore();
    drawCursor( TRUE );
    setModified();
    emit textChanged();
}

void QTextEdit::setAlignment( int a )
{
    if ( isReadOnly() || block_set_alignment )
    return;

    drawCursor( FALSE );
    QTextParagraph *start = cursor->paragraph();
    QTextParagraph *end = start;
    if ( doc->hasSelection( QTextDocument::Standard ) ) {
    start = doc->selectionStartCursor( QTextDocument::Standard ).topParagraph();
    end = doc->selectionEndCursor( QTextDocument::Standard ).topParagraph();
    if ( end->paragId() < start->paragId() )
        return; // do not trust our selections
    }

    clearUndoRedo();
    undoRedoInfo.type = UndoRedoInfo::Style;
    undoRedoInfo.id = start->paragId();
    undoRedoInfo.eid = end->paragId();
    undoRedoInfo.styleInformation = QTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );

    while ( start != end->next() ) {
    start->setAlignment( a );
    start = start->next();
    }

    clearUndoRedo();
    repaintChanged();
    formatMore();
    drawCursor( TRUE );
    if ( currentAlignment != a ) {
    currentAlignment = a;
    emit currentAlignmentChanged( currentAlignment );
    }
    setModified();
    emit textChanged();
}

void QTextEdit::updateCurrentFormat()
{
    int i = cursor->index();
    if ( i > 0 )
    --i;
    if ( doc->useFormatCollection() &&
     ( !currentFormat || currentFormat->key() != cursor->paragraph()->at( i )->format()->key() ) ) {
    if ( currentFormat )
        currentFormat->removeRef();
    currentFormat = doc->formatCollection()->format( cursor->paragraph()->at( i )->format() );
    if ( currentFormat->isMisspelled() ) {
        currentFormat->removeRef();
        currentFormat = doc->formatCollection()->format( currentFormat->font(), currentFormat->color() );
    }
    emit currentFontChanged( currentFormat->font() );
    emit currentColorChanged( currentFormat->color() );
    emit currentVerticalAlignmentChanged( (VerticalAlignment)currentFormat->vAlign() );
    }

    if ( currentAlignment != cursor->paragraph()->alignment() ) {
    currentAlignment = cursor->paragraph()->alignment();
    block_set_alignment = TRUE;
    emit currentAlignmentChanged( currentAlignment );
    block_set_alignment = FALSE;
    }
}

void QTextEdit::setItalic( bool b )
{
    QTextFormat f( *currentFormat );
    f.setItalic( b );
    QTextFormat *f2 = doc->formatCollection()->format( &f );
    setFormat( f2, QTextFormat::Italic );
}

void QTextEdit::setBold( bool b )
{
    QTextFormat f( *currentFormat );
    f.setBold( b );
    QTextFormat *f2 = doc->formatCollection()->format( &f );
    setFormat( f2, QTextFormat::Bold );
}

void QTextEdit::setUnderline( bool b )
{
    QTextFormat f( *currentFormat );
    f.setUnderline( b );
    QTextFormat *f2 = doc->formatCollection()->format( &f );
    setFormat( f2, QTextFormat::Underline );
}

void QTextEdit::setFamily( const QString &fontFamily )
{
    QTextFormat f( *currentFormat );
    f.setFamily( fontFamily );
    QTextFormat *f2 = doc->formatCollection()->format( &f );
    setFormat( f2, QTextFormat::Family );
}

void QTextEdit::setPointSize( int s )
{
    QTextFormat f( *currentFormat );
    f.setPointSize( s );
    QTextFormat *f2 = doc->formatCollection()->format( &f );
    setFormat( f2, QTextFormat::Size );
}

void QTextEdit::setColor( const QColor &c )
{
    QTextFormat f( *currentFormat );
    f.setColor( c );
    QTextFormat *f2 = doc->formatCollection()->format( &f );
    setFormat( f2, QTextFormat::Color );
}

void QTextEdit::setVerticalAlignment( VerticalAlignment a )
{
    QTextFormat f( *currentFormat );
    f.setVAlign( (QTextFormat::VerticalAlignment)a );
    QTextFormat *f2 = doc->formatCollection()->format( &f );
    setFormat( f2, QTextFormat::VAlign );
}

void QTextEdit::setFontInternal( const QFont &f_ )
{
    QTextFormat f( *currentFormat );
    f.setFont( f_ );
    QTextFormat *f2 = doc->formatCollection()->format( &f );
    setFormat( f2, QTextFormat::Font );
}


QString QTextEdit::text() const
{
    if ( isReadOnly() )
    return doc->originalText();
    return doc->text();
}

QString QTextEdit::text( int para ) const
{
    return doc->text( para );
}

void QTextEdit::setText( const QString &text, const QString &context )
{
    if ( !isModified() && isReadOnly() &&
     this->context() == context && this->text() == text )
    return;

    emit undoAvailable( FALSE );
    emit redoAvailable( FALSE );
    undoRedoInfo.clear();
    doc->commands()->clear();

    lastFormatted = 0;
    cursor->restoreState();
    doc->setText( text, context );

    if ( wrapMode == FixedPixelWidth ) {
    resizeContents( wrapWidth, 0 );
    doc->setWidth( wrapWidth );
    doc->setMinimumWidth( wrapWidth );
    } else {
    doc->setMinimumWidth( -1 );
    resizeContents( 0, 0 );
    }

    lastFormatted = doc->firstParagraph();
    delete cursor;
    cursor = new QTextCursor( doc );
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );

    if ( isModified() )
    setModified( FALSE );
    emit textChanged();
    formatMore();
    updateCurrentFormat();
    d->scrollToAnchor = QString::null;
}

bool QTextEdit::find( const QString &expr, bool cs, bool wo, bool forward,
              int *para, int *index )
{
    drawCursor( FALSE );
#ifndef QT_NO_CURSOR
    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
    QTextCursor findcur = *cursor;
    if ( para && index ) {
    if ( doc->paragAt( *para ) )
        findcur.gotoPosition( doc->paragAt(*para), *index );
    else
        findcur.gotoEnd();
    } else if ( doc->hasSelection( QTextDocument::Standard ) ){
    // maks sure we do not find the same selection again
    if ( forward )
        findcur.gotoNextLetter();
    else
        findcur.gotoPreviousLetter();
    }
    removeSelection( QTextDocument::Standard );
    bool found = doc->find( findcur, expr, cs, wo, forward );
    if ( found ) {
    if ( para )
        *para = findcur.paragraph()->paragId();
    if ( index )
        *index = findcur.index();
    *cursor = findcur;
    repaintChanged();
    ensureCursorVisible();
    }
    drawCursor( TRUE );
    return found;
}

void QTextEdit::blinkCursor()
{
    if ( !cursorVisible )
    return;
    bool cv = cursorVisible;
    blinkCursorVisible = !blinkCursorVisible;
    drawCursor( blinkCursorVisible );
    cursorVisible = cv;
}

void QTextEdit::setCursorPosition( int para, int index )
{
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return;

    if ( index > p->length() - 1 )
    index = p->length() - 1;

    drawCursor( FALSE );
    cursor->setParagraph( p );
    cursor->setIndex( index );
    ensureCursorVisible();
    drawCursor( TRUE );
    updateCurrentFormat();
    emit cursorPositionChanged( cursor );
    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
}

void QTextEdit::getCursorPosition( int *para, int *index ) const
{
    if ( !para || !index )
    return;
    *para = cursor->paragraph()->paragId();
    *index = cursor->index();
}

void QTextEdit::setSelection( int paraFrom, int indexFrom,
                  int paraTo, int indexTo, int selNum )
{
    if ( doc->hasSelection( selNum ) ) {
    doc->removeSelection( selNum );
    repaintChanged();
    }
    if ( selNum > doc->numSelections() - 1 )
    doc->addSelection( selNum );
    QTextParagraph *p1 = doc->paragAt( paraFrom );
    if ( !p1 )
    return;
    QTextParagraph *p2 = doc->paragAt( paraTo );
    if ( !p2 )
    return;

    if ( indexFrom > p1->length() - 1 )
    indexFrom = p1->length() - 1;
    if ( indexTo > p2->length() - 1 )
    indexTo = p2->length() - 1;

    drawCursor( FALSE );
    QTextCursor c = *cursor;
    QTextCursor oldCursor = *cursor;
    c.setParagraph( p1 );
    c.setIndex( indexFrom );
    cursor->setParagraph( p2 );
    cursor->setIndex( indexTo );
    doc->setSelectionStart( selNum, c );
    doc->setSelectionEnd( selNum, *cursor );
    repaintChanged();
    ensureCursorVisible();
    if ( selNum != QTextDocument::Standard )
    *cursor = oldCursor;
    drawCursor( TRUE );
}

void QTextEdit::getSelection( int *paraFrom, int *indexFrom,
                  int *paraTo, int *indexTo, int selNum ) const
{
    if ( !paraFrom || !paraTo || !indexFrom || !indexTo )
    return;
    if ( !doc->hasSelection( selNum ) ) {
    *paraFrom = -1;
    *indexFrom = -1;
    *paraTo = -1;
    *indexTo = -1;
    return;
    }

    doc->selectionStart( selNum, *paraFrom, *indexFrom );
    doc->selectionEnd( selNum, *paraTo, *indexTo );
}

void QTextEdit::setTextFormat( TextFormat format )
{
    doc->setTextFormat( format );
}

Qt::TextFormat QTextEdit::textFormat() const
{
    return doc->textFormat();
}

int QTextEdit::paragraphs() const
{
    return doc->lastParagraph()->paragId() + 1;
}

int QTextEdit::linesOfParagraph( int para ) const
{
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return -1;
    return p->lines();
}

int QTextEdit::paragraphLength( int para ) const
{
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return -1;
    return p->length() - 1;
}

int QTextEdit::lines() const
{
    QTextParagraph *p = doc->firstParagraph();
    int l = 0;
    while ( p ) {
    l += p->lines();
    p = p->next();
    }

    return l;
}

int QTextEdit::lineOfChar( int para, int index )
{
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return -1;

    int idx, line;
    QTextStringChar *c = p->lineStartOfChar( index, &idx, &line );
    if ( !c )
    return -1;

    return line;
}

void QTextEdit::setModified( bool m )
{
    bool oldModified = modified;
    modified = m;
    if ( modified && doc->oTextValid )
    doc->invalidateOriginalText();
    if ( oldModified != modified )
    emit modificationChanged( modified );
}

bool QTextEdit::isModified() const
{
    return modified;
}

void QTextEdit::setModified()
{
    if ( !isModified() )
    setModified( TRUE );
}

bool QTextEdit::italic() const
{
    return currentFormat->font().italic();
}

bool QTextEdit::bold() const
{
    return currentFormat->font().bold();
}

bool QTextEdit::underline() const
{
    return currentFormat->font().underline();
}

QString QTextEdit::family() const
{
    return currentFormat->font().family();
}

int QTextEdit::pointSize() const
{
    return currentFormat->font().pointSize();
}

QColor QTextEdit::color() const
{
    return currentFormat->color();
}

QFont QTextEdit::font() const
{
    return currentFormat->font();
}

int QTextEdit::alignment() const
{
    return currentAlignment;
}

void QTextEdit::startDrag()
{
#ifndef QT_NO_DRAGANDDROP
    mousePressed = FALSE;
    inDoubleClick = FALSE;
    QDragObject *drag = new QTextDrag( doc->selectedText( QTextDocument::Standard, qt_enable_richtext_copy ), viewport() );
    if ( isReadOnly() ) {
    drag->dragCopy();
    } else {
    if ( drag->drag() && QDragObject::target() != this && QDragObject::target() != viewport() )
        removeSelectedText();
    }
#endif
}

void QTextEdit::selectAll( bool select )
{
    if ( !select )
    doc->removeSelection( QTextDocument::Standard );
    else
    doc->selectAll( QTextDocument::Standard );
    repaintChanged();
    emit copyAvailable( doc->hasSelection( QTextDocument::Standard ) );
    emit selectionChanged();
#ifndef QT_NO_CURSOR
    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
}

void QTextEdit::UndoRedoInfo::clear()
{
    if ( valid() ) {
    if ( type == Insert || type == Return )
        doc->addCommand( new QTextInsertCommand( doc, id, index, d->text.rawData(), styleInformation ) );
    else if ( type == Format )
        doc->addCommand( new QTextFormatCommand( doc, id, index, eid, eindex, d->text.rawData(), format, flags ) );
    else if ( type == Style )
        doc->addCommand( new QTextStyleCommand( doc, id, eid, styleInformation ) );
    else if ( type != Invalid ) {
        doc->addCommand( new QTextDeleteCommand( doc, id, index, d->text.rawData(), styleInformation ) );
    }
    }
    type = Invalid;
    d->text = QString::null;
    id = -1;
    index = -1;
    styleInformation = QByteArray();
}


void QTextEdit::del()
{
    if ( doc->hasSelection( QTextDocument::Standard ) ) {
    removeSelectedText();
    return;
    }

    doKeyboardAction( ActionDelete );
}


QTextEdit::UndoRedoInfo::UndoRedoInfo( QTextDocument *dc )
    : type( Invalid ), doc( dc )
{
    d = new QUndoRedoInfoPrivate;
    d->text = QString::null;
    id = -1;
    index = -1;
}

QTextEdit::UndoRedoInfo::~UndoRedoInfo()
{
    delete d;
}

bool QTextEdit::UndoRedoInfo::valid() const
{
    return id >= 0 &&  type != Invalid;
}

void QTextEdit::resetFormat()
{
    setAlignment( Qt3::AlignAuto );
    setParagType( QStyleSheetItem::DisplayBlock, QStyleSheetItem::ListDisc );
    setFormat( doc->formatCollection()->defaultFormat(), QTextFormat::Format );
}

QStyleSheet* QTextEdit::styleSheet() const
{
    return doc->styleSheet();
}

void QTextEdit::setStyleSheet( QStyleSheet* styleSheet )
{
    doc->setStyleSheet( styleSheet );
}

void QTextEdit::setPaper( const QBrush& pap )
{
    doc->setPaper( new QBrush( pap ) );
    viewport()->setBackgroundColor( pap.color() );
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
}

QBrush QTextEdit::paper() const
{
    if ( doc->paper() )
    return *doc->paper();
    return QBrush();
}

void QTextEdit::setLinkUnderline( bool b )
{
    doc->setUnderlineLinks( b );
}

bool QTextEdit::linkUnderline() const
{
    return doc->underlineLinks();
}

void QTextEdit::setMimeSourceFactory( QMimeSourceFactory* factory )
{
    doc->setMimeSourceFactory( factory );
}

QMimeSourceFactory* QTextEdit::mimeSourceFactory() const
{
    return doc->mimeSourceFactory();
}

int QTextEdit::heightForWidth( int w ) const
{
    int oldw = doc->width();
    doc->doLayout( 0, w );
    int h = doc->height();
    doc->setWidth( oldw );
    doc->invalidate();
    ( (QTextEdit*)this )->formatMore();
    return h;
}

void QTextEdit::append( const QString &text )
{
    // flush and clear the undo/redo stack if necessary
    undoRedoInfo.clear();
    doc->commands()->clear();

    doc->removeSelection( QTextDocument::Standard );
    TextFormat f = doc->textFormat();
    if ( f == AutoText ) {
    if ( QStyleSheet::mightBeRichText( text ) )
        f = RichText;
    else
        f = PlainText;
    }

    drawCursor( FALSE );
    QTextCursor oldc( *cursor );
    ensureFormatted( doc->lastParagraph() );
    bool atBottom = contentsY() >= contentsHeight() - visibleHeight();
    cursor->gotoEnd();
    if ( cursor->index() > 0 )
    cursor->splitAndInsertEmptyParagraph();
    QTextCursor oldCursor2 = *cursor;

    if ( f == Qt::PlainText ) {
    cursor->insert( text, TRUE );
    if ( doc->useFormatCollection() &&
         currentFormat != cursor->paragraph()->at( cursor->index() )->format() ) {
        doc->setSelectionStart( QTextDocument::Temp, oldCursor2 );
        doc->setSelectionEnd( QTextDocument::Temp, *cursor );
        doc->setFormat( QTextDocument::Temp, currentFormat, QTextFormat::Format );
        doc->removeSelection( QTextDocument::Temp );
    }
    } else {
    if ( cursor->paragraph()->prev() )
        cursor->paragraph()->prev()->invalidate(0); // vertical margins might have to change
    doc->setRichTextInternal( text );
    }
    formatMore();
    repaintChanged();
    if ( atBottom )
        scrollToBottom();
    *cursor = oldc;
    if ( !isReadOnly() )
    cursorVisible = TRUE;
    setModified();
    emit textChanged();
}

bool QTextEdit::hasSelectedText() const
{
    return doc->hasSelection( QTextDocument::Standard );
}

QString QTextEdit::selectedText() const
{
    return doc->selectedText( QTextDocument::Standard );
}

bool QTextEdit::handleReadOnlyKeyEvent( QKeyEvent *e )
{
    switch( e->key() ) {
    case Key_Down:
    setContentsPos( contentsX(), contentsY() + 10 );
    break;
    case Key_Up:
    setContentsPos( contentsX(), contentsY() - 10 );
    break;
    case Key_Left:
    setContentsPos( contentsX() - 10, contentsY() );
    break;
    case Key_Right:
    setContentsPos( contentsX() + 10, contentsY() );
    break;
    case Key_PageUp:
    setContentsPos( contentsX(), contentsY() - visibleHeight() );
    break;
    case Key_PageDown:
    setContentsPos( contentsX(), contentsY() + visibleHeight() );
    break;
    case Key_Home:
    setContentsPos( contentsX(), 0 );
    break;
    case Key_End:
    setContentsPos( contentsX(), contentsHeight() - visibleHeight() );
    break;
    case Key_F16: // Copy key on Sun keyboards
    copy();
    break;
#ifndef QT_NO_NETWORKPROTOCOL
    case Key_Return:
    case Key_Enter:
    case Key_Space: {
    if ( !doc->focusIndicator.href.isEmpty() ) {
        QUrl u( doc->context(), doc->focusIndicator.href, TRUE );
        emitLinkClicked( u.toString( FALSE, FALSE ) );
#ifndef QT_NO_CURSOR
        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
    }
    } break;
#endif
    default:
    if ( e->state() & ControlButton ) {
        switch ( e->key() ) {
        case Key_C: case Key_F16: // Copy key on Sun keyboards
        copy();
        break;
        }
    }
    return FALSE;
    }
    return TRUE;
}

QString QTextEdit::context() const
{
    return doc->context();
}

QString QTextEdit::documentTitle() const
{
    return doc->attributes()[ "title" ];
}

void QTextEdit::makeParagVisible( QTextParagraph *p )
{
    setContentsPos( contentsX(), QMIN( p->rect().y(), contentsHeight() - visibleHeight() ) );
}

void QTextEdit::scrollToAnchor( const QString& name )
{
    if ( !isVisible() ) {
    d->scrollToAnchor = name;
    return;
    }
    if ( name.isEmpty() )
    return;
    sync();
    QTextCursor cursor( doc );
    QTextParagraph* last = doc->lastParagraph();
    for (;;) {
    QTextStringChar* c = cursor.paragraph()->at( cursor.index() );
    if( c->isAnchor() ) {
        QString a = c->anchorName();
        if ( a == name ||
         (a.contains( '#' ) && QStringList::split( '#', a ).contains( name ) ) ) {
        setContentsPos( contentsX(), QMIN( cursor.paragraph()->rect().top() + cursor.totalOffsetY(), contentsHeight() - visibleHeight() ) );
        break;
        }
    }
    if ( cursor.paragraph() == last && cursor.atParagEnd()  )
        break;
    cursor.gotoNextLetter();
    }
}

QString QTextEdit::anchorAt( const QPoint& pos )
{
    QTextCursor c( doc );
    placeCursor( pos, &c );
    return c.paragraph()->at( c.index() )->anchorHref();
}

void QTextEdit::documentWidthChanged( int w )
{
    resizeContents( QMAX( visibleWidth(), w), contentsHeight() );
}

void QTextEdit::updateStyles()
{
}

void QTextEdit::setDocument( QTextDocument *dc )
{
    if ( dc == doc )
    return;
    doc = dc;
    delete cursor;
    cursor = new QTextCursor( doc );
    clearUndoRedo();
    undoRedoInfo.doc = doc;
    lastFormatted = 0;
}

#ifndef QT_NO_CLIPBOARD

void QTextEdit::pasteSubType( const QCString& subtype )
{
    QCString st = subtype;
    QString t = QApplication::clipboard()->text(st);
    if ( doc->hasSelection( QTextDocument::Standard ) )
    removeSelectedText();
    if ( !t.isEmpty() ) {
    if ( t.startsWith( "<selstart/>" ) ) {
        t.remove( 0, 11 );
        QTextCursor oldC = *cursor;
        lastFormatted = cursor->paragraph();
        if ( lastFormatted->prev() )
        lastFormatted = lastFormatted->prev();
        doc->setRichTextInternal( t, cursor );

        if ( undoEnabled && !isReadOnly() ) {
        doc->setSelectionStart( QTextDocument::Temp, oldC );
        doc->setSelectionEnd( QTextDocument::Temp, *cursor );

        checkUndoRedoInfo( UndoRedoInfo::Insert );
        if ( !undoRedoInfo.valid() ) {
            undoRedoInfo.id = oldC.paragraph()->paragId();
            undoRedoInfo.index = oldC.index();
            undoRedoInfo.d->text = QString::null;
        }
        int oldLen = undoRedoInfo.d->text.length();
        if ( !doc->preProcessor() ) {
            QString txt = doc->selectedText( QTextDocument::Temp );
            undoRedoInfo.d->text += txt;
            for ( int i = 0; i < (int)txt.length(); ++i ) {
            if ( txt[ i ] != '\n' && oldC.paragraph()->at( oldC.index() )->format() ) {
                oldC.paragraph()->at( oldC.index() )->format()->addRef();
                undoRedoInfo.d->text.
                setFormat( oldLen + i, oldC.paragraph()->at( oldC.index() )->format(), TRUE );
            }
            oldC.gotoNextLetter();
            }
        }
        undoRedoInfo.clear();
        removeSelection( QTextDocument::Temp );
        }

        formatMore();
        setModified();
        emit textChanged();
        repaintChanged();
        ensureCursorVisible();
        return;
    }

#if defined(Q_OS_WIN32)
    // Need to convert CRLF to LF
    int index = t.find( QString::fromLatin1("\r\n"), 0 );
    while ( index != -1 ) {
        t.replace( index, 2, QChar('\n') );
        index = t.find( "\r\n", index );
    }
#elif defined(Q_OS_MAC)
    //need to convert CR to LF
    for( unsigned int index = 0; index < t.length(); index++ )
        if(t[index] == '\r')
        t[index] = '\n';
#endif
    for ( int i=0; (uint) i<t.length(); i++ ) {
        if ( t[ i ] < ' ' && t[ i ] != '\n' && t[ i ] != '\t' )
        t[ i ] = ' ';
    }
    if ( !t.isEmpty() )
        insert( t, FALSE, TRUE, TRUE );
    }
}

#ifndef QT_NO_MIMECLIPBOARD

void QTextEdit::pasteSpecial( const QPoint& pt )
{
    QCString st = pickSpecial( QApplication::clipboard()->data(), TRUE, pt );
    if ( !st.isEmpty() )
    pasteSubType( st );
}
#endif
#ifndef QT_NO_MIME
QCString QTextEdit::pickSpecial( QMimeSource* ms, bool always_ask, const QPoint& pt )
{
    if ( ms )  {
#ifndef QT_NO_POPUPMENU
    QPopupMenu popup( this, "qt_pickspecial_menu" );
    QString fmt;
    int n = 0;
    QDict<void> done;
    for (int i = 0; !( fmt = ms->format( i ) ).isNull(); i++) {
        int semi = fmt.find( ";" );
        if ( semi >= 0 )
        fmt = fmt.left( semi );
        if ( fmt.left( 5 ) == "text/" ) {
        fmt = fmt.mid( 5 );
        if ( !done.find( fmt ) ) {
            done.insert( fmt,(void*)1 );
            popup.insertItem( fmt, i );
            n++;
        }
        }
    }
    if ( n ) {
        int i = n ==1 && !always_ask ? popup.idAt( 0 ) : popup.exec( pt );
        if ( i >= 0 )
        return popup.text(i).latin1();
    }
#else
    QString fmt;
    for (int i = 0; !( fmt = ms->format( i ) ).isNull(); i++) {
        int semi = fmt.find( ";" );
        if ( semi >= 0 )
        fmt = fmt.left( semi );
        if ( fmt.left( 5 ) == "text/" ) {
        fmt = fmt.mid( 5 );
        return fmt.latin1();
        }
    }
#endif
    }
    return QCString();
}
#endif // QT_NO_MIME
#endif // QT_NO_CLIPBOARD

void QTextEdit::setWordWrap( WordWrap mode )
{
    if ( wrapMode == mode )
    return;
    wrapMode = mode;
    switch ( mode ) {
    case NoWrap:
    document()->formatter()->setWrapEnabled( FALSE );
    document()->formatter()->setWrapAtColumn( -1 );
    doc->setWidth( visibleWidth() );
    doc->setMinimumWidth( -1 );
    doc->invalidate();
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
    lastFormatted = doc->firstParagraph();
    interval = 0;
    formatMore();
    break;
    case WidgetWidth:
    document()->formatter()->setWrapEnabled( TRUE );
    document()->formatter()->setWrapAtColumn( -1 );
    doResize();
    break;
    case FixedPixelWidth:
    document()->formatter()->setWrapEnabled( TRUE );
    document()->formatter()->setWrapAtColumn( -1 );
    if ( wrapWidth < 0 )
        wrapWidth = 200;
    setWrapColumnOrWidth( wrapWidth );
    break;
    case FixedColumnWidth:
    if ( wrapWidth < 0 )
        wrapWidth = 80;
    document()->formatter()->setWrapEnabled( TRUE );
    document()->formatter()->setWrapAtColumn( wrapWidth );
    setWrapColumnOrWidth( wrapWidth );
    break;
    }
}

QTextEdit::WordWrap QTextEdit::wordWrap() const
{
    return wrapMode;
}

void QTextEdit::setWrapColumnOrWidth( int value )
{
    wrapWidth = value;
    if ( wrapMode == FixedColumnWidth ) {
    document()->formatter()->setWrapAtColumn( wrapWidth );
    resizeContents( 0, 0 );
    doc->setWidth( visibleWidth() );
    doc->setMinimumWidth( -1 );
    } else if (wrapMode == FixedPixelWidth ) {
    document()->formatter()->setWrapAtColumn( -1 );
    resizeContents( wrapWidth, 0 );
    doc->setWidth( wrapWidth );
    doc->setMinimumWidth( wrapWidth );
    } else {
    return;
    }
    doc->invalidate();
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
    lastFormatted = doc->firstParagraph();
    interval = 0;
    formatMore();
}

int QTextEdit::wrapColumnOrWidth() const
{
    if ( wrapMode == WidgetWidth )
    return visibleWidth();
    return wrapWidth;
}


void QTextEdit::setWrapPolicy( WrapPolicy policy )
{
    if ( wPolicy == policy )
    return;
    wPolicy = policy;
    QTextFormatter *formatter;
    if ( policy == AtWhiteSpace )
    formatter = new QTextFormatterBreakWords;
    else
    formatter = new QTextFormatterBreakInWords;
    formatter->setWrapAtColumn( document()->formatter()->wrapAtColumn() );
    formatter->setWrapEnabled( document()->formatter()->isWrapEnabled( 0 ) );
    document()->setFormatter( formatter );
    doc->invalidate();
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
    lastFormatted = doc->firstParagraph();
    interval = 0;
    formatMore();
}

QTextEdit::WrapPolicy QTextEdit::wrapPolicy() const
{
    return wPolicy;
}

void QTextEdit::clear()
{
    // make clear undoable
    doc->selectAll( QTextDocument::Temp );
    removeSelectedText( QTextDocument::Temp );

    setContentsPos( 0, 0 );
    if ( cursor->isValid() )
    cursor->restoreState();
    doc->clear( TRUE );
    delete cursor;
    cursor = new QTextCursor( doc );
    lastFormatted = 0;
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );

    emit cursorPositionChanged( cursor );
    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
}

int QTextEdit::undoDepth() const
{
    return document()->undoDepth();
}

int QTextEdit::length() const
{
    return document()->length();
}

int QTextEdit::tabStopWidth() const
{
    return document()->tabStopWidth();
}

void QTextEdit::setUndoDepth( int d )
{
    document()->setUndoDepth( d );
}

void QTextEdit::setTabStopWidth( int ts )
{
    document()->setTabStops( ts );
    doc->invalidate();
    lastFormatted = doc->firstParagraph();
    interval = 0;
    formatMore();
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
}

QSize QTextEdit::sizeHint() const
{
    // ### calculate a reasonable one
    return QSize( 100, 100 );
}

void QTextEdit::clearUndoRedo()
{
    undoRedoInfo.clear();
    emit undoAvailable( doc->commands()->isUndoAvailable() );
    emit redoAvailable( doc->commands()->isRedoAvailable() );
}

bool QTextEdit::getFormat( int para, int index, QFont *font, QColor *color, VerticalAlignment *verticalAlignment )
{
    if ( !font || !color )
    return FALSE;
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return FALSE;
    if ( index < 0 || index >= p->length() )
    return FALSE;
    *font = p->at( index )->format()->font();
    *color = p->at( index )->format()->color();
    *verticalAlignment = (VerticalAlignment)p->at( index )->format()->vAlign();
    return TRUE;
}

bool QTextEdit::getParagraphFormat( int para, QFont *font, QColor *color,
                    VerticalAlignment *verticalAlignment, int *alignment,
                    QStyleSheetItem::DisplayMode *displayMode,
                    QStyleSheetItem::ListStyle *listStyle,
                    int *listDepth )
{
    if ( !font || !color || !alignment || !displayMode || !listStyle )
    return FALSE;
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return FALSE;
    *font = p->at(0)->format()->font();
    *color = p->at(0)->format()->color();
    *verticalAlignment = (VerticalAlignment)p->at(0)->format()->vAlign();
    *alignment = p->alignment();
    *displayMode = p->isListItem() ? QStyleSheetItem::DisplayListItem : QStyleSheetItem::DisplayBlock;
    *listStyle = p->listStyle();
    *listDepth = p->listDepth();
    return TRUE;
}



QPopupMenu *QTextEdit::createPopupMenu( const QPoint& pos )
{
#ifndef QT_NO_POPUPMENU
    QPopupMenu *popup = new QPopupMenu( this, "qt_edit_menu" );
    if ( !isReadOnly() ) {
    d->id[ IdUndo ] = popup->insertItem( tr( "&Undo" ) + ACCEL_KEY( Z ) );
    d->id[ IdRedo ] = popup->insertItem( tr( "&Redo" ) + ACCEL_KEY( Y ) );
    popup->insertSeparator();
    }
#ifndef QT_NO_CLIPBOARD
    if ( !isReadOnly() )
    d->id[ IdCut ] = popup->insertItem( tr( "Cu&t" ) + ACCEL_KEY( X ) );
    d->id[ IdCopy ] = popup->insertItem( tr( "&Copy" ) + ACCEL_KEY( C ) );
    if ( !isReadOnly() )
    d->id[ IdPaste ] = popup->insertItem( tr( "&Paste" ) + ACCEL_KEY( V ) );
#endif
    if ( !isReadOnly() ) {
    d->id[ IdClear ] = popup->insertItem( tr( "Clear" ) );
    popup->insertSeparator();
    }
#if defined(Q_WS_X11)
    d->id[ IdSelectAll ] = popup->insertItem( tr( "Select All" ) );
#else
    d->id[ IdSelectAll ] = popup->insertItem( tr( "Select All" ) + ACCEL_KEY( A ) );
#endif
    popup->setItemEnabled( d->id[ IdUndo ], !isReadOnly() && doc->commands()->isUndoAvailable() );
    popup->setItemEnabled( d->id[ IdRedo ], !isReadOnly() && doc->commands()->isRedoAvailable() );
#ifndef QT_NO_CLIPBOARD
    popup->setItemEnabled( d->id[ IdCut ], !isReadOnly() && doc->hasSelection( QTextDocument::Standard, TRUE ) );
    popup->setItemEnabled( d->id[ IdCopy ], doc->hasSelection( QTextDocument::Standard, TRUE ) );
    popup->setItemEnabled( d->id[ IdPaste ], !isReadOnly() && !QApplication::clipboard()->text().isEmpty() );
#endif
    popup->setItemEnabled( d->id[ IdClear ], !isReadOnly() && !text().isEmpty() );
    popup->setItemEnabled( d->id[ IdSelectAll ], (bool)text().length() );
    return popup;
#else
    return 0;
#endif
}

QPopupMenu *QTextEdit::createPopupMenu()
{
    return 0;
}

void QTextEdit::setFont( const QFont &f )
{
    QFont old( QScrollView::font() );
    QScrollView::setFont( f );
    doc->setMinimumWidth( -1 );
    doc->setDefaultFormat( f, doc->formatCollection()->defaultFormat()->color() );
    lastFormatted = doc->firstParagraph();
    formatMore();
    repaintChanged();
}

void QTextEdit::zoomIn( int range )
{
    QFont f( QScrollView::font() );
    f.setPointSize( f.pointSize() + range );
    setFont( f );
}

void QTextEdit::zoomOut( int range )
{
    QFont f( QScrollView::font() );
    f.setPointSize( QMAX( 1, f.pointSize() - range ) );
    setFont( f );
}

void QTextEdit::zoomTo( int size )
{
    QFont f( QScrollView::font() );
    f.setPointSize( size );
    setFont( f );
}

void QTextEdit::sync()
{
    while ( lastFormatted ) {
    lastFormatted->format();
    lastFormatted = lastFormatted->next();
    }
    resizeContents( contentsWidth(), doc->height() );
}

void QTextEdit::setEnabled( bool b )
{
    QScrollView::setEnabled( b );
    if ( !b ) {
    blinkTimer->stop();
    drawCursor( FALSE );
    }
    if ( textFormat() == PlainText ) {
    QTextFormat *f = doc->formatCollection()->defaultFormat();
    f->setColor( colorGroup().text() );
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
    }
    if ( b ) {
    blinkTimer->start( QApplication::cursorFlashTime() / 2 );
    drawCursor( TRUE );
    }
}

void QTextEdit::setSelectionAttributes( int selNum, const QColor &back, bool invertText )
{
    if ( selNum < 1 )
    return;
    if ( selNum > doc->numSelections() )
    doc->addSelection( selNum );
    doc->setSelectionColor( selNum, back );
    doc->setInvertSelectionText( selNum, invertText );
}

void QTextEdit::windowActivationChange( bool )
{
    if ( !isVisible() )
    return;

    if ( palette().active() != palette().inactive() )
    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
}

void QTextEdit::setReadOnly( bool b )
{
    if ( readonly == b )
    return;
    readonly = b;
#ifndef QT_NO_CURSOR
    if ( readonly )
    viewport()->setCursor( arrowCursor );
    else
    viewport()->setCursor( ibeamCursor );
#endif
}

void QTextEdit::scrollToBottom()
{
    sync();
    setContentsPos( contentsX(), contentsHeight() - visibleHeight() );
}

QRect QTextEdit::paragraphRect( int para ) const
{
    QTextEdit *that = (QTextEdit *)this;
    that->sync();
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return QRect( -1, -1, -1, -1 );
    return p->rect();
}

int QTextEdit::paragraphAt( const QPoint &pos ) const
{
    QTextCursor c( doc );
    c.place( pos, doc->firstParagraph() );
    if ( c.paragraph() )
    return c.paragraph()->paragId();
    return -1;
}

int QTextEdit::charAt( const QPoint &pos, int *para ) const
{
    QTextCursor c( doc );
    c.place( pos, doc->firstParagraph() );
    if ( c.paragraph() ) {
    if ( para )
        *para = c.paragraph()->paragId();
    return c.index();
    }
    return -1;
}

void QTextEdit::setParagraphBackgroundColor( int para, const QColor &bg )
{
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return;
    p->setBackgroundColor( bg );
    repaintChanged();
}

void QTextEdit::clearParagraphBackground( int para )
{
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return;
    p->clearBackgroundColor();
    repaintChanged();
}

QColor QTextEdit::paragraphBackgroundColor( int para ) const
{
    QTextParagraph *p = doc->paragAt( para );
    if ( !p )
    return QColor();
    QColor *c = p->backgroundColor();
    if ( c )
    return *c;
    return QColor();
}

void QTextEdit::setUndoRedoEnabled( bool b )
{
    undoEnabled = b;
}

bool QTextEdit::isUndoRedoEnabled() const
{
    return undoEnabled;
}

bool QTextEdit::isUndoAvailable() const
{
    return doc->commands()->isUndoAvailable() || undoRedoInfo.valid();
}

bool QTextEdit::isRedoAvailable() const
{
    return doc->commands()->isRedoAvailable();
}

void QTextEdit::ensureFormatted( QTextParagraph *p )
{
    while ( !p->isValid() ) {
    if ( !lastFormatted )
        return;
    formatMore();
    }
}

void QTextEdit::updateCursor( const QPoint & pos )
{
    if ( isReadOnly() && linksEnabled() ) {
    QTextCursor c = *cursor;
    placeCursor( pos, &c, TRUE );

#ifndef QT_NO_NETWORKPROTOCOL
    if ( c.paragraph() && c.paragraph()->at( c.index() ) &&
         c.paragraph()->at( c.index() )->isAnchor() &&
         !c.paragraph()->at( c.index() )->anchorHref().isEmpty() ) {
        if ( c.index() < c.paragraph()->length() - 1 )
        onLink = c.paragraph()->at( c.index() )->anchorHref();
        else
        onLink = QString::null;

#ifndef QT_NO_CURSOR
        viewport()->setCursor( onLink.isEmpty() ? arrowCursor : pointingHandCursor );
#endif
        QUrl u( doc->context(), onLink, TRUE );
        emitHighlighted( u.toString( FALSE, FALSE ) );
    } else {
#ifndef QT_NO_CURSOR
        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
#endif
        onLink = QString::null;
        emitHighlighted( QString::null );
    }
#endif
    }
}

void QTextEdit::placeCursor( const QPoint &pos, QTextCursor *c )
{
    placeCursor( pos, c, FALSE );
}

---