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

1 files changed, 1 insertions, 0 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
@@ -420,512 +420,513 @@ static bool block_set_alignment = FALSE;
 
   When text is selected this signal will be emitted with \a yes set to
   TRUE. If no text has been selected or if the selected text is
   de-selected this signal is emitted with \a yes set to FALSE.
 
     If \a yes is TRUE then copy() can be used to copy the selection to the
     clipboard. If \a yes is FALSE then copy() does nothing.
 
     \sa selectionChanged()
 */
 
 
 /*!  \fn void QTextEdit::textChanged()
 
   This signal is emitted whenever the text in the text edit changes.
 
   \sa setText() append()
  */
 
 /*!  \fn void QTextEdit::selectionChanged()
 
   This signal is emitted whenever the selection changes.
 
   \sa setSelection() copyAvailable()
 */
 
 /*!  \fn QTextDocument *QTextEdit::document() const
 
     \internal
 
   This function returns the QTextDocument which is used by the text
   edit.
 */
 
 /*!  \fn void QTextEdit::setDocument( QTextDocument *doc )
 
     \internal
 
   This function sets the QTextDocument which should be used by the text
   edit to \a doc. This can be used, for example, if you want to
   display a document using multiple views. You would create a
   QTextDocument and set it to the text edits which should display it.
   You would need to connect to the textChanged() and
   selectionChanged() signals of all the text edits and update them all
   accordingly (preferably with a slight delay for efficiency reasons).
 */
 
 /*! \enum QTextEdit::CursorAction
 
   This enum is used by moveCursor() to specify in which direction
   the cursor should be moved:
 
   \value MoveBackward  Moves the cursor one character backward
 
   \value MoveWordBackward Moves the cursor one word backward
 
   \value MoveForward  Moves the cursor one character forward
 
   \value MoveWordForward Moves the cursor one word forward
 
   \value MoveUp  Moves the cursor up one line
 
   \value MoveDown  Moves the cursor down one line
 
   \value MoveLineStart  Moves the cursor to the beginning of the line
 
   \value MoveLineEnd Moves the cursor to the end of the line
 
   \value MoveHome  Moves the cursor to the beginning of the document
 
   \value MoveEnd Moves the cursor to the end of the document
 
   \value MovePgUp  Moves the cursor one page up
 
   \value MovePgDown  Moves the cursor one page down
 */
 
 
 /*!
   \property QTextEdit::overwriteMode
   \brief the text edit's overwrite mode
 
   If FALSE (the default) characters entered by the user are inserted
   with any characters to the right being moved out of the way.
   If TRUE, the editor is in overwrite mode, i.e. characters entered by
   the user overwrite any characters to the right of the cursor position.
 */
 
 /*! \fn void QTextEdit::setCurrentFont( const QFont &f )
 
   Sets the font of the current format to \a f.
 
   \sa font() setPointSize() setFamily()
 */
 
 /*!
   \property QTextEdit::undoDepth
   \brief the depth of the undo history
 
   The maximum number of steps in the undo/redo history.
   The default is 100.
 
   \sa undo() redo()
 */
 
 /*! \fn void QTextEdit::undoAvailable( bool yes )
 
   This signal is emitted when the availability of undo changes.  If \a
   yes is TRUE, then undo() will work until undoAvailable( FALSE ) is
   next emitted.
 
   \sa undo() undoDepth()
 */
 
 /*! \fn void QTextEdit::modificationChanged( bool m )
 
   This signal is emitted when the modification of the document
   changed. If \a m is TRUE, the document was modified, otherwise the
   modification state has been reset to unmodified.
 
   \sa modified
 */
 
 /*! \fn void QTextEdit::redoAvailable( bool yes )
 
   This signal is emitted when the availability of redo changes.  If \a
   yes is TRUE, then redo() will work until redoAvailable( FALSE ) is
   next emitted.
 
   \sa redo() undoDepth()
 */
 
 /*! \fn void QTextEdit::currentFontChanged( const QFont &f )
 
   This signal is emitted if the font of the current format has changed.
 
   The new font is \a f.
 
   \sa setCurrentFont()
 */
 
 /*! \fn void QTextEdit::currentColorChanged( const QColor &c )
 
   This signal is emitted if the color of the current format has changed.
 
   The new color is \a c.
 
   \sa setColor()
 */
 
 /*! \fn void QTextEdit::currentVerticalAlignmentChanged( VerticalAlignment a )
 
   This signal is emitted if the vertical alignment of the current
   format has changed.
 
   The new vertical alignment is \a a.
 
   \sa setVerticalAlignment()
 */
 
 /*! \fn void QTextEdit::currentAlignmentChanged( int a )
 
   This signal is emitted if the alignment of the current paragraph
   has changed.
 
   The new alignment is \a a.
 
   \sa setAlignment()
 */
 
 /*! \fn void QTextEdit::cursorPositionChanged( QTextCursor *c )
 
   This signal is emitted if the position of the cursor changed. \a c
   points to the text cursor object.
 
   \sa setCursorPosition()
 */
 
 /*! \overload void QTextEdit::cursorPositionChanged( int para, int pos )
 
   This signal is emitted if the position of the cursor changed. \a
   para contains the paragraph index and \a pos contains the character
   position within the paragraph.
 
   \sa setCursorPosition()
 */
 
 /*! \fn void QTextEdit::returnPressed()
 
   This signal is emitted if the user pressed the Return or the Enter key.
 */
 
 /*!
     \fn QTextCursor *QTextEdit::textCursor() const
 
     Returns the text edit's text cursor.
 
     \warning QTextCursor is not in the public API, but in special
     circumstances you might wish to use it.
 */
 
 /*!  Constructs an empty QTextEdit with parent \a parent and name \a
   name.
 */
 
 QTextEdit::QTextEdit( QWidget *parent, const char *name )
     : QScrollView( parent, name, WStaticContents | WRepaintNoErase | WResizeNoErase ),
       doc( new QTextDocument( 0 ) ), undoRedoInfo( doc )
 {
     init();
 }
 
 /*!
     Constructs a QTextEdit with parent \a parent and name \a name. The
     text edit will display the text \a text using context \a context.
 
     The \a context is a path which the text edit's QMimeSourceFactory
     uses to resolve the locations of files and images. It is passed to
     the mimeSourceFactory() when quering data.
 
     For example if the text contains an image tag,
     \c{<img src="image.png">}, and the context is "path/to/look/in", the
     QMimeSourceFactory will try to load the image from
     "path/to/look/in/image.png". If the tag was
     \c{<img src="/image.png">}, the context will not be used (because
     QMimeSourceFactory recognizes that we have used an absolute path)
     and will try to load "/image.png". The context is applied in exactly
     the same way to \e hrefs, for example,
     \c{<a href="target.html">Target</a>}, would resolve to
     "path/to/look/in/target.html".
 
 */
 
 QTextEdit::QTextEdit( const QString& text, const QString& context,
 		      QWidget *parent, const char *name)
     : QScrollView( parent, name, WStaticContents | WRepaintNoErase | WResizeNoErase ),
       doc( new QTextDocument( 0 ) ), undoRedoInfo( doc )
 {
     init();
     setText( text, context );
 }
 
 /*! \reimp */
 
 QTextEdit::~QTextEdit()
 {
     delete undoRedoInfo.d;
     undoRedoInfo.d = 0;
     delete cursor;
     delete doc;
     delete d;
 }
 
 void QTextEdit::init()
 {
     setFrameStyle( Sunken );
+    setVScrollBarMode( AlwaysOn );
     undoEnabled = TRUE;
     readonly = TRUE;
     setReadOnly( FALSE );
     d = new QTextEditPrivate;
     connect( doc, SIGNAL( minimumWidthChanged(int) ),
 	     this, SLOT( documentWidthChanged(int) ) );
 
     mousePressed = FALSE;
     inDoubleClick = FALSE;
     modified = FALSE;
     onLink = QString::null;
     overWrite = FALSE;
     wrapMode = WidgetWidth;
     wrapWidth = -1;
     wPolicy = AtWhiteSpace;
     inDnD = FALSE;
 
     doc->setFormatter( new QTextFormatterBreakWords );
     doc->formatCollection()->defaultFormat()->setFont( QScrollView::font() );
     doc->formatCollection()->defaultFormat()->setColor( colorGroup().color( QColorGroup::Text ) );
     currentFormat = doc->formatCollection()->defaultFormat();
     currentAlignment = Qt3::AlignAuto;
 
     viewport()->setBackgroundMode( PaletteBase );
     viewport()->setAcceptDrops( TRUE );
     resizeContents( 0, doc->lastParagraph() ?
 		    ( doc->lastParagraph()->paragId() + 1 ) * doc->formatCollection()->defaultFormat()->height() : 0 );
 
     setKeyCompression( TRUE );
     viewport()->setMouseTracking( TRUE );
 #ifndef QT_NO_CURSOR
     viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
 #endif
     cursor = new QTextCursor( doc );
 
     formatTimer = new QTimer( this );
     connect( formatTimer, SIGNAL( timeout() ),
 	     this, SLOT( formatMore() ) );
     lastFormatted = doc->firstParagraph();
 
     scrollTimer = new QTimer( this );
     connect( scrollTimer, SIGNAL( timeout() ),
 	     this, SLOT( autoScrollTimerDone() ) );
 
     interval = 0;
     changeIntervalTimer = new QTimer( this );
     connect( changeIntervalTimer, SIGNAL( timeout() ),
 	     this, SLOT( doChangeInterval() ) );
 
     cursorVisible = TRUE;
     blinkTimer = new QTimer( this );
     connect( blinkTimer, SIGNAL( timeout() ),
 	     this, SLOT( blinkCursor() ) );
 
 #ifndef QT_NO_DRAGANDDROP
     dragStartTimer = new QTimer( this );
     connect( dragStartTimer, SIGNAL( timeout() ),
 	     this, SLOT( startDrag() ) );
 #endif
 
 
     formatMore();
 
     blinkCursorVisible = FALSE;
 
     viewport()->setFocusProxy( this );
     viewport()->setFocusPolicy( WheelFocus );
     viewport()->installEventFilter( this );
     installEventFilter( this );
 }
 
 void QTextEdit::paintDocument( bool drawAll, QPainter *p, int cx, int cy, int cw, int ch )
 {
     bool drawCur = hasFocus() || viewport()->hasFocus();
     if ( hasSelectedText() || isReadOnly() || !cursorVisible )
 	drawCur = FALSE;
     QColorGroup g = colorGroup();
     if ( doc->paper() )
 	g.setBrush( QColorGroup::Base, *doc->paper() );
 
     if ( contentsY() < doc->y() ) {
 	p->fillRect( contentsX(), contentsY(), visibleWidth(), doc->y(),
 		     g.brush( QColorGroup::Base ) );
     }
     if ( drawAll && doc->width() - contentsX() < cx + cw ) {
 	p->fillRect( doc->width() - contentsX(), cy, cx + cw - doc->width() + contentsX(), ch,
 		     g.brush( QColorGroup::Base ) );
     }
 
     p->setBrushOrigin( -contentsX(), -contentsY() );
 
     lastFormatted = doc->draw( p, cx, cy, cw, ch, g, !drawAll, drawCur, cursor );
 
     if ( lastFormatted == doc->lastParagraph() )
 	resizeContents( contentsWidth(), doc->height() );
 
     if ( contentsHeight() < visibleHeight() && ( !doc->lastParagraph() || doc->lastParagraph()->isValid() ) && drawAll )
 	p->fillRect( 0, contentsHeight(), visibleWidth(),
 		     visibleHeight() - contentsHeight(), g.brush( QColorGroup::Base ) );
 }
 
 /*! \reimp */
 
 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;
 	}
     }
 
 }
 
 /*! \reimp */
 
 void QTextEdit::drawContents( QPainter * )
 {
 }
 
 /*! \reimp */
 
 bool QTextEdit::event( QEvent *e )
 {
     if ( e->type() == QEvent::AccelOverride && !isReadOnly() ) {
 	QKeyEvent* ke = (QKeyEvent*) e;
 	if ( ke->state() == NoButton || ke->state() == Keypad ) {
 	    if ( ke->key() < Key_Escape ) {
 		ke->accept();
 	    } else {
 		switch ( ke->key() ) {
 		case Key_Return:
 		case Key_Enter:
 		case Key_Delete:
 		case Key_Home:
 		case Key_End:
 		case Key_Backspace:
 		    ke->accept();
 		default:
 		    break;
 		}
 	    }
 	} else if ( ke->state() & ControlButton ) {
 	    switch ( ke->key() ) {
 // Those are too frequently used for application functionality
 /*	    case Key_A:
 	    case Key_B:
 	    case Key_D:
 	    case Key_E:
 	    case Key_F:
 	    case Key_H:
 	    case Key_I:
 	    case Key_K:
 	    case Key_N:
 	    case Key_P:
 	    case Key_T:
 */
 	    case Key_C:
 	    case Key_V:
 	    case Key_X:
 	    case Key_Y:
 	    case Key_Z:
 	    case Key_Left:
 	    case Key_Right:
 	    case Key_Up:
 	    case Key_Down:
 	    case Key_Home:
 	    case Key_End:
 	    case Key_Tab:
 #if defined (Q_WS_WIN)
 	    case Key_Insert:
 	    case Key_Delete:
 #endif
 		ke->accept();
 	    default:
 		break;
 	    }
 	} else {
 	    switch ( ke->key() ) {
 #if defined (Q_WS_WIN)
 	    case Key_Insert:
 		ke->accept();
 #endif
 	    default:
 		break;
 	    }
 	}
     }
 
     if ( e->type() == QEvent::Show ) {
 	if ( d->ensureCursorVisibleInShowEvent ) {
 	    sync();
 	    ensureCursorVisible();
 	    d->ensureCursorVisibleInShowEvent = FALSE;
 	}
 	if ( !d->scrollToAnchor.isEmpty()  ) {
 	    scrollToAnchor( d->scrollToAnchor );
 	    d->scrollToAnchor = QString::null;
 	}
     }
     return QWidget::event( e );
 }
 
 /*!
     Processes the key event, \a e.
     By default key events are used to provide keyboard navigation and
     text editing.
 */
 
 void QTextEdit::keyPressEvent( QKeyEvent *e )
 {
     changeIntervalTimer->stop();
     interval = 10;
     bool unknown = FALSE;
     if ( isReadOnly() ) {
 	if ( !handleReadOnlyKeyEvent( e ) )
 	    QScrollView::keyPressEvent( e );
 	changeIntervalTimer->start( 100, TRUE );
 	return;
     }
 
 
     bool selChanged = FALSE;
     for ( int i = 1; i < doc->numSelections(); ++i ) // start with 1 as we don't want to remove the Standard-Selection
 	selChanged = doc->removeSelection( i ) || selChanged;
 
     if ( selChanged ) {
 	cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
 	repaintChanged();
     }
 
     bool clearUndoRedoInfo = TRUE;
 
 
     switch ( e->key() ) {
     case Key_Left:
     case Key_Right: {
 	// a bit hacky, but can't change this without introducing new enum values for move and keeping the
 	// correct semantics and movement for BiDi and non BiDi text.
 	CursorAction a;
 	if ( cursor->paragraph()->string()->isRightToLeft() == (e->key() == Key_Right) )
 	    a = e->state() & ControlButton ? MoveWordBackward : MoveBackward;
 	else
 	    a = e->state() & ControlButton ? MoveWordForward : MoveForward;
 	moveCursor( a, e->state() & ShiftButton );
 	break;
     }
     case Key_Up:
 	moveCursor( e->state() & ControlButton ? MovePgUp : MoveUp, e->state() & ShiftButton );
 	break;
     case Key_Down:
 	moveCursor( e->state() & ControlButton ? MovePgDown : MoveDown, e->state() & ShiftButton );