- Fix: 0001167 - not the best solution, but it works.

1 files changed, 1235 insertions, 1234 deletions

diff --git a/noncore/apps/opie-write/qtextedit.cpp b/noncore/apps/opie-write/qtextedit.cpp
index 73b7b7b..bba8a65 100644
--- a/noncore/apps/opie-write/qtextedit.cpp
+++ b/noncore/apps/opie-write/qtextedit.cpp
@@ -58,12 +58,12 @@ namespace Qt3 {
 class QTextEditPrivate
 {
 public:
     QTextEditPrivate()
-	:preeditStart(-1),preeditLength(-1),ensureCursorVisibleInShowEvent(FALSE)
+    :preeditStart(-1),preeditLength(-1),ensureCursorVisibleInShowEvent(FALSE)
     {
-	for ( int i=0; i<7; i++ )
-	    id[i] = 0;
+    for ( int i=0; i<7; i++ )
+        id[i] = 0;
     }
     int id[ 7 ];
     int preeditStart;
     int preeditLength;
@@ -94,23 +94,23 @@ static bool block_set_alignment = FALSE;
     QTextEdit has three modes of operation:
     \table
     \header \i Mode \i Command \i Notes
     \row \i Plain Text Editor \i setTextFormat(PlainText)
-	 \i Set text with setText(); text() returns plain text. Text
-	 attributes (e.g. colors) can be set, but plain text is always
-	 returned.<sup>1.</sup>
+     \i Set text with setText(); text() returns plain text. Text
+     attributes (e.g. colors) can be set, but plain text is always
+     returned.<sup>1.</sup>
     \row \i Rich Text Editor \i setTextFormat(RichText)
-	 \i Set text with setText(); text() returns rich text. Rich
-	 text editing is fairly limited. You can't set margins or
-	 insert images for example (although you can read and
-	 correctly display files that have margins set and that
-	 include images). This mode is mostly useful for editing small
-	 amounts of rich text. <sup>2.</sup>
+     \i Set text with setText(); text() returns rich text. Rich
+     text editing is fairly limited. You can't set margins or
+     insert images for example (although you can read and
+     correctly display files that have margins set and that
+     include images). This mode is mostly useful for editing small
+     amounts of rich text. <sup>2.</sup>
     \row \i Text Viewer<sup>3.</sup> \i setReadOnly(TRUE)
          \i Set text with setText() or append() (which has no undo
-	 history so is faster and uses less memory); text() returns
-	 plain or rich text depending on the textFormat(). This mode
-	 can correctly display a large subset of HTML tags.
+     history so is faster and uses less memory); text() returns
+     plain or rich text depending on the textFormat(). This mode
+     can correctly display a large subset of HTML tags.
     \endtable
 
     <sup>1.</sup><small>We do \e not recommend using QTextEdit to
     create syntax highlighting editors because the current API is
@@ -206,18 +206,18 @@ static bool block_set_alignment = FALSE;
     for example:
     \code
     QFile file( fileName ); // Read the text from a file
     if ( file.open( IO_ReadOnly ) ) {
-	QTextStream ts( &file );
-	textEdit->setText( ts.read() );
+    QTextStream ts( &file );
+    textEdit->setText( ts.read() );
     }
     \endcode
     \code
     QFile file( fileName ); // Write the text to a file
     if ( file.open( IO_WriteOnly ) ) {
-	QTextStream ts( &file );
-	ts << textEdit->text();
-	textEdit->setModified( FALSE );
+    QTextStream ts( &file );
+    ts << textEdit->text();
+    textEdit->setModified( FALSE );
     }
     \endcode
 
     By default the text edit wraps words at whitespace to fit within
@@ -338,20 +338,20 @@ static bool block_set_alignment = FALSE;
     \row \i \e{Delete} \i Delete the character to the right of the cursor
     \row \i \e{Ctrl+A} \i Move the cursor to the beginning of the line
     \row \i \e{Ctrl+B} \i Move the cursor one character left
     \row \i \e{Ctrl+C} \i Copy the marked text to the clipboard (also
-			  \e{Ctrl+Insert} under Windows)
+              \e{Ctrl+Insert} under Windows)
     \row \i \e{Ctrl+D} \i Delete the character to the right of the cursor
     \row \i \e{Ctrl+E} \i Move the cursor to the end of the line
     \row \i \e{Ctrl+F} \i Move the cursor one character right
     \row \i \e{Ctrl+H} \i Delete the character to the left of the cursor
     \row \i \e{Ctrl+K} \i Delete to end of line
     \row \i \e{Ctrl+N} \i Move the cursor one line down
     \row \i \e{Ctrl+P} \i Move the cursor one line up
     \row \i \e{Ctrl+V} \i Paste the clipboard text into line edit
-			  (also \e{Shift+Insert} under Windows)
+              (also \e{Shift+Insert} under Windows)
     \row \i \e{Ctrl+X} \i Cut the marked text, copy to clipboard
-			  (also \e{Shift+Delete} under Windows)
+              (also \e{Shift+Delete} under Windows)
     \row \i \e{Ctrl+Z} \i Undo the last operation
     \row \i \e{Ctrl+Y} \i Redo the last operation
     \row \i \e{LeftArrow} \i Move the cursor one character left
     \row \i \e{Ctrl+LeftArrow} \i Move the cursor one word left
@@ -367,9 +367,9 @@ static bool block_set_alignment = FALSE;
     \row \i \e{Ctrl+Home} \i Move the cursor to the beginning of the text
     \row \i \e{End} \i Move the cursor to the end of the line
     \row \i \e{Ctrl+End} \i Move the cursor to the end of the text
     \row \i \e{Shift+Wheel} \i Scroll the page horizontally
-			       (the Wheel is the mouse wheel)
+                   (the Wheel is the mouse wheel)
     \row \i \e{Ctrl+Wheel} \i Zoom the text
     \endtable
 
     To select (mark) text hold down the Shift key whilst pressing one
@@ -650,9 +650,9 @@ QTextEdit::QTextEdit( QWidget *parent, const char *name )
 
 */
 
 QTextEdit::QTextEdit( const QString& text, const QString& context,
-		      QWidget *parent, const char *name)
+              QWidget *parent, const char *name)
     : QScrollView( parent, name, WStaticContents | WRepaintNoErase | WResizeNoErase ),
       doc( new QTextDocument( 0 ) ), undoRedoInfo( doc )
 {
     init();
@@ -672,14 +672,15 @@ QTextEdit::~QTextEdit()
 
 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) ) );
+         this, SLOT( documentWidthChanged(int) ) );
 
     mousePressed = FALSE;
     inDoubleClick = FALSE;
     modified = FALSE;
@@ -698,9 +699,9 @@ void QTextEdit::init()
 
     viewport()->setBackgroundMode( PaletteBase );
     viewport()->setAcceptDrops( TRUE );
     resizeContents( 0, doc->lastParagraph() ?
-		    ( doc->lastParagraph()->paragId() + 1 ) * doc->formatCollection()->defaultFormat()->height() : 0 );
+            ( doc->lastParagraph()->paragId() + 1 ) * doc->formatCollection()->defaultFormat()->height() : 0 );
 
     setKeyCompression( TRUE );
     viewport()->setMouseTracking( TRUE );
 #ifndef QT_NO_CURSOR
@@ -709,29 +710,29 @@ void QTextEdit::init()
     cursor = new QTextCursor( doc );
 
     formatTimer = new QTimer( this );
     connect( formatTimer, SIGNAL( timeout() ),
-	     this, SLOT( formatMore() ) );
+         this, SLOT( formatMore() ) );
     lastFormatted = doc->firstParagraph();
 
     scrollTimer = new QTimer( this );
     connect( scrollTimer, SIGNAL( timeout() ),
-	     this, SLOT( autoScrollTimerDone() ) );
+         this, SLOT( autoScrollTimerDone() ) );
 
     interval = 0;
     changeIntervalTimer = new QTimer( this );
     connect( changeIntervalTimer, SIGNAL( timeout() ),
-	     this, SLOT( doChangeInterval() ) );
+         this, SLOT( doChangeInterval() ) );
 
     cursorVisible = TRUE;
     blinkTimer = new QTimer( this );
     connect( blinkTimer, SIGNAL( timeout() ),
-	     this, SLOT( blinkCursor() ) );
+         this, SLOT( blinkCursor() ) );
 
 #ifndef QT_NO_DRAGANDDROP
     dragStartTimer = new QTimer( this );
     connect( dragStartTimer, SIGNAL( timeout() ),
-	     this, SLOT( startDrag() ) );
+         this, SLOT( startDrag() ) );
 #endif
 
 
     formatMore();
@@ -747,32 +748,32 @@ void QTextEdit::init()
 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;
+    drawCur = FALSE;
     QColorGroup g = colorGroup();
     if ( doc->paper() )
-	g.setBrush( QColorGroup::Base, *doc->paper() );
+    g.setBrush( QColorGroup::Base, *doc->paper() );
 
     if ( contentsY() < doc->y() ) {
-	p->fillRect( contentsX(), contentsY(), visibleWidth(), doc->y(),
-		     g.brush( QColorGroup::Base ) );
+    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->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() );
+    resizeContents( contentsWidth(), doc->height() );
 
     if ( contentsHeight() < visibleHeight() && ( !doc->lastParagraph() || doc->lastParagraph()->isValid() ) && drawAll )
-	p->fillRect( 0, contentsHeight(), visibleWidth(),
-		     visibleHeight() - contentsHeight(), g.brush( QColorGroup::Base ) );
+    p->fillRect( 0, contentsHeight(), visibleWidth(),
+             visibleHeight() - contentsHeight(), g.brush( QColorGroup::Base ) );
 }
 
 /*! \reimp */
 
@@ -781,13 +782,13 @@ 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;
-	}
+    int l = int(cy / v) * v;
+    while ( l < cy + ch ) {
+        p->drawLine( cx, l, cx + cw - 1, l );
+        l += v;
+    }
     }
 
 }
 
@@ -801,82 +802,82 @@ 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() ) {
+    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_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:
+        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:
+        case Key_Insert:
+        case Key_Delete:
 #endif
-		ke->accept();
-	    default:
-		break;
-	    }
-	} else {
-	    switch ( ke->key() ) {
+        ke->accept();
+        default:
+        break;
+        }
+    } else {
+        switch ( ke->key() ) {
 #if defined (Q_WS_WIN)
-	    case Key_Insert:
-		ke->accept();
+        case Key_Insert:
+        ke->accept();
 #endif
-	    default:
-		break;
-	    }
-	}
+        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;
-	}
+    if ( d->ensureCursorVisibleInShowEvent ) {
+        sync();
+        ensureCursorVisible();
+        d->ensureCursorVisibleInShowEvent = FALSE;
+    }
+    if ( !d->scrollToAnchor.isEmpty()  ) {
+        scrollToAnchor( d->scrollToAnchor );
+        d->scrollToAnchor = QString::null;
+    }
     }
     return QWidget::event( e );
 }
 
@@ -891,261 +892,261 @@ 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;
+    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;
+    selChanged = doc->removeSelection( i ) || selChanged;
 
     if ( selChanged ) {
-	cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
-	repaintChanged();
+    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;
+    // 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;
+    moveCursor( e->state() & ControlButton ? MovePgUp : MoveUp, e->state() & ShiftButton );
+    break;
     case Key_Down:
-	moveCursor( e->state() & ControlButton ? MovePgDown : MoveDown, e->state() & ShiftButton );
-	break;
+    moveCursor( e->state() & ControlButton ? MovePgDown : MoveDown, e->state() & ShiftButton );
+    break;
     case Key_Home:
-	moveCursor( e->state() & ControlButton ? MoveHome : MoveLineStart, e->state() & ShiftButton );
-	break;
+    moveCursor( e->state() & ControlButton ? MoveHome : MoveLineStart, e->state() & ShiftButton );
+    break;
     case Key_End:
-	moveCursor( e->state() & ControlButton ? MoveEnd : MoveLineEnd, e->state() & ShiftButton );
-	break;
+    moveCursor( e->state() & ControlButton ? MoveEnd : MoveLineEnd, e->state() & ShiftButton );
+    break;
     case Key_Prior:
-	moveCursor( MovePgUp, e->state() & ShiftButton );
-	break;
+    moveCursor( MovePgUp, e->state() & ShiftButton );
+    break;
     case Key_Next:
-	moveCursor( MovePgDown, e->state() & ShiftButton );
-	break;
+    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 {
+    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 );
+        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
-	    clearUndoRedoInfo = FALSE;
-	    doKeyboardAction( ActionReturn );
-	    emit returnPressed();
-	}
-	break;
+        clearUndoRedoInfo = FALSE;
+        doKeyboardAction( ActionReturn );
+        emit returnPressed();
+    }
+    break;
     case Key_Delete:
 #if defined (Q_WS_WIN)
-	if ( e->state() & ShiftButton ) {
-	    cut();
-	    break;
-	} else
+    if ( e->state() & ShiftButton ) {
+        cut();
+        break;
+    } else
 #endif
         if ( doc->hasSelection( QTextDocument::Standard, TRUE ) ) {
-	    removeSelectedText();
-	    break;
-	}
-	doKeyboardAction( ActionDelete );
-	clearUndoRedoInfo = FALSE;
+        removeSelectedText();
+        break;
+    }
+    doKeyboardAction( ActionDelete );
+    clearUndoRedoInfo = FALSE;
 
-	break;
+    break;
     case Key_Insert:
-	if ( e->state() & ShiftButton )
-	    paste();
+    if ( e->state() & ShiftButton )
+        paste();
 #if defined (Q_WS_WIN)
-	else if ( e->state() & ControlButton )
-	    copy();
+    else if ( e->state() & ControlButton )
+        copy();
 #endif
-	break;
+    break;
     case Key_Backspace:
-	if ( doc->hasSelection( QTextDocument::Standard, TRUE ) ) {
-	    removeSelectedText();
-	    break;
-	}
+    if ( doc->hasSelection( QTextDocument::Standard, TRUE ) ) {
+        removeSelectedText();
+        break;
+    }
 
-	doKeyboardAction( ActionBackspace );
-	clearUndoRedoInfo = FALSE;
+    doKeyboardAction( ActionBackspace );
+    clearUndoRedoInfo = FALSE;
 
-	break;
+    break;
     case Key_F16: // Copy key on Sun keyboards
-	copy();
-	break;
+    copy();
+    break;
     case Key_F18:  // Paste key on Sun keyboards
-	paste();
-	break;
+    paste();
+    break;
     case Key_F20:  // Cut key on Sun keyboards
-	cut();
-	break;
+    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 ( 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 );
+            moveCursor( MoveLineStart, e->state() & ShiftButton );
 #else
-		    selectAll( TRUE );
+            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;
+            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;
+        case Key_Insert:
+            copy();
+            break;
+        case Key_Delete:
+            del();
+            break;
 #endif
-		default:
-		    unknown = FALSE;
-		    break;
-		}
-	    } else {
-		unknown = TRUE;
-	    }
+        default:
+            unknown = FALSE;
+            break;
+        }
+        } else {
+        unknown = TRUE;
+        }
         }
     }
 
     emit cursorPositionChanged( cursor );
     emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
     if ( clearUndoRedoInfo )
-	clearUndoRedo();
+    clearUndoRedo();
     changeIntervalTimer->start( 100, TRUE );
     if ( unknown )
-	e->ignore();
+    e->ignore();
 }
 
 /*!
   Executes keyboard action \a action. This is normally called by
@@ -1154,108 +1155,108 @@ void QTextEdit::keyPressEvent( QKeyEvent *e )
 
 void QTextEdit::doKeyboardAction( KeyboardAction action )
 {
     if ( isReadOnly() )
-	return;
+    return;
 
     if ( cursor->nestedDepth() != 0 ) // #### for 3.0, disable editing of tables as this is not advanced enough
-	return;
+    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;
+    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;
+    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;
+    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;
+        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();
+    updateCurrentFormat();
     setModified();
     emit textChanged();
 }
 
@@ -1265,34 +1266,34 @@ void QTextEdit::readFormats( QTextCursor &c1, QTextCursor &c2, QTextString &text
     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 );
-	}
+    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 );
-	}
+    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 );
+    }
     }
 }
 
 /*! Removes the selection \a selNum (by default 0). This does not
@@ -1316,58 +1317,58 @@ void QTextEdit::removeSelection( int selNum )
 
 void QTextEdit::removeSelectedText( int selNum )
 {
     if ( isReadOnly() )
-	return;
+    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;
+    return;
 
     for ( int i = 0; i < (int)doc->numSelections(); ++i ) {
-	if ( i == selNum )
-	    continue;
-	doc->removeSelection( 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;
+    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();
+    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 );
+    // 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 );
+    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
-	updateMicroFocusHint();
+    updateMicroFocusHint();
     } else {
-	delete cursor;
-	cursor = new QTextCursor( doc );
-	drawCursor( TRUE );
-	viewport()->repaint( TRUE );
+    delete cursor;
+    cursor = new QTextCursor( doc );
+    drawCursor( TRUE );
+    viewport()->repaint( TRUE );
     }
     setModified();
     emit textChanged();
     emit selectionChanged();
@@ -1382,39 +1383,39 @@ void QTextEdit::removeSelectedText( int selNum )
 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 ) );
+    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 {
-	bool redraw = doc->removeSelection( QTextDocument::Standard );
-	moveCursor( action );
-	if ( !redraw ) {
-	    ensureCursorVisible();
-	    drawCursor( TRUE );
-	} else {
-	    cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
-	    repaintChanged();
-	    ensureCursorVisible();
-	    drawCursor( TRUE );
+        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 );
+        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
-	}
-	if ( redraw ) {
-	    emit copyAvailable( doc->hasSelection( QTextDocument::Standard ) );
-	    emit selectionChanged();
-	}
+    }
+    if ( redraw ) {
+        emit copyAvailable( doc->hasSelection( QTextDocument::Standard ) );
+        emit selectionChanged();
+    }
     }
 
     drawCursor( TRUE );
     updateCurrentFormat();
@@ -1427,44 +1428,44 @@ void QTextEdit::moveCursor( CursorAction action, bool select )
 void QTextEdit::moveCursor( CursorAction action )
 {
     switch ( action ) {
     case MoveBackward:
-	cursor->gotoPreviousLetter();
-	break;
+    cursor->gotoPreviousLetter();
+    break;
     case MoveWordBackward:
-	cursor->gotoPreviousWord();
-	break;
+    cursor->gotoPreviousWord();
+    break;
     case MoveForward:
-	cursor->gotoNextLetter();
-	break;
+    cursor->gotoNextLetter();
+    break;
     case MoveWordForward:
-	cursor->gotoNextWord();
-	break;
+    cursor->gotoNextWord();
+    break;
     case MoveUp:
-	cursor->gotoUp();
-	break;
+    cursor->gotoUp();
+    break;
     case MovePgUp:
-	cursor->gotoPageUp( visibleHeight() );
-	break;
+    cursor->gotoPageUp( visibleHeight() );
+    break;
     case MoveDown:
-	cursor->gotoDown();
-	break;
+    cursor->gotoDown();
+    break;
     case MovePgDown:
-	cursor->gotoPageDown( visibleHeight() );
-	break;
+    cursor->gotoPageDown( visibleHeight() );
+    break;
     case MoveLineStart:
-	cursor->gotoLineStart();
-	break;
+    cursor->gotoLineStart();
+    break;
     case MoveHome:
-	cursor->gotoHome();
-	break;
+    cursor->gotoHome();
+    break;
     case MoveLineEnd:
-	cursor->gotoLineEnd();
-	break;
+    cursor->gotoLineEnd();
+    break;
     case MoveEnd:
-	ensureFormatted( doc->lastParagraph() );
-	cursor->gotoEnd();
-	break;
+    ensureFormatted( doc->lastParagraph() );
+    cursor->gotoEnd();
+    break;
     }
     updateMicroFocusHint();
     updateCurrentFormat();
 }
@@ -1474,22 +1475,22 @@ void QTextEdit::moveCursor( CursorAction action )
 void QTextEdit::resizeEvent( QResizeEvent *e )
 {
     QScrollView::resizeEvent( e );
     if ( doc->visibleWidth() == 0 )
-	doResize();
+    doResize();
 }
 
 /*! \reimp */
 
 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();
+    bool stayAtBottom = e->oldSize().height() != e->size().height() &&
+           contentsY() > 0 && contentsY() >= doc->height() - e->oldSize().height();
+    doResize();
+    if ( stayAtBottom )
+        scrollToBottom();
     }
 }
 
 /*!
@@ -1501,10 +1502,10 @@ void QTextEdit::viewportResizeEvent( QResizeEvent *e )
 
 void QTextEdit::ensureCursorVisible()
 {
     if ( !isVisible() ) {
-	d->ensureCursorVisibleInShowEvent = TRUE;
-	return;
+    d->ensureCursorVisibleInShowEvent = TRUE;
+    return;
     }
     lastFormatted = cursor->paragraph();
     formatMore();
     QTextStringChar *chr = cursor->paragraph()->at( cursor->index() );
@@ -1522,43 +1523,43 @@ void QTextEdit::ensureCursorVisible()
 */
 void QTextEdit::drawCursor( bool visible )
 {
     if ( !isUpdatesEnabled() ||
-	 !viewport()->isUpdatesEnabled() ||
-	 !cursor->paragraph() ||
-	 !cursor->paragraph()->isValid() ||
-	 !selectedText().isEmpty() ||
-	 ( visible && !hasFocus() && !viewport()->hasFocus() && !inDnD ) ||
-	 isReadOnly() )
-	return;
+     !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() );
+    cg.setBrush( QColorGroup::Base, *cursor->paragraph()->background() );
     else if ( doc->paper() )
-	cg.setBrush( QColorGroup::Base, *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 );
+    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 );
+    doc->drawParagraph( &p, cursor->paragraph(), r.x() - cursor->totalOffsetX(),
+            r.y() - cursor->totalOffsetY(), r.width(), r.height(),
+            pix, cg, visible, cursor );
     }
     cursorVisible = visible;
 }
 
@@ -1576,15 +1577,15 @@ enum {
 #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;
-	}
+    if ( e->state() & ControlButton ) {
+        if ( e->delta() > 0 )
+        zoomOut();
+        else if ( e->delta() < 0 )
+        zoomIn();
+        return;
+    }
     }
     QScrollView::contentsWheelEvent( e );
 }
 #endif
@@ -1600,104 +1601,104 @@ void QTextEdit::contentsMousePressEvent( QMouseEvent *e )
     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();
-	    }
-	}
+    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;
-	}
+    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();
+    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 );
+        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
-	}
+    }
     } else if ( e->button() == MidButton ) {
-	bool redraw = doc->removeSelection( QTextDocument::Standard );
-	if ( !redraw ) {
-	    drawCursor( TRUE );
-	} else {
-	    repaintChanged();
+    bool redraw = doc->removeSelection( QTextDocument::Standard );
+    if ( !redraw ) {
+        drawCursor( TRUE );
+    } else {
+        repaintChanged();
 #ifndef QT_NO_CURSOR
-	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
-	}
+    }
     }
 
     if ( *cursor != oldCursor )
-	updateCurrentFormat();
+    updateCurrentFormat();
 }
 
 /*! \reimp */
 
 void QTextEdit::contentsMouseMoveEvent( QMouseEvent *e )
 {
     if ( mousePressed ) {
 #ifndef QT_NO_DRAGANDDROP
-	if ( mightStartDrag ) {
-	    dragStartTimer->stop();
-	    if ( ( e->pos() - dragStartPos ).manhattanLength() > QApplication::startDragDistance() )
-		startDrag();
+    if ( mightStartDrag ) {
+        dragStartTimer->stop();
+        if ( ( e->pos() - dragStartPos ).manhattanLength() > QApplication::startDragDistance() )
+        startDrag();
 #ifndef QT_NO_CURSOR
-	    if ( !isReadOnly() )
-		viewport()->setCursor( ibeamCursor );
+        if ( !isReadOnly() )
+        viewport()->setCursor( ibeamCursor );
 #endif
-	    return;
-	}
+        return;
+    }
 #endif
-	mousePos = e->pos();
-	handleMouseMove( mousePos );
-	oldMousePos = mousePos;
+    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 );
+    if ( doc->hasSelection( QTextDocument::Standard ) && doc->inSelection( QTextDocument::Standard, e->pos() ) )
+        viewport()->setCursor( arrowCursor );
+    else
+        viewport()->setCursor( ibeamCursor );
     }
 #endif
     updateCursor( e->pos() );
 }
@@ -1707,40 +1708,40 @@ void QTextEdit::contentsMouseMoveEvent( QMouseEvent *e )
 void QTextEdit::contentsMouseReleaseEvent( QMouseEvent * e )
 {
     QTextCursor oldCursor = *cursor;
     if ( scrollTimer->isActive() )
-	scrollTimer->stop();
+    scrollTimer->stop();
 #ifndef QT_NO_DRAGANDDROP
     if ( dragStartTimer->isActive() )
-	dragStartTimer->stop();
+    dragStartTimer->stop();
     if ( mightStartDrag ) {
-	selectAll( FALSE );
-	mousePressed = FALSE;
+    selectAll( FALSE );
+    mousePressed = FALSE;
     }
 #endif
     if ( mousePressed ) {
-	mousePressed = FALSE;
+    mousePressed = FALSE;
     }
     emit cursorPositionChanged( cursor );
     emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
     if ( oldCursor != *cursor )
-	updateCurrentFormat();
+    updateCurrentFormat();
     inDoubleClick = FALSE;
 
 #ifndef QT_NO_NETWORKPROTOCOL
     if ( !onLink.isEmpty() && onLink == pressedLink && linksEnabled() ) {
-	QUrl u( doc->context(), onLink, TRUE );
-	emitLinkClicked( u.toString( FALSE, FALSE ) );
+    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() );
+    // 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 );
+    doc->removeSelection( QTextDocument::Standard );
 
     emit copyAvailable( doc->hasSelection( QTextDocument::Standard ) );
     emit selectionChanged();
 }
@@ -1751,11 +1752,11 @@ void QTextEdit::contentsMouseDoubleClickEvent( QMouseEvent * )
 {
     QTextCursor c1 = *cursor;
     QTextCursor c2 = *cursor;
     if ( cursor->index() > 0 && !cursor->paragraph()->at( cursor->index()-1 )->c.isSpace() )
-	c1.gotoPreviousWord();
+    c1.gotoPreviousWord();
     if ( !cursor->paragraph()->at( cursor->index() )->c.isSpace() && !cursor->atParagEnd() )
-	c2.gotoNextWord();
+    c2.gotoNextWord();
 
     doc->setSelectionStart( QTextDocument::Standard, c1 );
     doc->setSelectionEnd( QTextDocument::Standard, c2 );
 
@@ -1773,10 +1774,10 @@ void QTextEdit::contentsMouseDoubleClickEvent( QMouseEvent * )
 
 void QTextEdit::contentsDragEnterEvent( QDragEnterEvent *e )
 {
     if ( isReadOnly() || !QTextDrag::canDecode( e ) ) {
-	e->ignore();
-	return;
+    e->ignore();
+    return;
     }
     e->acceptAction();
     inDnD = TRUE;
 }
@@ -1785,10 +1786,10 @@ void QTextEdit::contentsDragEnterEvent( QDragEnterEvent *e )
 
 void QTextEdit::contentsDragMoveEvent( QDragMoveEvent *e )
 {
     if ( isReadOnly() || !QTextDrag::canDecode( e ) ) {
-	e->ignore();
-	return;
+    e->ignore();
+    return;
     }
     drawCursor( FALSE );
     placeCursor( e->pos(),  cursor );
     drawCursor( TRUE );
@@ -1806,149 +1807,149 @@ void QTextEdit::contentsDragLeaveEvent( QDragLeaveEvent * )
 
 void QTextEdit::contentsDropEvent( QDropEvent *e )
 {
     if ( isReadOnly() )
-	return;
+    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 );
+    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 );
+        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();
-	}
+    }
+    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() )  ) );
+    handleMouseMove(  viewportToContents( viewport()->mapFromGlobal( QCursor::pos() )  ) );
 }
 
 void QTextEdit::handleMouseMove( const QPoint& pos )
 {
     if ( !mousePressed )
-	return;
+    return;
 
     if ( !scrollTimer->isActive() && pos.y() < contentsY() || pos.y() > contentsY() + visibleHeight() )
-	scrollTimer->start( 100, FALSE );
+    scrollTimer->start( 100, FALSE );
     else if ( scrollTimer->isActive() && pos.y() >= contentsY() && pos.y() <= contentsY() + visibleHeight() )
-	scrollTimer->stop();
+    scrollTimer->stop();
 
     drawCursor( FALSE );
     QTextCursor oldCursor = *cursor;
 
     placeCursor( pos );
 
     if ( inDoubleClick ) {
-	QTextCursor cl = *cursor;
-	cl.gotoPreviousWord();
-	QTextCursor cr = *cursor;
-	cr.gotoNextWord();
+    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() );
+    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 ( 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;
+    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;
+    redraw = doc->setSelectionEnd( QTextDocument::Standard, *cursor ) || redraw;
     }
 
     if ( !redraw ) {
-	drawCursor( TRUE );
+    drawCursor( TRUE );
     } else {
-	repaintChanged();
-	drawCursor( TRUE );
+    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() );
+    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;
+    currentAlignment = cursor->paragraph()->alignment();
+    block_set_alignment = TRUE;
+    emit currentAlignmentChanged( currentAlignment );
+    block_set_alignment = FALSE;
     }
 }
 
 /*!
@@ -1962,9 +1963,9 @@ void QTextEdit::handleMouseMove( const QPoint& pos )
 
 void QTextEdit::placeCursor( const QPoint &pos, QTextCursor *c, bool link )
 {
     if ( !c )
-	c = cursor;
+    c = cursor;
 
     c->restoreState();
     QTextParagraph *s = doc->firstParagraph();
     c->place( pos, s, link );
@@ -1975,65 +1976,65 @@ void QTextEdit::placeCursor( const QPoint &pos, QTextCursor *c, bool link )
 void QTextEdit::updateMicroFocusHint()
 {
     QTextCursor c( *cursor );
     if ( d->preeditStart != -1 )
-	c.setIndex( d->preeditStart );
+    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 );
-	}
+    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;
+    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;
+    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 ) );
+    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() );
+    resizeContents( contentsWidth(), QMAX( doc->height(), lastBottom ) );
+    if ( contentsHeight() < visibleHeight() )
+        updateContents( 0, contentsHeight(), visibleWidth(),
+                visibleHeight() - contentsHeight() );
     }
 
     if ( lastFormatted )
-	formatTimer->start( interval, TRUE );
+    formatTimer->start( interval, TRUE );
     else
-	interval = QMAX( 0, interval );
+    interval = QMAX( 0, interval );
 }
 
 void QTextEdit::doResize()
 {
     if ( wrapMode == FixedPixelWidth )
-	return;
+    return;
     doc->setMinimumWidth( -1 );
     resizeContents( 0, 0 );
     doc->setWidth( visibleWidth() );
     doc->invalidate();
@@ -2054,16 +2055,16 @@ void QTextEdit::doChangeInterval()
 
 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 );
-	}
+    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 );
 }
@@ -2082,61 +2083,61 @@ bool QTextEdit::eventFilter( QObject *o, QEvent *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;
+    return;
     QString txt( text );
     drawCursor( FALSE );
     if ( !isReadOnly() && doc->hasSelection( QTextDocument::Standard ) && removeSelected )
-	removeSelectedText();
+    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();
+    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();
+            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 );
+    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();
+    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();
-	    }
-	}
+    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();
+    doc->setSelectionStart( QTextDocument::Standard, oldCursor );
+    doc->setSelectionEnd( QTextDocument::Standard, *cursor );
+    repaintChanged();
     }
     updateMicroFocusHint();
     setModified();
     emit textChanged();
@@ -2148,9 +2149,9 @@ void QTextEdit::insertAt( const QString &text, int para, int index )
 {
     removeSelection( QTextDocument::Standard );
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return;
+    return;
     QTextCursor tmp = *cursor;
     cursor->setParagraph( p );
     cursor->setIndex( index );
     insert( text, FALSE, TRUE, FALSE );
@@ -2165,16 +2166,16 @@ void QTextEdit::insertAt( const QString &text, int para, int index )
 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();
+    QTextCursor tmp( doc );
+    tmp.setParagraph( p );
+    tmp.setIndex( 0 );
+    tmp.insert( text, TRUE );
+    tmp.splitAndInsertEmptyParagraph();
+    repaintChanged();
     } else {
-	append( text );
+    append( text );
     }
 }
 
 /*! Removes the paragraph \a para */
@@ -2182,43 +2183,43 @@ void QTextEdit::insertParagraph( const QString &text, int para )
 void QTextEdit::removeParagraph( int para )
 {
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return;
+    return;
     for ( int i = 0; i < doc->numSelections(); ++i )
-	doc->removeSelection( i );
+    doc->removeSelection( i );
 
     if ( p == doc->firstParagraph() && p == doc->lastParagraph() ) {
-	p->remove( 0, p->length() - 1 );
-	repaintChanged();
-	return;
+    p->remove( 0, p->length() - 1 );
+    repaintChanged();
+    return;
     }
     drawCursor( FALSE );
     bool resetCursor = cursor->paragraph() == p;
     if ( p->prev() )
-	p->prev()->setNext( p->next() );
+    p->prev()->setNext( p->next() );
     else
-	doc->setFirstParagraph( p->next() );
+    doc->setFirstParagraph( p->next() );
     if ( p->next() )
-	p->next()->setPrev( p->prev() );
+    p->next()->setPrev( p->prev() );
     else
-	doc->setLastParagraph( p->prev() );
+    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();
+    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 );
+    cursor->setParagraph( doc->firstParagraph() );
+    cursor->setIndex( 0 );
     }
     repaintChanged();
     drawCursor( TRUE );
 }
@@ -2238,12 +2239,12 @@ void QTextEdit::undo()
     // 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;
+    return;
 
     for ( int i = 0; i < (int)doc->numSelections(); ++i )
-	doc->removeSelection( i );
+    doc->removeSelection( i );
 
 #ifndef QT_NO_CURSOR
     viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
@@ -2251,10 +2252,10 @@ void QTextEdit::undo()
     clearUndoRedo();
     drawCursor( FALSE );
     QTextCursor *c = doc->undo( cursor );
     if ( !c ) {
-	drawCursor( TRUE );
-	return;
+    drawCursor( TRUE );
+    return;
     }
     lastFormatted = 0;
     ensureCursorVisible();
     repaintChanged();
@@ -2275,12 +2276,12 @@ void QTextEdit::undo()
 
 void QTextEdit::redo()
 {
     if ( isReadOnly() || !doc->commands()->isRedoAvailable() || !undoEnabled )
-	return;
+    return;
 
     for ( int i = 0; i < (int)doc->numSelections(); ++i )
-	doc->removeSelection( i );
+    doc->removeSelection( i );
 
 #ifndef QT_NO_CURSOR
     viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
@@ -2288,10 +2289,10 @@ void QTextEdit::redo()
     clearUndoRedo();
     drawCursor( FALSE );
     QTextCursor *c = doc->redo( cursor );
     if ( !c ) {
-	drawCursor( TRUE );
-	return;
+    drawCursor( TRUE );
+    return;
     }
     lastFormatted = 0;
     ensureCursorVisible();
     repaintChanged();
@@ -2314,18 +2315,18 @@ void QTextEdit::redo()
 void QTextEdit::paste()
 {
 #ifndef QT_NO_CLIPBOARD
     if ( isReadOnly() )
-	return;
+    return;
     pasteSubType( "plain" );
     updateMicroFocusHint();
 #endif
 }
 
 void QTextEdit::checkUndoRedoInfo( UndoRedoInfo::Type t )
 {
     if ( undoRedoInfo.valid() && t != undoRedoInfo.type ) {
-	clearUndoRedo();
+    clearUndoRedo();
     }
     undoRedoInfo.type = t;
 }
 
@@ -2337,9 +2338,9 @@ void QTextEdit::checkUndoRedoInfo( UndoRedoInfo::Type t )
 
 void QTextEdit::repaintChanged()
 {
     if ( !isUpdatesEnabled() || !viewport()->isUpdatesEnabled() )
-	return;
+    return;
     QPainter p( viewport() );
     p.translate( -contentsX(), -contentsY() );
     paintDocument( FALSE, &p, contentsX(), contentsY(), visibleWidth(), visibleHeight() );
 }
@@ -2355,15 +2356,15 @@ void QTextEdit::repaintChanged()
 
 void QTextEdit::cut()
 {
     if ( isReadOnly() )
-	return;
+    return;
 
     QString t;
     if ( doc->hasSelection( QTextDocument::Standard ) &&
-	 !( t = doc->selectedText( QTextDocument::Standard, qt_enable_richtext_copy ) ).isEmpty() ) {
-	QApplication::clipboard()->setText( t );
-	removeSelectedText();
+     !( t = doc->selectedText( QTextDocument::Standard, qt_enable_richtext_copy ) ).isEmpty() ) {
+    QApplication::clipboard()->setText( t );
+    removeSelectedText();
     }
     updateMicroFocusHint();
 }
 
@@ -2375,10 +2376,10 @@ void QTextEdit::cut()
 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 );
+     !t.isEmpty() && t.simplifyWhiteSpace() != "<selstart/>" )
+    QApplication::clipboard()->setText( t );
 }
 
 /*!
   Re-indents the current paragraph.
@@ -2386,15 +2387,15 @@ void QTextEdit::copy()
 
 void QTextEdit::indent()
 {
     if ( isReadOnly() )
-	return;
+    return;
 
     drawCursor( FALSE );
     if ( !doc->hasSelection( QTextDocument::Standard ) )
-	cursor->indent();
+    cursor->indent();
     else
-	doc->indentSelection( QTextDocument::Standard );
+    doc->indentSelection( QTextDocument::Standard );
     repaintChanged();
     drawCursor( TRUE );
     setModified();
     emit textChanged();
@@ -2408,15 +2409,15 @@ void QTextEdit::indent()
 
 bool QTextEdit::focusNextPrevChild( bool n )
 {
     if ( !isReadOnly() || !linksEnabled() )
-	return FALSE;
+    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 );
+    //##### this does not work with tables. The focusIndicator
+    //should really be a QTextCursor. Fix 3.1
+    makeParagVisible( doc->focusIndicator.parag );
     return b;
 }
 
 /*!
@@ -2428,49 +2429,49 @@ bool QTextEdit::focusNextPrevChild( bool n )
 
 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();
+    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();
-	    }
-	}
+    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();
+        }
+    }
     }
 }
 
 /*! \reimp */
@@ -2478,11 +2479,11 @@ void QTextEdit::setFormat( QTextFormat *f, int flags )
 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() );
+    QTextFormat *f = doc->formatCollection()->defaultFormat();
+    f->setColor( colorGroup().text() );
+    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
     }
 }
 
 /*! \internal
@@ -2500,18 +2501,18 @@ void QTextEdit::setPalette( const QPalette &p )
 
 void QTextEdit::setParagType( QStyleSheetItem::DisplayMode dm, QStyleSheetItem::ListStyle listStyle )
 {
     if ( isReadOnly() )
-	return;
+    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
+    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;
@@ -2519,18 +2520,18 @@ void QTextEdit::setParagType( QStyleSheetItem::DisplayMode dm, QStyleSheetItem::
     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();
+    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();
@@ -2549,18 +2550,18 @@ void QTextEdit::setParagType( QStyleSheetItem::DisplayMode dm, QStyleSheetItem::
 
 void QTextEdit::setAlignment( int a )
 {
     if ( isReadOnly() || block_set_alignment )
-	return;
+    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
+    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;
@@ -2568,19 +2569,19 @@ void QTextEdit::setAlignment( int a )
     undoRedoInfo.eid = end->paragId();
     undoRedoInfo.styleInformation = QTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
 
     while ( start != end->next() ) {
-	start->setAlignment( a );
-	start = start->next();
+    start->setAlignment( a );
+    start = start->next();
     }
 
     clearUndoRedo();
     repaintChanged();
     formatMore();
     drawCursor( TRUE );
     if ( currentAlignment != a ) {
-	currentAlignment = a;
-	emit currentAlignmentChanged( currentAlignment );
+    currentAlignment = a;
+    emit currentAlignmentChanged( currentAlignment );
     }
     setModified();
     emit textChanged();
 }
@@ -2588,28 +2589,28 @@ void QTextEdit::setAlignment( int a )
 void QTextEdit::updateCurrentFormat()
 {
     int i = cursor->index();
     if ( i > 0 )
-	--i;
+    --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() );
+     ( !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;
+    currentAlignment = cursor->paragraph()->alignment();
+    block_set_alignment = TRUE;
+    emit currentAlignmentChanged( currentAlignment );
+    block_set_alignment = FALSE;
     }
 }
 
 /*!
@@ -2727,9 +2728,9 @@ void QTextEdit::setFontInternal( const QFont &f_ )
 
 QString QTextEdit::text() const
 {
     if ( isReadOnly() )
-	return doc->originalText();
+    return doc->originalText();
     return doc->text();
 }
 
 /*!
@@ -2767,10 +2768,10 @@ QString QTextEdit::text( int para ) const
 
 void QTextEdit::setText( const QString &text, const QString &context )
 {
     if ( !isModified() && isReadOnly() &&
-	 this->context() == context && this->text() == text )
-	return;
+     this->context() == context && this->text() == text )
+    return;
 
     emit undoAvailable( FALSE );
     emit redoAvailable( FALSE );
     undoRedoInfo.clear();
@@ -2780,23 +2781,23 @@ void QTextEdit::setText( const QString &text, const QString &context )
     cursor->restoreState();
     doc->setText( text, context );
 
     if ( wrapMode == FixedPixelWidth ) {
-	resizeContents( wrapWidth, 0 );
-	doc->setWidth( wrapWidth );
-	doc->setMinimumWidth( wrapWidth );
+    resizeContents( wrapWidth, 0 );
+    doc->setWidth( wrapWidth );
+    doc->setMinimumWidth( wrapWidth );
     } else {
-	doc->setMinimumWidth( -1 );
-	resizeContents( 0, 0 );
+    doc->setMinimumWidth( -1 );
+    resizeContents( 0, 0 );
     }
 
     lastFormatted = doc->firstParagraph();
     delete cursor;
     cursor = new QTextCursor( doc );
     updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
 
     if ( isModified() )
-	setModified( FALSE );
+    setModified( FALSE );
     emit textChanged();
     formatMore();
     updateCurrentFormat();
     d->scrollToAnchor = QString::null;
@@ -2859,46 +2860,46 @@ void QTextEdit::setText( const QString &text, const QString &context )
     and \e *\a para are undefined.
 */
 
 bool QTextEdit::find( const QString &expr, bool cs, bool wo, bool forward,
-		      int *para, int *index )
+              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();
+    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();
+    // 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();
+    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;
+    return;
     bool cv = cursorVisible;
     blinkCursorVisible = !blinkCursorVisible;
     drawCursor( blinkCursorVisible );
     cursorVisible = cv;
@@ -2913,12 +2914,12 @@ void QTextEdit::blinkCursor()
 void QTextEdit::setCursorPosition( int para, int index )
 {
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return;
+    return;
 
     if ( index > p->length() - 1 )
-	index = p->length() - 1;
+    index = p->length() - 1;
 
     drawCursor( FALSE );
     cursor->setParagraph( p );
     cursor->setIndex( index );
@@ -2939,9 +2940,9 @@ void QTextEdit::setCursorPosition( int para, int index )
 
 void QTextEdit::getCursorPosition( int *para, int *index ) const
 {
     if ( !para || !index )
-	return;
+    return;
     *para = cursor->paragraph()->paragId();
     *index = cursor->index();
 }
 
@@ -2960,27 +2961,27 @@ void QTextEdit::getCursorPosition( int *para, int *index ) const
   \sa getSelection() selectedText
 */
 
 void QTextEdit::setSelection( int paraFrom, int indexFrom,
-			      int paraTo, int indexTo, int selNum )
+                  int paraTo, int indexTo, int selNum )
 {
     if ( doc->hasSelection( selNum ) ) {
-	doc->removeSelection( selNum );
-	repaintChanged();
+    doc->removeSelection( selNum );
+    repaintChanged();
     }
     if ( selNum > doc->numSelections() - 1 )
-	doc->addSelection( selNum );
+    doc->addSelection( selNum );
     QTextParagraph *p1 = doc->paragAt( paraFrom );
     if ( !p1 )
-	return;
+    return;
     QTextParagraph *p2 = doc->paragAt( paraTo );
     if ( !p2 )
-	return;
+    return;
 
     if ( indexFrom > p1->length() - 1 )
-	indexFrom = p1->length() - 1;
+    indexFrom = p1->length() - 1;
     if ( indexTo > p2->length() - 1 )
-	indexTo = p2->length() - 1;
+    indexTo = p2->length() - 1;
 
     drawCursor( FALSE );
     QTextCursor c = *cursor;
     QTextCursor oldCursor = *cursor;
@@ -2992,9 +2993,9 @@ void QTextEdit::setSelection( int paraFrom, int indexFrom,
     doc->setSelectionEnd( selNum, *cursor );
     repaintChanged();
     ensureCursorVisible();
     if ( selNum != QTextDocument::Standard )
-	*cursor = oldCursor;
+    *cursor = oldCursor;
     drawCursor( TRUE );
 }
 
 /*!
@@ -3017,18 +3018,18 @@ void QTextEdit::setSelection( int paraFrom, int indexFrom,
     \sa setSelection() selectedText
 */
 
 void QTextEdit::getSelection( int *paraFrom, int *indexFrom,
-			      int *paraTo, int *indexTo, int selNum ) const
+                  int *paraTo, int *indexTo, int selNum ) const
 {
     if ( !paraFrom || !paraTo || !indexFrom || !indexTo )
-	return;
+    return;
     if ( !doc->hasSelection( selNum ) ) {
-	*paraFrom = -1;
-	*indexFrom = -1;
-	*paraTo = -1;
-	*indexTo = -1;
-	return;
+    *paraFrom = -1;
+    *indexFrom = -1;
+    *paraTo = -1;
+    *indexTo = -1;
+    return;
     }
 
     doc->selectionStart( selNum, *paraFrom, *indexFrom );
     doc->selectionEnd( selNum, *paraTo, *indexTo );
@@ -3078,9 +3079,9 @@ int QTextEdit::paragraphs() const
 int QTextEdit::linesOfParagraph( int para ) const
 {
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return -1;
+    return -1;
     return p->lines();
 }
 
 /*!
@@ -3091,9 +3092,9 @@ int QTextEdit::linesOfParagraph( int para ) const
 int QTextEdit::paragraphLength( int para ) const
 {
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return -1;
+    return -1;
     return p->length() - 1;
 }
 
 /*!
@@ -3108,10 +3109,10 @@ int QTextEdit::lines() const
 {
     QTextParagraph *p = doc->firstParagraph();
     int l = 0;
     while ( p ) {
-	l += p->lines();
-	p = p->next();
+    l += p->lines();
+    p = p->next();
     }
 
     return l;
 }
@@ -3127,14 +3128,14 @@ int QTextEdit::lines() const
 int QTextEdit::lineOfChar( int para, int index )
 {
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return -1;
+    return -1;
 
     int idx, line;
     QTextStringChar *c = p->lineStartOfChar( index, &idx, &line );
     if ( !c )
-	return -1;
+    return -1;
 
     return line;
 }
 
@@ -3142,11 +3143,11 @@ void QTextEdit::setModified( bool m )
 {
     bool oldModified = modified;
     modified = m;
     if ( modified && doc->oTextValid )
-	doc->invalidateOriginalText();
+    doc->invalidateOriginalText();
     if ( oldModified != modified )
-	emit modificationChanged( modified );
+    emit modificationChanged( modified );
 }
 
 /*! \property QTextEdit::modified
   \brief whether the document has been modified by the user
@@ -3159,9 +3160,9 @@ bool QTextEdit::isModified() const
 
 void QTextEdit::setModified()
 {
     if ( !isModified() )
-	setModified( TRUE );
+    setModified( TRUE );
 }
 
 /*!
     Returns TRUE if the current format is italic; otherwise returns FALSE.
@@ -3260,12 +3261,12 @@ void QTextEdit::startDrag()
     mousePressed = FALSE;
     inDoubleClick = FALSE;
     QDragObject *drag = new QTextDrag( doc->selectedText( QTextDocument::Standard, qt_enable_richtext_copy ), viewport() );
     if ( isReadOnly() ) {
-	drag->dragCopy();
+    drag->dragCopy();
     } else {
-	if ( drag->drag() && QDragObject::target() != this && QDragObject::target() != viewport() )
-	    removeSelectedText();
+    if ( drag->drag() && QDragObject::target() != this && QDragObject::target() != viewport() )
+        removeSelectedText();
     }
 #endif
 }
 
@@ -3280,11 +3281,11 @@ void QTextEdit::startDrag()
 
 void QTextEdit::selectAll( bool select )
 {
     if ( !select )
-	doc->removeSelection( QTextDocument::Standard );
+    doc->removeSelection( QTextDocument::Standard );
     else
-	doc->selectAll( QTextDocument::Standard );
+    doc->selectAll( QTextDocument::Standard );
     repaintChanged();
     emit copyAvailable( doc->hasSelection( QTextDocument::Standard ) );
     emit selectionChanged();
 #ifndef QT_NO_CURSOR
@@ -3294,17 +3295,17 @@ void QTextEdit::selectAll( bool select )
 
 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 ) );
-	}
+    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;
@@ -3324,10 +3325,10 @@ void QTextEdit::UndoRedoInfo::clear()
 
 void QTextEdit::del()
 {
     if ( doc->hasSelection( QTextDocument::Standard ) ) {
-	removeSelectedText();
-	return;
+    removeSelectedText();
+    return;
     }
 
     doKeyboardAction( ActionDelete );
 }
@@ -3403,9 +3404,9 @@ void QTextEdit::setPaper( const QBrush& pap )
 
 QBrush QTextEdit::paper() const
 {
     if ( doc->paper() )
-	return *doc->paper();
+    return *doc->paper();
     return QBrush();
 }
 
 /*!
@@ -3476,44 +3477,44 @@ void QTextEdit::append( const QString &text )
 
     doc->removeSelection( QTextDocument::Standard );
     TextFormat f = doc->textFormat();
     if ( f == AutoText ) {
-	if ( QStyleSheet::mightBeRichText( text ) )
-	    f = RichText;
-	else
-	    f = PlainText;
+    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();
+    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 );
-	}
+    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 );
+    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;
+    cursorVisible = TRUE;
     setModified();
     emit textChanged();
 }
 
@@ -3545,56 +3546,56 @@ QString QTextEdit::selectedText() const
 bool QTextEdit::handleReadOnlyKeyEvent( QKeyEvent *e )
 {
     switch( e->key() ) {
     case Key_Down:
-	setContentsPos( contentsX(), contentsY() + 10 );
-	break;
+    setContentsPos( contentsX(), contentsY() + 10 );
+    break;
     case Key_Up:
-	setContentsPos( contentsX(), contentsY() - 10 );
-	break;
+    setContentsPos( contentsX(), contentsY() - 10 );
+    break;
     case Key_Left:
-	setContentsPos( contentsX() - 10, contentsY() );
-	break;
+    setContentsPos( contentsX() - 10, contentsY() );
+    break;
     case Key_Right:
-	setContentsPos( contentsX() + 10, contentsY() );
-	break;
+    setContentsPos( contentsX() + 10, contentsY() );
+    break;
     case Key_PageUp:
-	setContentsPos( contentsX(), contentsY() - visibleHeight() );
-	break;
+    setContentsPos( contentsX(), contentsY() - visibleHeight() );
+    break;
     case Key_PageDown:
-	setContentsPos( contentsX(), contentsY() + visibleHeight() );
-	break;
+    setContentsPos( contentsX(), contentsY() + visibleHeight() );
+    break;
     case Key_Home:
-	setContentsPos( contentsX(), 0 );
-	break;
+    setContentsPos( contentsX(), 0 );
+    break;
     case Key_End:
-	setContentsPos( contentsX(), contentsHeight() - visibleHeight() );
-	break;
+    setContentsPos( contentsX(), contentsHeight() - visibleHeight() );
+    break;
     case Key_F16: // Copy key on Sun keyboards
-	copy();
-	break;
+    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 ) );
+    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 );
+        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;
+    if ( e->state() & ControlButton ) {
+        switch ( e->key() ) {
+        case Key_C: case Key_F16: // Copy key on Sun keyboards
+        copy();
+        break;
+        }
+    }
+    return FALSE;
     }
     return TRUE;
 }
 
@@ -3637,29 +3638,29 @@ void QTextEdit::makeParagVisible( QTextParagraph *p )
 
 void QTextEdit::scrollToAnchor( const QString& name )
 {
     if ( !isVisible() ) {
-	d->scrollToAnchor = name;
-	return;
+    d->scrollToAnchor = name;
+    return;
     }
     if ( name.isEmpty() )
-	return;
+    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();
+    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();
     }
 }
 
 /*! If there is an anchor at position \a pos (in contents
@@ -3690,9 +3691,9 @@ void QTextEdit::updateStyles()
 
 void QTextEdit::setDocument( QTextDocument *dc )
 {
     if ( dc == doc )
-	return;
+    return;
     doc = dc;
     delete cursor;
     cursor = new QTextCursor( doc );
     clearUndoRedo();
@@ -3716,72 +3717,72 @@ void QTextEdit::pasteSubType( const QCString& subtype )
 {
     QCString st = subtype;
     QString t = QApplication::clipboard()->text(st);
     if ( doc->hasSelection( QTextDocument::Standard ) )
-	removeSelectedText();
+    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 ( 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 );
-	}
+    // 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';
+    //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 );
+    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
@@ -3794,49 +3795,49 @@ void QTextEdit::pasteSubType( const QCString& subtype )
 void QTextEdit::pasteSpecial( const QPoint& pt )
 {
     QCString st = pickSpecial( QApplication::clipboard()->data(), TRUE, pt );
     if ( !st.isEmpty() )
-	pasteSubType( st );
+    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();
-	}
+    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();
-	    }
-	}
+    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();
 }
@@ -3847,9 +3848,9 @@ QCString QTextEdit::pickSpecial( QMimeSource* ms, bool always_ask, const QPoint&
 
   This enum defines the QTextEdit's word wrap modes.  The following
   values are valid:
 
-  \value NoWrap	 Do not wrap the text.
+  \value NoWrap  Do not wrap the text.
 
   \value WidgetWidth Wrap the text at the current width of the
   widget (this is the default). Wrapping is at whitespace by default;
   this can be changed with setWrapPolicy().
@@ -3885,41 +3886,41 @@ QCString QTextEdit::pickSpecial( QMimeSource* ms, bool always_ask, const QPoint&
 
 void QTextEdit::setWordWrap( WordWrap mode )
 {
     if ( wrapMode == mode )
-	return;
+    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;
+    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;
+    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;
+    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;
+    if ( wrapWidth < 0 )
+        wrapWidth = 80;
+    document()->formatter()->setWrapEnabled( TRUE );
+    document()->formatter()->setWrapAtColumn( wrapWidth );
+    setWrapColumnOrWidth( wrapWidth );
+    break;
     }
 }
 
 QTextEdit::WordWrap QTextEdit::wordWrap() const
@@ -3942,19 +3943,19 @@ QTextEdit::WordWrap QTextEdit::wordWrap() const
 void QTextEdit::setWrapColumnOrWidth( int value )
 {
     wrapWidth = value;
     if ( wrapMode == FixedColumnWidth ) {
-	document()->formatter()->setWrapAtColumn( wrapWidth );
-	resizeContents( 0, 0 );
-	doc->setWidth( visibleWidth() );
-	doc->setMinimumWidth( -1 );
+    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 );
+    document()->formatter()->setWrapAtColumn( -1 );
+    resizeContents( wrapWidth, 0 );
+    doc->setWidth( wrapWidth );
+    doc->setMinimumWidth( wrapWidth );
     } else {
-	return;
+    return;
     }
     doc->invalidate();
     updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
     lastFormatted = doc->firstParagraph();
@@ -3964,9 +3965,9 @@ void QTextEdit::setWrapColumnOrWidth( int value )
 
 int QTextEdit::wrapColumnOrWidth() const
 {
     if ( wrapMode == WidgetWidth )
-	return visibleWidth();
+    return visibleWidth();
     return wrapWidth;
 }
 
 
@@ -3997,15 +3998,15 @@ int QTextEdit::wrapColumnOrWidth() const
 
 void QTextEdit::setWrapPolicy( WrapPolicy policy )
 {
     if ( wPolicy == policy )
-	return;
+    return;
     wPolicy = policy;
     QTextFormatter *formatter;
     if ( policy == AtWhiteSpace )
-	formatter = new QTextFormatterBreakWords;
+    formatter = new QTextFormatterBreakWords;
     else
-	formatter = new QTextFormatterBreakInWords;
+    formatter = new QTextFormatterBreakInWords;
     formatter->setWrapAtColumn( document()->formatter()->wrapAtColumn() );
     formatter->setWrapEnabled( document()->formatter()->isWrapEnabled( 0 ) );
     document()->setFormatter( formatter );
     doc->invalidate();
@@ -4034,9 +4035,9 @@ void QTextEdit::clear()
     removeSelectedText( QTextDocument::Temp );
 
     setContentsPos( 0, 0 );
     if ( cursor->isValid() )
-	cursor->restoreState();
+    cursor->restoreState();
     doc->clear( TRUE );
     delete cursor;
     cursor = new QTextCursor( doc );
     lastFormatted = 0;
@@ -4120,14 +4121,14 @@ void QTextEdit::clearUndoRedo()
 
 bool QTextEdit::getFormat( int para, int index, QFont *font, QColor *color, VerticalAlignment *verticalAlignment )
 {
     if ( !font || !color )
-	return FALSE;
+    return FALSE;
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return FALSE;
+    return FALSE;
     if ( index < 0 || index >= p->length() )
-	return FALSE;
+    return FALSE;
     *font = p->at( index )->format()->font();
     *color = p->at( index )->format()->color();
     *verticalAlignment = (VerticalAlignment)p->at( index )->format()->vAlign();
     return TRUE;
@@ -4151,18 +4152,18 @@ bool QTextEdit::getFormat( int para, int index, QFont *font, QColor *color, Vert
   Returns FALSE if \a para is out of range otherwise returns TRUE.
 */
 
 bool QTextEdit::getParagraphFormat( int para, QFont *font, QColor *color,
-				    VerticalAlignment *verticalAlignment, int *alignment,
-				    QStyleSheetItem::DisplayMode *displayMode,
-				    QStyleSheetItem::ListStyle *listStyle,
-				    int *listDepth )
+                    VerticalAlignment *verticalAlignment, int *alignment,
+                    QStyleSheetItem::DisplayMode *displayMode,
+                    QStyleSheetItem::ListStyle *listStyle,
+                    int *listDepth )
 {
     if ( !font || !color || !alignment || !displayMode || !listStyle )
-	return FALSE;
+    return FALSE;
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return FALSE;
+    return FALSE;
     *font = p->at(0)->format()->font();
     *color = p->at(0)->format()->color();
     *verticalAlignment = (VerticalAlignment)p->at(0)->format()->vAlign();
     *alignment = p->alignment();
@@ -4187,22 +4188,22 @@ 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();
+    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[ 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 ) );
+    d->id[ IdPaste ] = popup->insertItem( tr( "&Paste" ) + ACCEL_KEY( V ) );
 #endif
     if ( !isReadOnly() ) {
-	d->id[ IdClear ] = popup->insertItem( tr( "Clear" ) );
-	popup->insertSeparator();
+    d->id[ IdClear ] = popup->insertItem( tr( "Clear" ) );
+    popup->insertSeparator();
     }
 #if defined(Q_WS_X11)
     d->id[ IdSelectAll ] = popup->insertItem( tr( "Select All" ) );
 #else
@@ -4333,10 +4334,10 @@ void QTextEdit::zoomTo( int size )
 
 void QTextEdit::sync()
 {
     while ( lastFormatted ) {
-	lastFormatted->format();
-	lastFormatted = lastFormatted->next();
+    lastFormatted->format();
+    lastFormatted = lastFormatted->next();
     }
     resizeContents( contentsWidth(), doc->height() );
 }
 
@@ -4345,19 +4346,19 @@ void QTextEdit::sync()
 void QTextEdit::setEnabled( bool b )
 {
     QScrollView::setEnabled( b );
     if ( !b ) {
-	blinkTimer->stop();
-	drawCursor( FALSE );
+    blinkTimer->stop();
+    drawCursor( FALSE );
     }
     if ( textFormat() == PlainText ) {
-	QTextFormat *f = doc->formatCollection()->defaultFormat();
-	f->setColor( colorGroup().text() );
-	updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
+    QTextFormat *f = doc->formatCollection()->defaultFormat();
+    f->setColor( colorGroup().text() );
+    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
     }
     if ( b ) {
-	blinkTimer->start( QApplication::cursorFlashTime() / 2 );
-	drawCursor( TRUE );
+    blinkTimer->start( QApplication::cursorFlashTime() / 2 );
+    drawCursor( TRUE );
     }
 }
 
 /*!
@@ -4371,35 +4372,35 @@ void QTextEdit::setEnabled( bool b )
 
 void QTextEdit::setSelectionAttributes( int selNum, const QColor &back, bool invertText )
 {
     if ( selNum < 1 )
-	return;
+    return;
     if ( selNum > doc->numSelections() )
-	doc->addSelection( selNum );
+    doc->addSelection( selNum );
     doc->setSelectionColor( selNum, back );
     doc->setInvertSelectionText( selNum, invertText );
 }
 
 /*! \reimp */
 void QTextEdit::windowActivationChange( bool )
 {
     if ( !isVisible() )
-	return;
+    return;
 
     if ( palette().active() != palette().inactive() )
-	updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
+    updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
 }
 
 void QTextEdit::setReadOnly( bool b )
 {
     if ( readonly == b )
-	return;
+    return;
     readonly = b;
 #ifndef QT_NO_CURSOR
     if ( readonly )
-	viewport()->setCursor( arrowCursor );
+    viewport()->setCursor( arrowCursor );
     else
-	viewport()->setCursor( ibeamCursor );
+    viewport()->setCursor( ibeamCursor );
 #endif
 }
 
 /*! Scrolls to the bottom of the document and does formatting if
@@ -4420,9 +4421,9 @@ 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 QRect( -1, -1, -1, -1 );
     return p->rect();
 }
 
 /*!
@@ -4434,9 +4435,9 @@ int QTextEdit::paragraphAt( const QPoint &pos ) const
 {
     QTextCursor c( doc );
     c.place( pos, doc->firstParagraph() );
     if ( c.paragraph() )
-	return c.paragraph()->paragId();
+    return c.paragraph()->paragId();
     return -1;
 }
 
 /*!
@@ -4450,11 +4451,11 @@ 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();
+    if ( para )
+        *para = c.paragraph()->paragId();
+    return c.index();
     }
     return -1;
 }
 
@@ -4463,9 +4464,9 @@ int QTextEdit::charAt( const QPoint &pos, int *para ) const
 void QTextEdit::setParagraphBackgroundColor( int para, const QColor &bg )
 {
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return;
+    return;
     p->setBackgroundColor( bg );
     repaintChanged();
 }
 
@@ -4476,9 +4477,9 @@ void QTextEdit::setParagraphBackgroundColor( int para, const QColor &bg )
 void QTextEdit::clearParagraphBackground( int para )
 {
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return;
+    return;
     p->clearBackgroundColor();
     repaintChanged();
 }
 
@@ -4490,12 +4491,12 @@ void QTextEdit::clearParagraphBackground( int para )
 QColor QTextEdit::paragraphBackgroundColor( int para ) const
 {
     QTextParagraph *p = doc->paragAt( para );
     if ( !p )
-	return QColor();
+    return QColor();
     QColor *c = p->backgroundColor();
     if ( c )
-	return *c;
+    return *c;
     return QColor();
 }
 
 /*! \property QTextEdit::undoRedoEnabled
@@ -4530,42 +4531,42 @@ bool QTextEdit::isRedoAvailable() const
 
 void QTextEdit::ensureFormatted( QTextParagraph *p )
 {
     while ( !p->isValid() ) {
-	if ( !lastFormatted )
-	    return;
-	formatMore();
+    if ( !lastFormatted )
+        return;
+    formatMore();
     }
 }
 
 /*! \internal */
 void QTextEdit::updateCursor( const QPoint & pos )
 {
     if ( isReadOnly() && linksEnabled() ) {
-	QTextCursor c = *cursor;
-	placeCursor( pos, &c, TRUE );
+    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;
+    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 );
+        viewport()->setCursor( onLink.isEmpty() ? arrowCursor : pointingHandCursor );
 #endif
-	    QUrl u( doc->context(), onLink, TRUE );
-	    emitHighlighted( u.toString( FALSE, FALSE ) );
-	} else {
+        QUrl u( doc->context(), onLink, TRUE );
+        emitHighlighted( u.toString( FALSE, FALSE ) );
+    } else {
 #ifndef QT_NO_CURSOR
-	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+        viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
-	    onLink = QString::null;
-	    emitHighlighted( QString::null );
-	}
+        onLink = QString::null;
+        emitHighlighted( QString::null );
+    }
 #endif
     }
 }