Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731

1 files changed, 7467 insertions, 0 deletions

diff --git a/src/widgets/qtextedit.cpp b/src/widgets/qtextedit.cpp
new file mode 100644
index 000000000..09466f459
--- /dev/null
+++ b/src/widgets/qtextedit.cpp
@@ -0,0 +1,7467 @@
+/****************************************************************************
+**
+** Implementation of the TQTextEdit class
+**
+** Created : 990101
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the widgets module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qtextedit.h"
+
+#ifndef QT_NO_TEXTEDIT
+
+// Keep this position to avoid patch rejection
+#ifndef QT_NO_IM
+#include "qinputcontext.h"
+#endif
+
+#include "../kernel/qrichtext_p.h"
+#include "qpainter.h"
+#include "qpen.h"
+#include "qbrush.h"
+#include "qpixmap.h"
+#include "qfont.h"
+#include "qcolor.h"
+#include "qstyle.h"
+#include "qsize.h"
+#include "qevent.h"
+#include "qtimer.h"
+#include "qapplication.h"
+#include "qlistbox.h"
+#include "qvbox.h"
+#include "qapplication.h"
+#include "qclipboard.h"
+#include "qcolordialog.h"
+#include "qfontdialog.h"
+#include "qstylesheet.h"
+#include "qdragobject.h"
+#include "qurl.h"
+#include "qcursor.h"
+#include "qregexp.h"
+#include "qpopupmenu.h"
+#include "qptrstack.h"
+#include "qmetaobject.h"
+#include "qtextbrowser.h"
+#include <private/qucom_p.h>
+#include "private/qsyntaxhighlighter_p.h"
+#include <qguardedptr.h>
+
+#ifndef QT_NO_ACCEL
+#include <qkeysequence.h>
+#define ACCEL_KEY(k) "\t" + TQString(TQKeySequence( TQt::CTRL | TQt::Key_ ## k ))
+#else
+#define ACCEL_KEY(k) "\t" + TQString("Ctrl+" #k)
+#endif
+
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+#define LOGOFFSET(i) d->logOffset + i
+#endif
+
+struct TQUndoRedoInfoPrivate
+{
+    TQTextString text;
+};
+
+class TQTextEditPrivate
+{
+public:
+    TQTextEditPrivate()
+	:preeditStart(-1),preeditLength(-1),ensureCursorVisibleInShowEvent(FALSE),
+	 tabChangesFocus(FALSE),
+#ifndef QT_NO_CLIPBOARD
+	 clipboard_mode( TQClipboard::Clipboard ),
+#endif
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+	 od(0), optimMode(FALSE),
+	 maxLogLines(-1),
+	 logOffset(0),
+#endif
+	 autoFormatting( (uint)TQTextEdit::AutoAll )
+    {
+	for ( int i=0; i<7; i++ )
+	    id[i] = 0;
+    }
+    int id[ 7 ];
+    int preeditStart;
+    int preeditLength;
+    bool composeMode() const { return ( preeditLength > 0 ); }
+
+    uint ensureCursorVisibleInShowEvent : 1;
+    uint tabChangesFocus : 1;
+    TQString scrollToAnchor; // used to deferr scrollToAnchor() until the show event when we are resized
+    TQString pressedName;
+    TQString onName;
+#ifndef QT_NO_CLIPBOARD
+    TQClipboard::Mode clipboard_mode;
+#endif
+    TQTimer *trippleClickTimer;
+    TQPoint trippleClickPoint;
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    TQTextEditOptimPrivate * od;
+    bool optimMode : 1;
+    int maxLogLines;
+    int logOffset;
+#endif
+    uint autoFormatting;
+};
+
+#ifndef QT_NO_MIME
+class TQRichTextDrag : public TQTextDrag
+{
+public:
+    TQRichTextDrag( TQWidget *dragSource = 0, const char *name = 0 );
+
+    void setPlainText( const TQString &txt ) { setText( txt ); }
+    void setRichText( const TQString &txt ) { richTxt = txt; }
+
+    virtual TQByteArray encodedData( const char *mime ) const;
+    virtual const char* format( int i ) const;
+
+    static bool decode( TQMimeSource *e, TQString &str, const TQCString &mimetype,
+			const TQCString &subtype );
+    static bool canDecode( TQMimeSource* e );
+
+private:
+    TQString richTxt;
+
+};
+
+TQRichTextDrag::TQRichTextDrag( TQWidget *dragSource, const char *name )
+    : TQTextDrag( dragSource, name )
+{
+}
+
+TQByteArray TQRichTextDrag::encodedData( const char *mime ) const
+{
+    if ( qstrcmp( "application/x-qrichtext", mime ) == 0 ) {
+	return richTxt.utf8(); // #### perhaps we should use USC2 instead?
+    } else
+	return TQTextDrag::encodedData( mime );
+}
+
+bool TQRichTextDrag::decode( TQMimeSource *e, TQString &str, const TQCString &mimetype,
+			    const TQCString &subtype )
+{
+    if ( mimetype == "application/x-qrichtext" ) {
+	// do richtext decode
+	const char *mime;
+	int i;
+	for ( i = 0; ( mime = e->format( i ) ); ++i ) {
+	    if ( qstrcmp( "application/x-qrichtext", mime ) != 0 )
+		continue;
+	    str = TQString::fromUtf8( e->encodedData( mime ) );
+	    return TRUE;
+	}
+	return FALSE;
+    }
+
+    // do a regular text decode
+    TQCString subt = subtype;
+    return TQTextDrag::decode( e, str, subt );
+}
+
+bool TQRichTextDrag::canDecode( TQMimeSource* e )
+{
+    if ( e->provides( "application/x-qrichtext" ) )
+	return TRUE;
+    return TQTextDrag::canDecode( e );
+}
+
+const char* TQRichTextDrag::format( int i ) const
+{
+    if ( TQTextDrag::format( i ) )
+	return TQTextDrag::format( i );
+    if ( TQTextDrag::format( i-1 ) )
+	return "application/x-qrichtext";
+    return 0;
+}
+
+#endif
+
+static bool block_set_alignment = FALSE;
+
+/*!
+    \class TQTextEdit qtextedit.h
+    \brief The TQTextEdit widget provides a powerful single-page rich text editor.
+
+    \ingroup basic
+    \ingroup text
+    \mainclass
+
+    \tableofcontents
+
+    \section1 Introduction and Concepts
+
+    TQTextEdit is an advanced WYSIWYG viewer/editor supporting rich
+    text formatting using HTML-style tags. It is optimized to handle
+    large documents and to respond tquickly to user input.
+
+    TQTextEdit has four 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.
+    \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>1.</sup>
+    \row \i Text Viewer \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.
+    \row \i Log Viewer \i setTextFormat(LogText)
+	 \i Append text using append(). The widget is set to be read
+	 only and rich text support is disabled although a few HTML
+	 tags (for color, bold, italic and underline) may be used.
+	 (See \link #logtextmode LogText mode\endlink for details.)
+    \endtable
+
+    <sup>1.</sup><small>A more complete API that supports setting
+    margins, images, etc., is planned for a later TQt release.</small>
+
+    TQTextEdit can be used as a syntax highlighting editor when used in
+    conjunction with TQSyntaxHighlighter.
+
+    We recommend that you always call setTextFormat() to set the mode
+    you want to use. If you use \c AutoText then setText() and
+    append() will try to determine whether the text they are given is
+    plain text or rich text. If you use \c RichText then setText() and
+    append() will assume that the text they are given is rich text.
+    insert() simply inserts the text it is given.
+
+    TQTextEdit works on paragraphs and characters. A paragraph is a
+    formatted string which is word-wrapped to fit into the width of
+    the widget. By default when reading plain text, one newline
+    signify a paragraph. A document consists of zero or more
+    paragraphs, indexed from 0. Characters are indexed on a
+    per-paragraph basis, also indexed from 0. The words in the
+    paragraph are aligned in accordance with the paragraph's
+    alignment(). Paragraphs are separated by hard line breaks. Each
+    character within a paragraph has its own attributes, for example,
+    font and color.
+
+    The text edit documentation uses the following concepts:
+    \list
+    \i \e{current format} --
+    this is the format at the current cursor position, \e and it
+    is the format of the selected text if any.
+    \i \e{current paragraph} -- the paragraph which contains the
+    cursor.
+    \endlist
+
+    TQTextEdit can display images (using TQMimeSourceFactory), lists and
+    tables. If the text is too large to view within the text edit's
+    viewport, scrollbars will appear. The text edit can load both
+    plain text and HTML files (a subset of HTML 3.2 and 4). The
+    rendering style and the set of valid tags are defined by a
+    styleSheet(). Custom tags can be created and placed in a custom
+    style sheet. Change the style sheet with \l{setStyleSheet()}; see
+    TQStyleSheet for details. The images identified by image tags are
+    displayed if they can be interpreted using the text edit's
+    \l{TQMimeSourceFactory}; see setMimeSourceFactory().
+
+    If you want a text browser with more navigation use TQTextBrowser.
+    If you just need to display a small piece of rich text use TQLabel
+    or TQSimpleRichText.
+
+    If you create a new TQTextEdit, and want to allow the user to edit
+    rich text, call setTextFormat(TQt::RichText) to ensure that the
+    text is treated as rich text. (Rich text uses HTML tags to set
+    text formatting attributes. See TQStyleSheet for information on the
+    HTML tags that are supported.). If you don't call setTextFormat()
+    explicitly the text edit will guess from the text itself whether
+    it is rich text or plain text. This means that if the text looks
+    like HTML or XML it will probably be interpreted as rich text, so
+    you should call setTextFormat(TQt::PlainText) to preserve such
+    text.
+
+    Note that we do not intend to add a full-featured web browser
+    widget to TQt (because that would easily double TQt's size and only
+    a few applications would benefit from it). The rich
+    text support in TQt is designed to provide a fast, portable and
+    efficient way to add reasonable online help facilities to
+    applications, and to provide a basis for rich text editors.
+
+    \section1 Using TQTextEdit as a Display Widget
+
+    TQTextEdit can display a large HTML subset, including tables and
+    images.
+
+    The text is set or replaced using setText() which deletes any
+    existing text and replaces it with the text passed in the
+    setText() call. If you call setText() with legacy HTML (with
+    setTextFormat(RichText) in force), and then call text(), the text
+    that is returned may have different markup, but will render the
+    same. Text can be inserted with insert(), paste(), pasteSubType()
+    and append(). Text that is appended does not go into the undo
+    history; this makes append() faster and consumes less memory. Text
+    can also be cut(). The entire text is deleted with clear() and the
+    selected text is deleted with removeSelectedText(). Selected
+    (marked) text can also be deleted with del() (which will delete
+    the character to the right of the cursor if no text is selected).
+
+    Loading and saving text is achieved using setText() and text(),
+    for example:
+    \code
+    TQFile file( fileName ); // Read the text from a file
+    if ( file.open( IO_ReadOnly ) ) {
+	TQTextStream stream( &file );
+	textEdit->setText( stream.read() );
+    }
+
+    TQFile file( fileName ); // Write the text to a file
+    if ( file.open( IO_WriteOnly ) ) {
+	TQTextStream stream( &file );
+	stream << textEdit->text();
+	textEdit->setModified( FALSE );
+    }
+    \endcode
+
+    By default the text edit wraps words at whitespace to fit within
+    the text edit widget. The setWordWrap() function is used to
+    specify the kind of word wrap you want, or \c NoWrap if you don't
+    want any wrapping. Call setWordWrap() to set a fixed pixel width
+    \c FixedPixelWidth, or character column (e.g. 80 column) \c
+    FixedColumnWidth with the pixels or columns specified with
+    setWrapColumnOrWidth(). If you use word wrap to the widget's width
+    \c WidgetWidth, you can specify whether to break on whitespace or
+    anywhere with setWrapPolicy().
+
+    The background color is set differently than other widgets, using
+    setPaper(). You specify a brush style which could be a plain color
+    or a complex pixmap.
+
+    Hypertext links are automatically underlined; this can be changed
+    with setLinkUnderline(). The tab stop width is set with
+    setTabStopWidth().
+
+    The zoomIn() and zoomOut() functions can be used to resize the
+    text by increasing (decreasing for zoomOut()) the point size used.
+    Images are not affected by the zoom functions.
+
+    The lines() function returns the number of lines in the text and
+    paragraphs() returns the number of paragraphs. The number of lines
+    within a particular paragraph is returned by linesOfParagraph().
+    The length of the entire text in characters is returned by
+    length().
+
+    You can scroll to an anchor in the text, e.g.
+    \c{<a name="anchor">} with scrollToAnchor(). The find() function
+    can be used to find and select a given string within the text.
+
+    A read-only TQTextEdit provides the same functionality as the
+    (obsolete) TQTextView. (TQTextView is still supplied for
+    compatibility with old code.)
+
+    \section2 Read-only key bindings
+
+    When TQTextEdit is used read-only the key-bindings are limited to
+    navigation, and text may only be selected with the mouse:
+    \table
+    \header \i Keypresses \i Action
+    \row \i UpArrow	\i Move one line up
+    \row \i DownArrow	\i Move one line down
+    \row \i LeftArrow	\i Move one character left
+    \row \i RightArrow	\i Move one character right
+    \row \i PageUp	\i Move one (viewport) page up
+    \row \i PageDown	\i Move one (viewport) page down
+    \row \i Home	\i Move to the beginning of the text
+    \row \i End		\i Move to the end of the text
+    \row \i Shift+Wheel
+	 \i Scroll the page horizontally (the Wheel is the mouse wheel)
+    \row \i Ctrl+Wheel	\i Zoom the text
+    \endtable
+
+    The text edit may be able to provide some meta-information. For
+    example, the documentTitle() function will return the text from
+    within HTML \c{<title>} tags.
+
+    The text displayed in a text edit has a \e context. The context is
+    a path which the text edit's TQMimeSourceFactory uses to resolve
+    the locations of files and images. It is passed to the
+    mimeSourceFactory() when quering data. (See TQTextEdit() and
+    \l{context()}.)
+
+    \target logtextmode
+    \section2 Using TQTextEdit in LogText Mode
+
+    Setting the text format to \c LogText puts the widget in a special
+    mode which is optimized for very large texts. Editing, word wrap,
+    and rich text support are disabled in this mode (the widget is
+    explicitly made read-only). This allows the text to be stored in a
+    different, more memory efficient manner. However, a certain degree
+    of text formatting is supported through the use of formatting tags.
+    A tag is delimited by \c < and \c {>}. The characters \c {<}, \c >
+    and \c & are escaped by using \c {&lt;}, \c {&gt;} and \c {&amp;}.
+    A tag pair consists of a left and a right tag (or open/close tags).
+    Left-tags mark the starting point for formatting, while right-tags
+    mark the ending point. A right-tag always start with a \c / before
+    the tag keyword. For example \c <b> and \c </b> are a tag pair.
+    Tags can be nested, but they have to be closed in the same order as
+    they are opened. For example, \c <b><u></u></b> is valid, while \c
+    <b><u></b></u> will output an error message.
+
+    By using tags it is possible to change the color, bold, italic and
+    underline settings for a piece of text. A color can be specified
+    by using the HTML font tag \c {<font color=colorname>}. The color
+    name can be one of the color names from the X11 color database, or
+    a RGB hex value (e.g \c {#00ff00}). Example of valid color tags:
+    \c {<font color=red>}, \c {<font color="light blue">}, \c {<font
+    color="#223344">}. Bold, italic and underline settings can be
+    specified by the tags \c {<b>}, \c <i> and \c {<u>}. Note that a
+    tag does not necessarily have to be closed. A valid example:
+    \code
+    This is <font color=red>red</font> while <b>this</b> is <font color=blue>blue</font>.
+    <font color=green><font color=yellow>Yellow,</font> and <u>green</u>.
+    \endcode
+
+    Stylesheets can also be used in LogText mode. To create and use a
+    custom tag, you could do the following:
+    \code
+    TQTextEdit * log = new TQTextEdit( this );
+    log->setTextFormat( TQt::LogText );
+    TQStyleSheetItem * item = new TQStyleSheetItem( log->styleSheet(), "mytag" );
+    item->setColor( "red" );
+    item->setFontWeight( TQFont::Bold );
+    item->setFontUnderline( TRUE );
+    log->append( "This is a <mytag>custom tag</mytag>!" );
+    \endcode
+    Note that only the color, bold, underline and italic attributes of
+    a TQStyleSheetItem is used in LogText mode.
+
+    Note that you can use setMaxLogLines() to limit the number of
+    lines the widget can hold in LogText mode.
+
+    There are a few things that you need to be aware of when the
+    widget is in this mode:
+    \list
+    \i Functions that deal with rich text formatting and cursor
+    movement will not work or return anything valid.
+    \i Lines are equivalent to paragraphs.
+    \endlist
+
+    \section1 Using TQTextEdit as an Editor
+
+    All the information about using TQTextEdit as a display widget also
+    applies here.
+
+    The current format's attributes are set with setItalic(),
+    setBold(), setUnderline(), setFamily() (font family),
+    setPointSize(), setColor() and setCurrentFont(). The current
+    paragraph's alignment is set with setAlignment().
+
+    Use setSelection() to select text. The setSelectionAttributes()
+    function is used to indicate how selected text should be
+    displayed. Use hasSelectedText() to find out if any text is
+    selected. The currently selected text's position is available
+    using getSelection() and the selected text itself is returned by
+    selectedText(). The selection can be copied to the clipboard with
+    copy(), or cut to the clipboard with cut(). It can be deleted with
+    removeSelectedText(). The entire text can be selected (or
+    unselected) using selectAll(). TQTextEdit supports multiple
+    selections. Most of the selection functions operate on the default
+    selection, selection 0. If the user presses a non-selecting key,
+    e.g. a cursor key without also holding down Shift, all selections
+    are cleared.
+
+    Set and get the position of the cursor with setCursorPosition()
+    and getCursorPosition() respectively. When the cursor is moved,
+    the signals currentFontChanged(), currentColorChanged() and
+    currentAlignmentChanged() are emitted to reflect the font, color
+    and alignment at the new cursor position.
+
+    If the text changes, the textChanged() signal is emitted, and if
+    the user inserts a new line by pressing Return or Enter,
+    returnPressed() is emitted. The isModified() function will return
+    TRUE if the text has been modified.
+
+    TQTextEdit provides command-based undo and redo. To set the depth
+    of the command history use setUndoDepth() which defaults to 100
+    steps. To undo or redo the last operation call undo() or redo().
+    The signals undoAvailable() and redoAvailable() indicate whether
+    the undo and redo operations can be executed.
+
+    The indent() function is used to reindent a paragraph. It is
+    useful for code editors, for example in \link designer-manual.book
+    TQt Designer\endlink's code editor \e{Ctrl+I} invokes the indent()
+    function.
+
+    \section2 Editing key bindings
+
+    The list of key-bindings which are implemented for editing:
+    \table
+    \header \i Keypresses \i Action
+    \row \i Backspace \i Delete the character to the left of the cursor
+    \row \i Delete \i Delete the character to the right of the cursor
+    \row \i Ctrl+A \i Move the cursor to the beginning of the line
+    \row \i Ctrl+B \i Move the cursor one character left
+    \row \i Ctrl+C \i Copy the marked text to the clipboard (also
+		      Ctrl+Insert under Windows)
+    \row \i Ctrl+D \i Delete the character to the right of the cursor
+    \row \i Ctrl+E \i Move the cursor to the end of the line
+    \row \i Ctrl+F \i Move the cursor one character right
+    \row \i Ctrl+H \i Delete the character to the left of the cursor
+    \row \i Ctrl+K \i Delete to end of line
+    \row \i Ctrl+N \i Move the cursor one line down
+    \row \i Ctrl+P \i Move the cursor one line up
+    \row \i Ctrl+V \i Paste the clipboard text into line edit
+		      (also Shift+Insert under Windows)
+    \row \i Ctrl+X \i Cut the marked text, copy to clipboard
+		      (also Shift+Delete under Windows)
+    \row \i Ctrl+Z \i Undo the last operation
+    \row \i Ctrl+Y \i Redo the last operation
+    \row \i LeftArrow	    \i Move the cursor one character left
+    \row \i Ctrl+LeftArrow  \i Move the cursor one word left
+    \row \i RightArrow	    \i Move the cursor one character right
+    \row \i Ctrl+RightArrow \i Move the cursor one word right
+    \row \i UpArrow	    \i Move the cursor one line up
+    \row \i Ctrl+UpArrow    \i Move the cursor one word up
+    \row \i DownArrow	    \i Move the cursor one line down
+    \row \i Ctrl+Down Arrow \i Move the cursor one word down
+    \row \i PageUp	    \i Move the cursor one page up
+    \row \i PageDown	    \i Move the cursor one page down
+    \row \i Home	    \i Move the cursor to the beginning of the line
+    \row \i Ctrl+Home	    \i Move the cursor to the beginning of the text
+    \row \i End		    \i Move the cursor to the end of the line
+    \row \i Ctrl+End	    \i Move the cursor to the end of the text
+    \row \i Shift+Wheel	    \i Scroll the page horizontally
+			    (the Wheel is the mouse wheel)
+    \row \i Ctrl+Wheel	    \i Zoom the text
+    \endtable
+
+    To select (mark) text hold down the Shift key whilst pressing one
+    of the movement keystrokes, for example, \e{Shift+Right Arrow}
+    will select the character to the right, and \e{Shift+Ctrl+Right
+    Arrow} will select the word to the right, etc.
+
+    By default the text edit widget operates in insert mode so all
+    text that the user enters is inserted into the text edit and any
+    text to the right of the cursor is moved out of the way. The mode
+    can be changed to overwrite, where new text overwrites any text to
+    the right of the cursor, using setOverwriteMode().
+*/
+
+/*!
+    \enum TQTextEdit::AutoFormatting
+
+    \value AutoNone Do not perform any automatic formatting
+    \value AutoBulletList Only automatically format bulletted lists
+    \value AutoAll Apply all available autoformatting
+*/
+
+
+/*!
+    \enum TQTextEdit::KeyboardAction
+
+    This enum is used by doKeyboardAction() to specify which action
+    should be executed:
+
+    \value ActionBackspace  Delete the character to the left of the
+    cursor.
+
+    \value ActionDelete  Delete the character to the right of the
+    cursor.
+
+    \value ActionReturn  Split the paragraph at the cursor position.
+
+    \value ActionKill If the cursor is not at the end of the
+    paragraph, delete the text from the cursor position until the end
+    of the paragraph. If the cursor is at the end of the paragraph,
+    delete the hard line break at the end of the paragraph: this will
+    cause this paragraph to be joined with the following paragraph.
+
+    \value ActionWordBackspace Delete the word to the left of the
+    cursor position.
+
+    \value ActionWordDelete Delete the word to the right of the
+    cursor position
+
+*/
+
+/*!
+    \enum TQTextEdit::VerticalAlignment
+
+    This enum is used to set the vertical alignment of the text.
+
+    \value AlignNormal Normal alignment
+    \value AlignSuperScript Superscript
+    \value AlignSubScript Subscript
+*/
+
+/*!
+    \enum TQTextEdit::TextInsertionFlags
+
+    \internal
+
+    \value RedoIndentation
+    \value CheckNewLines
+    \value RemoveSelected
+*/
+
+
+/*!
+    \fn void TQTextEdit::copyAvailable(bool yes)
+
+    This signal is emitted when text is selected or de-selected in the
+    text edit.
+
+    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 TQTextEdit::textChanged()
+
+    This signal is emitted whenever the text in the text edit changes.
+
+    \sa setText() append()
+*/
+
+/*!
+    \fn void TQTextEdit::selectionChanged()
+
+    This signal is emitted whenever the selection changes.
+
+    \sa setSelection() copyAvailable()
+*/
+
+/*!  \fn TQTextDocument *TQTextEdit::document() const
+
+    \internal
+
+  This function returns the TQTextDocument which is used by the text
+  edit.
+*/
+
+/*!  \fn void TQTextEdit::setDocument( TQTextDocument *doc )
+
+    \internal
+
+  This function sets the TQTextDocument 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
+  TQTextDocument 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 TQTextEdit::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 viewport page up
+
+    \value MovePgDown  Moves the cursor one viewport page down
+*/
+
+/*!
+  \enum TQt::AnchorAttribute
+
+  An anchor has one or more of the following attributes:
+
+  \value AnchorName the name attribute of the anchor. This attribute is
+  used when scrolling to an anchor in the document.
+
+  \value AnchorHref the href attribute of the anchor. This attribute is
+  used when a link is clicked to determine what content to load.
+*/
+
+/*!
+    \property TQTextEdit::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 TQTextEdit::setCurrentFont( const TQFont &f )
+
+    Sets the font of the current format to \a f.
+
+    If the widget is in \c LogText mode this function will do
+    nothing. Use setFont() instead.
+
+    \sa currentFont() setPointSize() setFamily()
+*/
+
+/*!
+    \property TQTextEdit::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 TQTextEdit::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 TQTextEdit::modificationChanged( bool m )
+
+    This signal is emitted when the modification status of the
+    document has changed. If \a m is TRUE, the document was modified,
+    otherwise the modification state has been reset to unmodified.
+
+    \sa modified
+*/
+
+/*!
+    \fn void TQTextEdit::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 TQTextEdit::currentFontChanged( const TQFont &f )
+
+    This signal is emitted if the font of the current format has
+    changed.
+
+    The new font is \a f.
+
+    \sa setCurrentFont()
+*/
+
+/*!
+    \fn void TQTextEdit::currentColorChanged( const TQColor &c )
+
+    This signal is emitted if the color of the current format has
+    changed.
+
+    The new color is \a c.
+
+    \sa setColor()
+*/
+
+/*!
+    \fn void TQTextEdit::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 TQTextEdit::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 TQTextEdit::cursorPositionChanged( TQTextCursor *c )
+
+    \internal
+*/
+
+/*!
+    \fn void TQTextEdit::cursorPositionChanged( int para, int pos )
+
+    This signal is emitted if the position of the cursor has changed.
+    \a para contains the paragraph index and \a pos contains the
+    character position within the paragraph.
+
+    \sa setCursorPosition()
+*/
+
+/*!
+    \fn void TQTextEdit::clicked( int para, int pos )
+
+    This signal is emitted when the mouse is clicked on the paragraph
+    \a para at character position \a pos.
+
+    \sa doubleClicked()
+*/
+
+/*! \fn void TQTextEdit::doubleClicked( int para, int pos )
+
+  This signal is emitted when the mouse is double-clicked on the
+  paragraph \a para at character position \a pos.
+
+  \sa clicked()
+*/
+
+
+/*!
+    \fn void TQTextEdit::returnPressed()
+
+    This signal is emitted if the user pressed the Return or the Enter
+    key.
+*/
+
+/*!
+    \fn TQTextCursor *TQTextEdit::textCursor() const
+
+    Returns the text edit's text cursor.
+
+    \warning TQTextCursor is not in the public API, but in special
+    circumstances you might wish to use it.
+*/
+
+/*!
+    Constructs an empty TQTextEdit called \a name, with parent \a
+    parent.
+*/
+
+TQTextEdit::TQTextEdit( TQWidget *parent, const char *name )
+    : TQScrollView( parent, name, WStaticContents | WNoAutoErase ),
+      doc( new TQTextDocument( 0 ) ), undoRedoInfo( doc )
+{
+    init();
+}
+
+/*!
+    Constructs a TQTextEdit called \a name, with parent \a parent. The
+    text edit will display the text \a text using context \a context.
+
+    The \a context is a path which the text edit's TQMimeSourceFactory
+    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
+    TQMimeSourceFactory 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
+    TQMimeSourceFactory 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".
+*/
+
+TQTextEdit::TQTextEdit( const TQString& text, const TQString& context,
+		      TQWidget *parent, const char *name)
+    : TQScrollView( parent, name, WStaticContents | WNoAutoErase ),
+      doc( new TQTextDocument( 0 ) ), undoRedoInfo( doc )
+{
+    init();
+    setText( text, context );
+}
+
+/*!
+    \reimp
+*/
+
+TQTextEdit::~TQTextEdit()
+{
+    delete undoRedoInfo.d;
+    undoRedoInfo.d = 0;
+    delete cursor;
+    delete doc;
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	delete d->od;
+#endif
+    delete d;
+}
+
+void TQTextEdit::init()
+{
+    d = new TQTextEditPrivate;
+    doc->formatCollection()->setPaintDevice( this );
+    undoEnabled = TRUE;
+    readonly = TRUE;
+    setReadOnly( FALSE );
+    setFrameStyle( LineEditPanel | Sunken );
+    connect( doc, SIGNAL( minimumWidthChanged(int) ),
+	     this, SLOT( documentWidthChanged(int) ) );
+
+    mousePressed = FALSE;
+    inDoubleClick = FALSE;
+    modified = FALSE;
+    onLink = TQString::null;
+    d->onName = TQString::null;
+    overWrite = FALSE;
+    wrapMode = WidgetWidth;
+    wrapWidth = -1;
+    wPolicy = AtWhiteSpace;
+    inDnD = FALSE;
+    doc->setFormatter( new TQTextFormatterBreakWords );
+    doc->formatCollection()->defaultFormat()->setFont( TQScrollView::font() );
+    doc->formatCollection()->defaultFormat()->setColor( colorGroup().color( TQColorGroup::Text ) );
+    currentFormat = doc->formatCollection()->defaultFormat();
+    currentAlignment = TQt::AlignAuto;
+
+    setBackgroundMode( PaletteBase );
+    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 TQTextCursor( doc );
+
+    formatTimer = new TQTimer( this );
+    connect( formatTimer, SIGNAL( timeout() ),
+	     this, SLOT( formatMore() ) );
+    lastFormatted = doc->firstParagraph();
+
+    scrollTimer = new TQTimer( this );
+    connect( scrollTimer, SIGNAL( timeout() ),
+	     this, SLOT( autoScrollTimerDone() ) );
+
+    interval = 0;
+    changeIntervalTimer = new TQTimer( this );
+    connect( changeIntervalTimer, SIGNAL( timeout() ),
+	     this, SLOT( doChangeInterval() ) );
+
+    cursorVisible = TRUE;
+    blinkTimer = new TQTimer( this );
+    connect( blinkTimer, SIGNAL( timeout() ),
+	     this, SLOT( blinkCursor() ) );
+
+#ifndef QT_NO_DRAGANDDROP
+    dragStartTimer = new TQTimer( this );
+    connect( dragStartTimer, SIGNAL( timeout() ),
+	     this, SLOT( startDrag() ) );
+#endif
+
+    d->trippleClickTimer = new TQTimer( this );
+
+    formatMore();
+
+    blinkCursorVisible = FALSE;
+
+    viewport()->setFocusProxy( this );
+    viewport()->setFocusPolicy( WheelFocus );
+    setInputMethodEnabled( TRUE );
+    viewport()->installEventFilter( this );
+    connect( this, SIGNAL(horizontalSliderReleased()), this, SLOT(sliderReleased()) );
+    connect( this, SIGNAL(verticalSliderReleased()), this, SLOT(sliderReleased()) );
+    installEventFilter( this );
+}
+
+void TQTextEdit::paintDocument( bool drawAll, TQPainter *p, int cx, int cy, int cw, int ch )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    Q_ASSERT( !d->optimMode );
+    if ( d->optimMode )
+	return;
+#endif
+
+    bool drawCur = hasFocus() || viewport()->hasFocus();
+    if (( hasSelectedText() && !style().styleHint( TQStyle::SH_BlinkCursorWhenTextSelected ) ) ||
+	isReadOnly() || !cursorVisible || doc->hasSelection( TQTextDocument::IMSelectionText ))
+	drawCur = FALSE;
+    TQColorGroup g = colorGroup();
+    const TQColorGroup::ColorRole backRole = TQPalette::backgroundRoleFromMode(backgroundMode());
+    if ( doc->paper() )
+	g.setBrush( backRole, *doc->paper() );
+
+    if ( contentsY() < doc->y() ) {
+	p->fillRect( contentsX(), contentsY(), visibleWidth(), doc->y(),
+		     g.brush( backRole ) );
+    }
+    if ( drawAll && doc->width() - contentsX() < cx + cw ) {
+	p->fillRect( doc->width() - contentsX(), cy, cx + cw - doc->width() + contentsX(), ch,
+		     g.brush( backRole ) );
+    }
+
+    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( backRole ) );
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::drawContents( TQPainter *p, int cx, int cy, int cw, int ch )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimDrawContents( p, cx, cy, cw, ch );
+	return;
+    }
+#endif
+    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;
+	}
+    }
+
+    // This invocation is retquired to follow dragging of active window
+    // by the showed candidate window.
+    updateMicroFocusHint();
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::drawContents( TQPainter *p )
+{
+    if ( horizontalScrollBar()->isVisible() &&
+	 verticalScrollBar()->isVisible() ) {
+	const TQRect verticalRect = verticalScrollBar()->geometry();
+	const TQRect horizontalRect = horizontalScrollBar()->geometry();
+
+	TQRect cornerRect;
+	cornerRect.setTop( verticalRect.bottom() );
+	cornerRect.setBottom( horizontalRect.bottom() );
+	cornerRect.setLeft( verticalRect.left() );
+	cornerRect.setRight( verticalRect.right() );
+
+	p->fillRect( cornerRect, colorGroup().background() );
+    }
+}
+
+/*!
+    \reimp
+*/
+
+bool TQTextEdit::event( TQEvent *e )
+{
+    if ( e->type() == TQEvent::AccelOverride && !isReadOnly() ) {
+	TQKeyEvent* ke = (TQKeyEvent*) e;
+	switch(ke->state()) {
+	case NoButton:
+	case Keypad:
+	case ShiftButton:
+	    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:
+		case Key_Left:
+		case Key_Right:
+		    ke->accept();
+		default:
+		    break;
+		}
+	    }
+	    break;
+
+	case ControlButton:
+	case ControlButton|ShiftButton:
+	case ControlButton|Keypad:
+	case ControlButton|ShiftButton|Keypad:
+	    switch ( ke->key() ) {
+	    case Key_Tab:
+	    case Key_Backtab:
+		ke->ignore();
+		break;
+// 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:
+#if defined (Q_WS_WIN)
+	    case Key_Insert:
+	    case Key_Delete:
+#endif
+		ke->accept();
+	    default:
+		break;
+	    }
+	    break;
+
+	default:
+	    switch ( ke->key() ) {
+#if defined (Q_WS_WIN)
+	    case Key_Insert:
+		ke->accept();
+#endif
+	    default:
+		break;
+	    }
+	    break;
+	}
+    }
+
+    if ( e->type() == TQEvent::Show ) {
+	if (
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+	     !d->optimMode &&
+#endif
+	     d->ensureCursorVisibleInShowEvent  ) {
+	    ensureCursorVisible();
+	    d->ensureCursorVisibleInShowEvent = FALSE;
+	}
+	if ( !d->scrollToAnchor.isEmpty() ) {
+	    scrollToAnchor( d->scrollToAnchor );
+	    d->scrollToAnchor = TQString::null;
+	}
+    }
+    return TQWidget::event( e );
+}
+
+/*!
+    Processes the key event, \a e. By default key events are used to
+    provide keyboard navigation and text editing.
+*/
+
+void TQTextEdit::keyPressEvent( TQKeyEvent *e )
+{
+    changeIntervalTimer->stop();
+    interval = 10;
+    bool unknownKey = FALSE;
+    if ( isReadOnly() ) {
+	if ( !handleReadOnlyKeyEvent( e ) )
+	    TQScrollView::keyPressEvent( e );
+	changeIntervalTimer->start( 100, TRUE );
+	return;
+    }
+
+
+    bool selChanged = FALSE;
+    for ( int i = 1; i < doc->numSelections(); ++i ) // start with 1 as we don't want to remove the Standard-Selection
+	selChanged = doc->removeSelection( i ) || selChanged;
+
+    if ( selChanged ) {
+	cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
+	repaintChanged();
+    }
+
+    bool clearUndoRedoInfo = TRUE;
+
+
+    switch ( e->key() ) {
+    case Key_Left:
+    case Key_Right: {
+	// a bit hacky, but can't change this without introducing new enum values for move and keeping the
+	// correct semantics and movement for BiDi and non BiDi text.
+	CursorAction a;
+	if ( cursor->paragraph()->string()->isRightToLeft() == (e->key() == Key_Right) )
+	    a = e->state() & ControlButton ? MoveWordBackward : MoveBackward;
+	else
+	    a = e->state() & ControlButton ? MoveWordForward : MoveForward;
+	moveCursor( a, e->state() & ShiftButton );
+	break;
+    }
+    case Key_Up:
+	moveCursor( e->state() & ControlButton ? MovePgUp : MoveUp, e->state() & ShiftButton );
+	break;
+    case Key_Down:
+	moveCursor( e->state() & ControlButton ? MovePgDown : MoveDown, e->state() & ShiftButton );
+	break;
+    case Key_Home:
+	moveCursor( e->state() & ControlButton ? MoveHome : MoveLineStart, e->state() & ShiftButton );
+	break;
+    case Key_End:
+	moveCursor( e->state() & ControlButton ? MoveEnd : MoveLineEnd, e->state() & ShiftButton );
+	break;
+    case Key_Prior:
+	moveCursor( MovePgUp, e->state() & ShiftButton );
+	break;
+    case Key_Next:
+	moveCursor( MovePgDown, e->state() & ShiftButton );
+	break;
+    case Key_Return: case Key_Enter:
+	if ( doc->hasSelection( TQTextDocument::Standard, FALSE ) )
+	    removeSelectedText();
+	if ( textFormat() == TQt::RichText && ( e->state() & ControlButton ) ) {
+	    // Ctrl-Enter inserts a line break in rich text mode
+	    insert( TQString( TQChar( 0x2028) ), TRUE, FALSE );
+	} else {
+#ifndef QT_NO_CURSOR
+	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+	    clearUndoRedoInfo = FALSE;
+	    doKeyboardAction( ActionReturn );
+	    emit returnPressed();
+	}
+	break;
+    case Key_Delete:
+#if defined (Q_WS_WIN)
+	if ( e->state() & ShiftButton ) {
+	    cut();
+	    break;
+	} else
+#endif
+        if ( doc->hasSelection( TQTextDocument::Standard, TRUE ) ) {
+	    removeSelectedText();
+	    break;
+	}
+	doKeyboardAction( e->state() & ControlButton ? ActionWordDelete
+			  : ActionDelete );
+	clearUndoRedoInfo = FALSE;
+
+	break;
+    case Key_Insert:
+	if ( e->state() & ShiftButton )
+	    paste();
+#if defined (Q_WS_WIN)
+	else if ( e->state() & ControlButton )
+	    copy();
+#endif
+	else
+	    setOverwriteMode( !isOverwriteMode() );
+	break;
+    case Key_Backspace:
+#if defined (Q_WS_WIN)
+	if ( e->state() & AltButton ) {
+	    if (e->state() & ControlButton ) {
+		break;
+	    } else if ( e->state() & ShiftButton ) {
+		redo();
+		break;
+	    } else {
+		undo();
+		break;
+	    }
+	} else
+#endif
+	if ( doc->hasSelection( TQTextDocument::Standard, TRUE ) ) {
+	    removeSelectedText();
+	    break;
+	}
+
+	doKeyboardAction( e->state() & ControlButton ? ActionWordBackspace
+			  : ActionBackspace );
+	clearUndoRedoInfo = FALSE;
+	break;
+    case Key_F16: // Copy key on Sun keyboards
+	copy();
+	break;
+    case Key_F18:  // Paste key on Sun keyboards
+	paste();
+	break;
+    case Key_F20:  // Cut key on Sun keyboards
+	cut();
+	break;
+    case Key_Direction_L:
+	if ( doc->textFormat() == TQt::PlainText ) {
+	    // change the whole doc
+	    TQTextParagraph *p = doc->firstParagraph();
+	    while ( p ) {
+		p->setDirection( TQChar::DirL );
+		p->setAlignment( TQt::AlignLeft );
+		p->invalidate( 0 );
+		p = p->next();
+	    }
+	} else {
+	    if ( !cursor->paragraph() || cursor->paragraph()->direction() == TQChar::DirL )
+		return;
+	    cursor->paragraph()->setDirection( TQChar::DirL );
+	    if ( cursor->paragraph()->length() <= 1&&
+		 ( (cursor->paragraph()->alignment() & (TQt::AlignLeft | TQt::AlignRight) ) != 0 ) )
+		setAlignment( TQt::AlignLeft );
+	}
+	repaintChanged();
+	break;
+    case Key_Direction_R:
+	if ( doc->textFormat() == TQt::PlainText ) {
+	    // change the whole doc
+	    TQTextParagraph *p = doc->firstParagraph();
+	    while ( p ) {
+		p->setDirection( TQChar::DirR );
+		p->setAlignment( TQt::AlignRight );
+		p->invalidate( 0 );
+		p = p->next();
+	    }
+	} else {
+	    if ( !cursor->paragraph() || cursor->paragraph()->direction() == TQChar::DirR )
+		return;
+	    cursor->paragraph()->setDirection( TQChar::DirR );
+	    if ( cursor->paragraph()->length() <= 1&&
+		 ( (cursor->paragraph()->alignment() & (TQt::AlignLeft | TQt::AlignRight) ) != 0 ) )
+		setAlignment( TQt::AlignRight );
+	}
+	repaintChanged();
+	break;
+    default: {
+	    if ( e->text().length() &&
+		( !( e->state() & ControlButton ) &&
+#ifndef Q_OS_MACX
+		  !( e->state() & AltButton ) &&
+#endif
+		  !( e->state() & MetaButton ) ||
+		 ( ( (e->state()&ControlButton) | AltButton ) == (ControlButton|AltButton) ) ) &&
+		 ( !e->ascii() || e->ascii() >= 32 || e->text() == "\t" ) ) {
+		clearUndoRedoInfo = FALSE;
+		if ( e->key() == Key_Tab ) {
+		    if ( d->tabChangesFocus ) {
+			e->ignore();
+			break;
+		    }
+		    if ( textFormat() == TQt::RichText && cursor->index() == 0
+			 && ( cursor->paragraph()->isListItem() || cursor->paragraph()->listDepth() ) ) {
+			clearUndoRedo();
+			undoRedoInfo.type = UndoRedoInfo::Style;
+			undoRedoInfo.id = cursor->paragraph()->paragId();
+			undoRedoInfo.eid = undoRedoInfo.id;
+			undoRedoInfo.styleInformation = TQTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
+			cursor->paragraph()->setListDepth( cursor->paragraph()->listDepth() +1 );
+			clearUndoRedo();
+			drawCursor( FALSE );
+			repaintChanged();
+			drawCursor( TRUE );
+			break;
+		    }
+		} else if ( e->key() == Key_BackTab ) {
+		    if ( d->tabChangesFocus ) {
+			e->ignore();
+			break;
+		    }
+		}
+
+		if ( ( autoFormatting() & AutoBulletList ) &&
+		     textFormat() == TQt::RichText && cursor->index() == 0
+		     && !cursor->paragraph()->isListItem()
+		     && ( e->text()[0] == '-' || e->text()[0] == '*' ) ) {
+			clearUndoRedo();
+			undoRedoInfo.type = UndoRedoInfo::Style;
+			undoRedoInfo.id = cursor->paragraph()->paragId();
+			undoRedoInfo.eid = undoRedoInfo.id;
+			undoRedoInfo.styleInformation = TQTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
+			setParagType( TQStyleSheetItem::DisplayListItem, TQStyleSheetItem::ListDisc );
+			clearUndoRedo();
+			drawCursor( FALSE );
+			repaintChanged();
+			drawCursor( TRUE );
+			break;
+		}
+		if (overWrite && !cursor->atParagEnd() && !doc->hasSelection(TQTextDocument::Standard)) {
+                    doKeyboardAction(ActionDelete);
+                    clearUndoRedoInfo = FALSE;
+                }
+		TQString t = e->text();
+#ifdef Q_WS_X11
+		extern bool qt_hebrew_keyboard_hack;
+		if ( qt_hebrew_keyboard_hack ) {
+		    // the X11 keyboard layout is broken and does not reverse
+		    // braces correctly. This is a hack to get halfway correct
+		    // behaviour
+		    TQTextParagraph *p = cursor->paragraph();
+		    if ( p && p->string() && p->string()->isRightToLeft() ) {
+			TQChar *c = (TQChar *)t.unicode();
+			int l = t.length();
+			while( l-- ) {
+			    if ( c->mirrored() )
+				*c = c->mirroredChar();
+			    c++;
+			}
+		    }
+		}
+#endif
+		insert( t, TRUE, FALSE );
+		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:
+		    if ( !d->tabChangesFocus )
+			indent();
+		    break;
+		case Key_A:
+#if defined(Q_WS_X11)
+		    moveCursor( MoveLineStart, e->state() & ShiftButton );
+#else
+		    selectAll( TRUE );
+#endif
+		    break;
+		case Key_B:
+		    moveCursor( MoveBackward, e->state() & ShiftButton );
+		    break;
+		case Key_F:
+		    moveCursor( MoveForward, e->state() & ShiftButton );
+		    break;
+		case Key_D:
+		    if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+			removeSelectedText();
+			break;
+		    }
+		    doKeyboardAction( ActionDelete );
+		    clearUndoRedoInfo = FALSE;
+		    break;
+		case Key_H:
+		    if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+			removeSelectedText();
+			break;
+		    }
+		    if ( !cursor->paragraph()->prev() &&
+			 cursor->atParagStart() )
+			break;
+
+		    doKeyboardAction( ActionBackspace );
+		    clearUndoRedoInfo = FALSE;
+		    break;
+		case Key_E:
+		    moveCursor( MoveLineEnd, e->state() & ShiftButton );
+		    break;
+		case Key_N:
+		    moveCursor( MoveDown, e->state() & ShiftButton );
+		    break;
+		case Key_P:
+		    moveCursor( MoveUp, e->state() & ShiftButton );
+		    break;
+		case Key_Z:
+		    if(e->state() & ShiftButton)
+			redo();
+		    else
+			undo();
+		    break;
+		case Key_Y:
+		    redo();
+		    break;
+		case Key_K:
+		    doKeyboardAction( ActionKill );
+		    break;
+#if defined(Q_WS_WIN)
+		case Key_Insert:
+		    copy();
+		    break;
+		case Key_Delete:
+		    del();
+		    break;
+#endif
+		default:
+		    unknownKey = FALSE;
+		    break;
+		}
+	    } else {
+		unknownKey = TRUE;
+	    }
+        }
+    }
+
+    emit cursorPositionChanged( cursor );
+    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
+    if ( clearUndoRedoInfo )
+	clearUndoRedo();
+    changeIntervalTimer->start( 100, TRUE );
+    if ( unknownKey )
+	e->ignore();
+}
+
+/*!
+  This function is not intended as polymorphic usage. Just a shared code
+  fragment that calls TQWidget::sendMouseEventToInputContext() easily for this
+  class.
+ */
+bool TQTextEdit::sendMouseEventToInputContext( TQMouseEvent *e )
+{
+#ifndef QT_NO_IM
+    if ( d->composeMode() ) {
+	TQTextCursor c( doc );
+	if ( c.place( e->pos(), doc->firstParagraph(), FALSE, FALSE, FALSE ) ) {
+	    int mousePos = c.index() - d->preeditStart;
+	    if ( cursor->globalY() == c.globalY() &&
+		 mousePos >= 0 && mousePos < d->preeditLength ) {
+		TQWidget::sendMouseEventToInputContext( mousePos, e->type(),
+						       e->button(), e->state() );
+	    }
+	} else if ( e->type() != TQEvent::MouseMove ) {
+	    // send button events on out of preedit
+	    TQWidget::sendMouseEventToInputContext( -1, e->type(),
+						   e->button(), e->state() );
+	}
+	return TRUE;
+    }
+#endif
+    return FALSE;
+}
+
+
+/*!
+    \reimp
+*/
+void TQTextEdit::imStartEvent( TQIMEvent *e )
+{
+    if ( isReadOnly() ) {
+	e->ignore();
+	return;
+    }
+
+    if ( hasSelectedText() )
+	removeSelectedText();
+    d->preeditStart = cursor->index();
+    clearUndoRedo();
+    undoRedoInfo.type = UndoRedoInfo::IME;
+}
+
+/*!
+    \reimp
+*/
+void TQTextEdit::imComposeEvent( TQIMEvent *e )
+{
+    if ( isReadOnly() ) {
+	e->ignore();
+	return;
+    }
+
+    doc->removeSelection( TQTextDocument::IMCompositionText );
+    doc->removeSelection( TQTextDocument::IMSelectionText );
+
+    if ( d->composeMode() && cursor->paragraph() )
+	cursor->paragraph()->remove( d->preeditStart, d->preeditLength );
+    cursor->setIndex( d->preeditStart );
+    d->preeditLength = e->text().length();
+
+    int sellen = e->selectionLength();
+    uint insertionFlags = CheckNewLines | RemoveSelected | AsIMCompositionText;
+    if ( sellen > 0 ) {
+      insertionFlags |= WithIMSelection;
+    }
+    insert( e->text(), insertionFlags );
+    // insert can trigger an imEnd event as it emits a textChanged signal, so better
+    // be careful
+    if(d->preeditStart != -1) {
+	cursor->setIndex( d->preeditStart + d->preeditLength );
+	TQTextCursor c = *cursor;
+	cursor->setIndex( d->preeditStart );
+	doc->setSelectionStart( TQTextDocument::IMCompositionText, *cursor );
+	doc->setSelectionEnd( TQTextDocument::IMCompositionText, c );
+
+	cursor->setIndex( d->preeditStart + e->cursorPos() );
+
+	if ( sellen > 0 ) {
+	    cursor->setIndex( d->preeditStart + e->cursorPos() + sellen );
+	    c = *cursor;
+	    cursor->setIndex( d->preeditStart + e->cursorPos() );
+	    doc->setSelectionStart( TQTextDocument::IMSelectionText, *cursor );
+	    doc->setSelectionEnd( TQTextDocument::IMSelectionText, c );
+#if 0
+ 	    // Disabled for Asian input method that shows candidate
+ 	    // window. This behavior is same as TQt/E 2.3.7 which supports
+ 	    // Asian input methods. Asian input methods need start point
+ 	    // of IM selection text to place candidate window as adjacent
+ 	    // to the selection text.
+	    cursor->setIndex( d->preeditStart + d->preeditLength );
+#endif
+	}
+    }
+
+    updateMicroFocusHint();
+    repaintChanged();
+}
+
+/*!
+    \reimp
+*/
+void TQTextEdit::imEndEvent( TQIMEvent *e )
+{
+    if ( isReadOnly() ) {
+	e->ignore();
+	return;
+    }
+
+    doc->removeSelection( TQTextDocument::IMCompositionText );
+    doc->removeSelection( TQTextDocument::IMSelectionText );
+
+    if (undoRedoInfo.type == UndoRedoInfo::IME)
+        undoRedoInfo.type = UndoRedoInfo::Invalid;
+
+    if ( d->composeMode() && cursor->paragraph() )
+	cursor->paragraph()->remove( d->preeditStart, d->preeditLength );
+    if ( d->preeditStart >= 0 ) {
+        cursor->setIndex( d->preeditStart );
+	//TODO: TQt 4 we should use the new virtual insert function
+	insert( e->text(), FALSE );
+    }
+    d->preeditStart = d->preeditLength = -1;
+
+    repaintChanged();
+}
+
+
+static bool qtextedit_ignore_readonly = FALSE;
+
+/*!
+    Executes keyboard action \a action. This is normally called by a
+    key event handler.
+*/
+
+void TQTextEdit::doKeyboardAction( KeyboardAction action )
+{
+    if ( isReadOnly() && !qtextedit_ignore_readonly )
+	return;
+
+    if ( cursor->nestedDepth() != 0 ) // #### for 3.0, disable editing of tables as this is not advanced enough
+	return;
+
+    lastFormatted = cursor->paragraph();
+    drawCursor( FALSE );
+    bool doUpdateCurrentFormat = TRUE;
+
+    switch ( action ) {
+    case ActionWordDelete:
+    case ActionDelete:
+	if ( action == ActionDelete && !cursor->atParagEnd() ) {
+	    if ( undoEnabled ) {
+		checkUndoRedoInfo( UndoRedoInfo::Delete );
+		if ( !undoRedoInfo.valid() ) {
+		    undoRedoInfo.id = cursor->paragraph()->paragId();
+		    undoRedoInfo.index = cursor->index();
+		    undoRedoInfo.d->text = TQString::null;
+		}
+		int idx = cursor->index();
+		do {
+		    undoRedoInfo.d->text.insert( undoRedoInfo.d->text.length(), cursor->paragraph()->at( idx++ ), TRUE );
+		} while ( !cursor->paragraph()->string()->validCursorPosition( idx ) );
+	    }
+	    cursor->remove();
+	} else {
+	    clearUndoRedo();
+	    doc->setSelectionStart( TQTextDocument::Temp, *cursor );
+	    if ( action == ActionWordDelete && !cursor->atParagEnd() ) {
+		cursor->gotoNextWord();
+	    } else {
+		cursor->gotoNextLetter();
+	    }
+	    doc->setSelectionEnd( TQTextDocument::Temp, *cursor );
+	    removeSelectedText( TQTextDocument::Temp );
+	}
+	break;
+    case ActionWordBackspace:
+    case ActionBackspace:
+	if ( textFormat() == TQt::RichText
+	     && (cursor->paragraph()->isListItem()
+		 || cursor->paragraph()->listDepth() )
+	     && cursor->index() == 0 ) {
+	    if ( undoEnabled ) {
+		clearUndoRedo();
+		undoRedoInfo.type = UndoRedoInfo::Style;
+		undoRedoInfo.id = cursor->paragraph()->paragId();
+		undoRedoInfo.eid = undoRedoInfo.id;
+		undoRedoInfo.styleInformation = TQTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
+	    }
+	    int ldepth = cursor->paragraph()->listDepth();
+	    if ( cursor->paragraph()->isListItem() && ldepth == 1 ) {
+		cursor->paragraph()->setListItem( FALSE );
+	    } else if ( TQMAX( ldepth, 1 ) == 1 ) {
+		cursor->paragraph()->setListItem( FALSE );
+		cursor->paragraph()->setListDepth( 0 );
+	    } else {
+		cursor->paragraph()->setListDepth( ldepth - 1 );
+	    }
+	    clearUndoRedo();
+	    lastFormatted = cursor->paragraph();
+	    repaintChanged();
+	    drawCursor( TRUE );
+	    return;
+	}
+
+	if ( action == ActionBackspace && !cursor->atParagStart() ) {
+	    if ( undoEnabled ) {
+		checkUndoRedoInfo( UndoRedoInfo::Delete );
+		if ( !undoRedoInfo.valid() ) {
+		    undoRedoInfo.id = cursor->paragraph()->paragId();
+		    undoRedoInfo.index = cursor->index();
+		    undoRedoInfo.d->text = TQString::null;
+		}
+		undoRedoInfo.d->text.insert( 0, cursor->paragraph()->at( cursor->index()-1 ), TRUE );
+		undoRedoInfo.index = cursor->index()-1;
+	    }
+	    cursor->removePreviousChar();
+	    lastFormatted = cursor->paragraph();
+	} else if ( cursor->paragraph()->prev()
+		    || (action == ActionWordBackspace
+			&& !cursor->atParagStart()) ) {
+	    clearUndoRedo();
+	    doc->setSelectionStart( TQTextDocument::Temp, *cursor );
+	    if ( action == ActionWordBackspace && !cursor->atParagStart() ) {
+		cursor->gotoPreviousWord();
+	    } else {
+		cursor->gotoPreviousLetter();
+	    }
+	    doc->setSelectionEnd( TQTextDocument::Temp, *cursor );
+	    removeSelectedText( TQTextDocument::Temp );
+	}
+	break;
+    case ActionReturn:
+	if ( undoEnabled ) {
+	    checkUndoRedoInfo( UndoRedoInfo::Return );
+	    if ( !undoRedoInfo.valid() ) {
+		undoRedoInfo.id = cursor->paragraph()->paragId();
+		undoRedoInfo.index = cursor->index();
+		undoRedoInfo.d->text = TQString::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( TQTextDocument::Temp, *cursor );
+	if ( cursor->atParagEnd() )
+	    cursor->gotoNextLetter();
+	else
+	    cursor->setIndex( cursor->paragraph()->length() - 1 );
+	doc->setSelectionEnd( TQTextDocument::Temp, *cursor );
+	removeSelectedText( TQTextDocument::Temp );
+	break;
+    }
+
+    formatMore();
+    repaintChanged();
+    ensureCursorVisible();
+    drawCursor( TRUE );
+    updateMicroFocusHint();
+    if ( doUpdateCurrentFormat )
+	updateCurrentFormat();
+    setModified();
+    emit textChanged();
+}
+
+void TQTextEdit::readFormats( TQTextCursor &c1, TQTextCursor &c2, TQTextString &text, bool fillStyles )
+{
+#ifndef QT_NO_DATASTREAM
+    TQDataStream styleStream( undoRedoInfo.styleInformation, IO_WriteOnly );
+#endif
+    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 );
+#ifndef QT_NO_DATASTREAM
+	if ( fillStyles ) {
+	    styleStream << (int) 1;
+	    c1.paragraph()->writeStyleInformation( styleStream );
+	}
+#endif
+    } 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++;
+
+        if (c1.paragraph()->next() != c2.paragraph()) {
+            num += text.appendParagraphs(c1.paragraph()->next(), c2.paragraph());
+            lastIndex = text.length();
+        }
+
+	for ( i = 0; i < c2.index(); ++i )
+	    text.insert( i + lastIndex, c2.paragraph()->at( i ), TRUE );
+#ifndef QT_NO_DATASTREAM
+	if ( fillStyles ) {
+	    styleStream << num;
+	    for ( TQTextParagraph *p = c1.paragraph(); --num >= 0; p = p->next() )
+		p->writeStyleInformation( styleStream );
+	}
+#endif
+    }
+}
+
+/*!
+    Removes the selection \a selNum (by default 0). This does not
+    remove the selected text.
+
+    \sa removeSelectedText()
+*/
+
+void TQTextEdit::removeSelection( int selNum )
+{
+    doc->removeSelection( selNum );
+    repaintChanged();
+}
+
+/*!
+    Deletes the text of selection \a selNum (by default, the default
+    selection, 0). If there is no selected text nothing happens.
+
+    \sa selectedText removeSelection()
+*/
+
+void TQTextEdit::removeSelectedText( int selNum )
+{
+    if(selNum != 0)
+        resetInputContext();
+
+    TQTextCursor c1 = doc->selectionStartCursor( selNum );
+    c1.restoreState();
+    TQTextCursor c2 = doc->selectionEndCursor( selNum );
+    c2.restoreState();
+
+    // ### no support for editing tables yet, plus security for broken selections
+    if ( c1.nestedDepth() || c2.nestedDepth() )
+	return;
+
+    for ( int i = 0; i < (int)doc->numSelections(); ++i ) {
+	if ( i == selNum )
+	    continue;
+	doc->removeSelection( i );
+    }
+
+    drawCursor( FALSE );
+    if ( undoEnabled ) {
+	checkUndoRedoInfo( UndoRedoInfo::RemoveSelected );
+	if ( !undoRedoInfo.valid() ) {
+	    doc->selectionStart( selNum, undoRedoInfo.id, undoRedoInfo.index );
+	    undoRedoInfo.d->text = TQString::null;
+	}
+	readFormats( c1, c2, undoRedoInfo.d->text, TRUE );
+    }
+
+    doc->removeSelectedText( selNum, cursor );
+    if ( cursor->isValid() ) {
+	lastFormatted = 0; // make sync a noop
+	ensureCursorVisible();
+	lastFormatted = cursor->paragraph();
+	formatMore();
+	repaintContents( FALSE );
+	ensureCursorVisible();
+	drawCursor( TRUE );
+	clearUndoRedo();
+#if defined(Q_WS_WIN)
+	// there seems to be a problem with repainting or erasing the area
+	// of the scrollview which is not the contents on windows
+	if ( contentsHeight() < visibleHeight() )
+	    viewport()->repaint( 0, contentsHeight(), visibleWidth(), visibleHeight() - contentsHeight(), TRUE );
+#endif
+#ifndef QT_NO_CURSOR
+	viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+	updateMicroFocusHint();
+    } else {
+	delete cursor;
+	cursor = new TQTextCursor( doc );
+	drawCursor( TRUE );
+	repaintContents( TRUE );
+    }
+    setModified();
+    emit textChanged();
+    emit selectionChanged();
+    emit copyAvailable( doc->hasSelection( TQTextDocument::Standard ) );
+}
+
+/*!
+    Moves the text cursor according to \a action. This is normally
+    used by some key event handler. \a select specifies whether the
+    text between the current cursor position and the new position
+    should be selected.
+*/
+
+void TQTextEdit::moveCursor( CursorAction action, bool select )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return;
+#endif
+#ifdef Q_WS_MACX
+    TQTextCursor c1 = *cursor;
+    TQTextCursor c2;
+#endif
+    drawCursor( FALSE );
+    if ( select ) {
+	if ( !doc->hasSelection( TQTextDocument::Standard ) )
+	    doc->setSelectionStart( TQTextDocument::Standard, *cursor );
+	moveCursor( action );
+#ifdef Q_WS_MACX
+	c2 = *cursor;
+	if (c1 == c2)
+	    if (action == MoveDown || action == MovePgDown)
+		moveCursor( MoveEnd );
+	    else if (action == MoveUp || action == MovePgUp)
+		moveCursor( MoveHome );
+#endif
+	if ( doc->setSelectionEnd( TQTextDocument::Standard, *cursor ) ) {
+	    cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
+	    repaintChanged();
+	} else {
+	    drawCursor( TRUE );
+	}
+	ensureCursorVisible();
+	emit selectionChanged();
+	emit copyAvailable( doc->hasSelection( TQTextDocument::Standard ) );
+    } else {
+#ifdef Q_WS_MACX
+	TQTextCursor cStart = doc->selectionStartCursor( TQTextDocument::Standard );
+	TQTextCursor cEnd = doc->selectionEndCursor( TQTextDocument::Standard );
+	bool redraw = doc->removeSelection( TQTextDocument::Standard );
+	if (redraw && action == MoveDown)
+	    *cursor = cEnd;
+	else if (redraw && action == MoveUp)
+	    *cursor = cStart;
+	if (redraw && action == MoveForward)
+	    *cursor = cEnd;
+	else if (redraw && action == MoveBackward)
+	    *cursor = cStart;
+	else
+	    moveCursor( action );
+	c2 = *cursor;
+	if (c1 == c2)
+	    if (action == MoveDown)
+		moveCursor( MoveEnd );
+	    else if (action == MoveUp)
+		moveCursor( MoveHome );
+#else
+	bool redraw = doc->removeSelection( TQTextDocument::Standard );
+	moveCursor( action );
+#endif
+	if ( !redraw ) {
+	    ensureCursorVisible();
+	    drawCursor( TRUE );
+	} else {
+	    cursor->paragraph()->document()->nextDoubleBuffered = TRUE;
+	    repaintChanged();
+	    ensureCursorVisible();
+	    drawCursor( TRUE );
+#ifndef QT_NO_CURSOR
+	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+	}
+	if ( redraw ) {
+	    emit copyAvailable( doc->hasSelection( TQTextDocument::Standard ) );
+	    emit selectionChanged();
+	}
+    }
+
+    drawCursor( TRUE );
+    updateCurrentFormat();
+    updateMicroFocusHint();
+}
+
+/*!
+    \overload
+*/
+
+void TQTextEdit::moveCursor( CursorAction action )
+{
+    resetInputContext();
+    switch ( action ) {
+    case MoveBackward:
+	cursor->gotoPreviousLetter();
+	break;
+    case MoveWordBackward:
+	cursor->gotoPreviousWord();
+	break;
+    case MoveForward:
+	cursor->gotoNextLetter();
+	break;
+    case MoveWordForward:
+	cursor->gotoNextWord();
+	break;
+    case MoveUp:
+	cursor->gotoUp();
+	break;
+    case MovePgUp:
+	cursor->gotoPageUp( visibleHeight() );
+	break;
+    case MoveDown:
+	cursor->gotoDown();
+	break;
+    case MovePgDown:
+	cursor->gotoPageDown( visibleHeight() );
+	break;
+    case MoveLineStart:
+	cursor->gotoLineStart();
+	break;
+    case MoveHome:
+	cursor->gotoHome();
+	break;
+    case MoveLineEnd:
+	cursor->gotoLineEnd();
+	break;
+    case MoveEnd:
+	ensureFormatted( doc->lastParagraph() );
+	cursor->gotoEnd();
+	break;
+    }
+    updateMicroFocusHint();
+    updateCurrentFormat();
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::resizeEvent( TQResizeEvent *e )
+{
+    TQScrollView::resizeEvent( e );
+    if ( doc->visibleWidth() == 0 )
+	doResize();
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::viewportResizeEvent( TQResizeEvent *e )
+{
+    TQScrollView::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();
+    }
+}
+
+/*!
+    Ensures that the cursor is visible by scrolling the text edit if
+    necessary.
+
+    \sa setCursorPosition()
+*/
+
+void TQTextEdit::ensureCursorVisible()
+{
+    // Not visible or the user is draging the window, so don't position to caret yet
+    if ( !isUpdatesEnabled() || !isVisible() || isHorizontalSliderPressed() || isVerticalSliderPressed() ) {
+	d->ensureCursorVisibleInShowEvent = TRUE;
+	return;
+    }
+    sync();
+    TQTextStringChar *chr = cursor->paragraph()->at( cursor->index() );
+    int h = cursor->paragraph()->lineHeightOfChar( cursor->index() );
+    int x = cursor->paragraph()->rect().x() + chr->x + cursor->offsetX();
+    int y = 0; int dummy;
+    cursor->paragraph()->lineHeightOfChar( cursor->index(), &dummy, &y );
+    y += cursor->paragraph()->rect().y() + cursor->offsetY();
+    int w = 1;
+    ensureVisible( x, y + h / 2, w, h / 2 + 2 );
+}
+
+/*!
+    \internal
+*/
+void TQTextEdit::sliderReleased()
+{
+    if ( d->ensureCursorVisibleInShowEvent && isVisible() ) {
+	d->ensureCursorVisibleInShowEvent = FALSE;
+	ensureCursorVisible();
+    }
+}
+
+/*!
+    \internal
+*/
+void TQTextEdit::drawCursor( bool visible )
+{
+    if ( !isUpdatesEnabled() ||
+	 !viewport()->isUpdatesEnabled() ||
+	 !cursor->paragraph() ||
+	 !cursor->paragraph()->isValid() ||
+	 ( !style().styleHint( TQStyle::SH_BlinkCursorWhenTextSelected ) &&
+	   ( d->optimMode ? optimHasSelection() : doc->hasSelection( TQTextDocument::Standard, TRUE ))) ||
+	 ( visible && !hasFocus() && !viewport()->hasFocus() && !inDnD ) ||
+         doc->hasSelection( TQTextDocument::IMSelectionText ) ||
+	 isReadOnly() )
+	return;
+
+    // Asian users regard selection text as cursor on candidate
+    // selection phase of input method, so ordinary cursor should be
+    // invisible if IM selection text exists.
+    if ( doc->hasSelection( TQTextDocument::IMSelectionText ) ) {
+        visible = FALSE;
+    }
+
+    TQPainter p( viewport() );
+    TQRect r( cursor->topParagraph()->rect() );
+    cursor->paragraph()->setChanged( TRUE );
+    p.translate( -contentsX() + cursor->totalOffsetX(), -contentsY() + cursor->totalOffsetY() );
+    TQPixmap *pix = 0;
+    TQColorGroup cg( colorGroup() );
+    const TQColorGroup::ColorRole backRole = TQPalette::backgroundRoleFromMode(backgroundMode());
+    if ( cursor->paragraph()->background() )
+	cg.setBrush( backRole, *cursor->paragraph()->background() );
+    else if ( doc->paper() )
+	cg.setBrush( backRole, *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() & TQt::AlignJustify ) == TQt::AlignJustify )
+	    dist = 50;
+	int x = r.x() - cursor->totalOffsetX() + cursor->x() - dist;
+	x = TQMAX( x, 0 );
+	p.setClipRect( TQRect( x - contentsX(),
+			      r.y() - cursor->totalOffsetY() + cursor->y() - contentsY(), 2 * dist, h ) );
+	doc->drawParagraph( &p, cursor->paragraph(), x,
+			r.y() - cursor->totalOffsetY() + cursor->y(), 2 * dist, h, pix, cg, visible, cursor );
+    } else {
+	doc->drawParagraph( &p, cursor->paragraph(), r.x() - cursor->totalOffsetX(),
+			r.y() - cursor->totalOffsetY(), r.width(), r.height(),
+			pix, cg, visible, cursor );
+    }
+    cursorVisible = visible;
+}
+
+enum {
+    IdUndo = 0,
+    IdRedo = 1,
+    IdCut = 2,
+    IdCopy = 3,
+    IdPaste = 4,
+    IdClear = 5,
+    IdSelectAll = 6
+};
+
+/*!
+    \reimp
+*/
+#ifndef QT_NO_WHEELEVENT
+void TQTextEdit::contentsWheelEvent( TQWheelEvent *e )
+{
+    if ( isReadOnly() ) {
+	if ( e->state() & ControlButton ) {
+	    if ( e->delta() > 0 )
+		zoomOut();
+	    else if ( e->delta() < 0 )
+		zoomIn();
+	    return;
+	}
+    }
+    TQScrollView::contentsWheelEvent( e );
+}
+#endif
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::contentsMousePressEvent( TQMouseEvent *e )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimMousePressEvent( e );
+	return;
+    }
+#endif
+
+    if ( sendMouseEventToInputContext( e ) )
+	return;
+
+    if ( d->trippleClickTimer->isActive() &&
+	 ( e->globalPos() - d->trippleClickPoint ).manhattanLength() <
+	 TQApplication::startDragDistance() ) {
+	TQTextCursor c1 = *cursor;
+	TQTextCursor c2 = *cursor;
+	c1.gotoLineStart();
+	c2.gotoLineEnd();
+	doc->setSelectionStart( TQTextDocument::Standard, c1 );
+	doc->setSelectionEnd( TQTextDocument::Standard, c2 );
+	*cursor = c2;
+	repaintChanged();
+	mousePressed = TRUE;
+	return;
+    }
+
+    clearUndoRedo();
+    TQTextCursor oldCursor = *cursor;
+    TQTextCursor c = *cursor;
+    mousePos = e->pos();
+    mightStartDrag = FALSE;
+    pressedLink = TQString::null;
+    d->pressedName = TQString::null;
+
+    if ( e->button() == LeftButton ) {
+	mousePressed = TRUE;
+	drawCursor( FALSE );
+	placeCursor( e->pos() );
+	ensureCursorVisible();
+
+	if ( isReadOnly() && linksEnabled() ) {
+	    TQTextCursor 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();
+		d->pressedName = c.paragraph()->at( c.index() )->anchorName();
+	    }
+	}
+
+#ifndef QT_NO_DRAGANDDROP
+	if ( doc->inSelection( TQTextDocument::Standard, e->pos() ) ) {
+	    mightStartDrag = TRUE;
+	    drawCursor( TRUE );
+	    dragStartTimer->start( TQApplication::startDragTime(), TRUE );
+	    dragStartPos = e->pos();
+	    return;
+	}
+#endif
+
+	bool redraw = FALSE;
+	if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+	    if ( !( e->state() & ShiftButton ) ) {
+		redraw = doc->removeSelection( TQTextDocument::Standard );
+		doc->setSelectionStart( TQTextDocument::Standard, *cursor );
+	    } else {
+		redraw = doc->setSelectionEnd( TQTextDocument::Standard, *cursor ) || redraw;
+	    }
+	} else {
+	    if ( isReadOnly() || !( e->state() & ShiftButton ) ) {
+		doc->setSelectionStart( TQTextDocument::Standard, *cursor );
+	    } else {
+		doc->setSelectionStart( TQTextDocument::Standard, c );
+		redraw = doc->setSelectionEnd( TQTextDocument::Standard, *cursor ) || redraw;
+	    }
+	}
+
+	for ( int i = 1; i < doc->numSelections(); ++i ) // start with 1 as we don't want to remove the Standard-Selection
+	    redraw = doc->removeSelection( i ) || redraw;
+
+	if ( !redraw ) {
+	    drawCursor( TRUE );
+	} else {
+	    repaintChanged();
+#ifndef QT_NO_CURSOR
+	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+	}
+    } else if ( e->button() == MidButton ) {
+	bool redraw = doc->removeSelection( TQTextDocument::Standard );
+	if ( !redraw ) {
+	    drawCursor( TRUE );
+	} else {
+	    repaintChanged();
+#ifndef QT_NO_CURSOR
+	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+	}
+    }
+
+    if ( *cursor != oldCursor )
+	updateCurrentFormat();
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::contentsMouseMoveEvent( TQMouseEvent *e )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimMouseMoveEvent( e );
+	return;
+    }
+#endif
+    if ( sendMouseEventToInputContext( e ) ) {
+	// don't return from here to avoid cursor vanishing
+    } else if ( mousePressed ) {
+#ifndef QT_NO_DRAGANDDROP
+	if ( mightStartDrag ) {
+	    dragStartTimer->stop();
+	    if ( ( e->pos() - dragStartPos ).manhattanLength() > TQApplication::startDragDistance() ) {
+		TQGuardedPtr<TQTextEdit> guard( this );
+		startDrag();
+		if (guard.isNull()) // we got deleted during the dnd
+                    return;
+	    }
+#ifndef QT_NO_CURSOR
+	    if ( !isReadOnly() )
+		viewport()->setCursor( ibeamCursor );
+#endif
+	    return;
+	}
+#endif
+	mousePos = e->pos();
+	handleMouseMove( mousePos );
+	oldMousePos = mousePos;
+    }
+
+#ifndef QT_NO_CURSOR
+    if ( !isReadOnly() && !mousePressed ) {
+	if ( doc->hasSelection( TQTextDocument::Standard ) && doc->inSelection( TQTextDocument::Standard, e->pos() ) )
+	    viewport()->setCursor( arrowCursor );
+	else
+	    viewport()->setCursor( ibeamCursor );
+    }
+#endif
+    updateCursor( e->pos() );
+}
+
+void TQTextEdit::copyToClipboard()
+{
+#ifndef QT_NO_CLIPBOARD
+    if (TQApplication::clipboard()->supportsSelection()) {
+	d->clipboard_mode = TQClipboard::Selection;
+
+	// don't listen to selection changes
+	disconnect( TQApplication::clipboard(), SIGNAL(selectionChanged()), this, 0);
+	copy();
+	// listen to selection changes
+	connect( TQApplication::clipboard(), SIGNAL(selectionChanged()),
+		 this, SLOT(clipboardChanged()) );
+
+	d->clipboard_mode = TQClipboard::Clipboard;
+    }
+#endif
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::contentsMouseReleaseEvent( TQMouseEvent * e )
+{
+    if ( !inDoubleClick && !d->composeMode() ) { // could be the release of a dblclick
+	int para = 0;
+	int index = charAt( e->pos(), &para );
+	emit clicked( para, index );
+    }
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimMouseReleaseEvent( e );
+	return;
+    }
+#endif
+    if ( sendMouseEventToInputContext( e ) )
+	return;
+    TQTextCursor oldCursor = *cursor;
+    if ( scrollTimer->isActive() )
+	scrollTimer->stop();
+#ifndef QT_NO_DRAGANDDROP
+    if ( dragStartTimer->isActive() )
+	dragStartTimer->stop();
+    if ( mightStartDrag ) {
+	selectAll( FALSE );
+	mousePressed = FALSE;
+    }
+#endif
+    bool mouseWasPressed = mousePressed;
+    if ( mousePressed ) {
+	mousePressed = FALSE;
+	copyToClipboard();
+    }
+#ifndef QT_NO_CLIPBOARD
+    else if ( e->button() == MidButton && !isReadOnly() ) {
+        // only do middle-click pasting on systems that have selections (ie. X11)
+        if (TQApplication::clipboard()->supportsSelection()) {
+            drawCursor( FALSE );
+            placeCursor( e->pos() );
+            ensureCursorVisible();
+            doc->setSelectionStart( TQTextDocument::Standard, oldCursor );
+            bool redraw = FALSE;
+            if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+                redraw = doc->removeSelection( TQTextDocument::Standard );
+                doc->setSelectionStart( TQTextDocument::Standard, *cursor );
+            } else {
+                doc->setSelectionStart( TQTextDocument::Standard, *cursor );
+            }
+            // start with 1 as we don't want to remove the Standard-Selection
+            for ( int i = 1; i < doc->numSelections(); ++i )
+                redraw = doc->removeSelection( i ) || redraw;
+            if ( !redraw ) {
+                drawCursor( TRUE );
+            } else {
+                repaintChanged();
+#ifndef QT_NO_CURSOR
+                viewport()->setCursor( ibeamCursor );
+#endif
+            }
+	    d->clipboard_mode = TQClipboard::Selection;
+            paste();
+	    d->clipboard_mode = TQClipboard::Clipboard;
+        }
+    }
+#endif
+    emit cursorPositionChanged( cursor );
+    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
+    if ( oldCursor != *cursor )
+	updateCurrentFormat();
+    inDoubleClick = FALSE;
+
+#ifndef QT_NO_NETWORKPROTOCOL
+    if ( (   (!onLink.isEmpty() && onLink == pressedLink)
+	  || (!d->onName.isEmpty() && d->onName == d->pressedName))
+	 && linksEnabled() && mouseWasPressed ) {
+	if (!onLink.isEmpty()) {
+	    TQUrl u( doc->context(), onLink, TRUE );
+	    emitLinkClicked( u.toString( FALSE, FALSE ) );
+	}
+	if (::qt_cast<TQTextBrowser*>(this)) { // change for 4.0
+	    TQConnectionList *clist = receivers(
+			"anchorClicked(const TQString&,const TQString&)");
+	    if (!signalsBlocked() && clist) {
+		TQUObject o[3];
+		static_QUType_TQString.set(o+1, d->onName);
+		static_QUType_TQString.set(o+2, onLink);
+		activate_signal( clist, o);
+	    }
+	}
+
+	// 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( TQTextDocument::Standard, TRUE ) )
+	doc->removeSelection( TQTextDocument::Standard );
+
+    emit copyAvailable( doc->hasSelection( TQTextDocument::Standard ) );
+    emit selectionChanged();
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::contentsMouseDoubleClickEvent( TQMouseEvent * e )
+{
+    if ( e->button() != TQt::LeftButton && !d->composeMode() ) {
+	e->ignore();
+	return;
+    }
+    int para = 0;
+    int index = charAt( e->pos(), &para );
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	TQString str = d->od->lines[ LOGOFFSET(para) ];
+	int startIdx = index, endIdx = index, i;
+	if ( !str[ index ].isSpace() ) {
+	    i = startIdx;
+	    // find start of word
+	    while ( i >= 0 && !str[ i ].isSpace() ) {
+		startIdx = i--;
+	    }
+	    i = endIdx;
+	    // find end of word..
+	    while ( (uint) i < str.length() && !str[ i ].isSpace() ) {
+		endIdx = ++i;
+	    }
+	    // ..and start of next
+	    while ( (uint) i < str.length() && str[ i ].isSpace() ) {
+		endIdx = ++i;
+	    }
+	    optimSetSelection( para, startIdx, para, endIdx );
+	    repaintContents( FALSE );
+	}
+    } else
+#endif
+    {
+	if ( sendMouseEventToInputContext( e ) )
+	    return;
+
+	TQTextCursor c1 = *cursor;
+	TQTextCursor c2 = *cursor;
+#if defined(Q_OS_MAC)
+	TQTextParagraph *para = cursor->paragraph();
+	if ( cursor->isValid() ) {
+	    if ( para->at( cursor->index() )->c.isLetterOrNumber() ) {
+		while ( c1.index() > 0 &&
+			c1.paragraph()->at( c1.index()-1 )->c.isLetterOrNumber() )
+		    c1.gotoPreviousLetter();
+		while ( c2.paragraph()->at( c2.index() )->c.isLetterOrNumber() &&
+			!c2.atParagEnd() )
+		    c2.gotoNextLetter();
+	    } else if ( para->at( cursor->index() )->c.isSpace() ) {
+		while ( c1.index() > 0 &&
+			c1.paragraph()->at( c1.index()-1 )->c.isSpace() )
+		    c1.gotoPreviousLetter();
+		while ( c2.paragraph()->at( c2.index() )->c.isSpace() &&
+			!c2.atParagEnd() )
+		    c2.gotoNextLetter();
+	    } else if ( !c2.atParagEnd() ) {
+		c2.gotoNextLetter();
+	    }
+	}
+#else
+	if ( cursor->index() > 0 && !cursor->paragraph()->at( cursor->index()-1 )->c.isSpace() )
+	    c1.gotoPreviousWord();
+	if ( !cursor->paragraph()->at( cursor->index() )->c.isSpace() && !cursor->atParagEnd() )
+	    c2.gotoNextWord();
+#endif
+	doc->setSelectionStart( TQTextDocument::Standard, c1 );
+	doc->setSelectionEnd( TQTextDocument::Standard, c2 );
+
+	*cursor = c2;
+
+	repaintChanged();
+
+	d->trippleClickTimer->start( qApp->doubleClickInterval(), TRUE );
+	d->trippleClickPoint = e->globalPos();
+    }
+    inDoubleClick = TRUE;
+    mousePressed = TRUE;
+    emit doubleClicked( para, index );
+}
+
+#ifndef QT_NO_DRAGANDDROP
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::contentsDragEnterEvent( TQDragEnterEvent *e )
+{
+    if ( isReadOnly() || !TQTextDrag::canDecode( e ) ) {
+	e->ignore();
+	return;
+    }
+    e->acceptAction();
+    inDnD = TRUE;
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::contentsDragMoveEvent( TQDragMoveEvent *e )
+{
+    if ( isReadOnly() || !TQTextDrag::canDecode( e ) ) {
+	e->ignore();
+	return;
+    }
+    drawCursor( FALSE );
+    placeCursor( e->pos(),  cursor );
+    drawCursor( TRUE );
+    e->acceptAction();
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::contentsDragLeaveEvent( TQDragLeaveEvent * )
+{
+    drawCursor( FALSE );
+    inDnD = FALSE;
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::contentsDropEvent( TQDropEvent *e )
+{
+    if ( isReadOnly() )
+	return;
+    inDnD = FALSE;
+    e->acceptAction();
+    bool intern = FALSE;
+    if ( TQRichTextDrag::canDecode( e ) ) {
+	bool hasSel = doc->hasSelection( TQTextDocument::Standard );
+	bool internalDrag = e->source() == this || e->source() == viewport();
+	int dropId, dropIndex;
+	TQTextCursor insertCursor = *cursor;
+	dropId = cursor->paragraph()->paragId();
+	dropIndex = cursor->index();
+	if ( hasSel && internalDrag ) {
+	    TQTextCursor c1, c2;
+	    int selStartId, selStartIndex;
+	    int selEndId, selEndIndex;
+	    c1 = doc->selectionStartCursor( TQTextDocument::Standard );
+	    c1.restoreState();
+	    c2 = doc->selectionEndCursor( TQTextDocument::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() == TQDropEvent::Move ) {
+	    removeSelectedText();
+	    intern = TRUE;
+	    doc->removeSelection( TQTextDocument::Standard );
+	} else {
+	    doc->removeSelection( TQTextDocument::Standard );
+#ifndef QT_NO_CURSOR
+	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+	}
+	drawCursor( FALSE );
+	cursor->setParagraph( insertCursor.paragraph() );
+	cursor->setIndex( insertCursor.index() );
+	drawCursor( TRUE );
+	if ( !cursor->nestedDepth() ) {
+	    TQString subType = "plain";
+	    if ( textFormat() != PlainText ) {
+		if ( e->provides( "application/x-qrichtext" ) )
+		    subType = "x-qrichtext";
+	    }
+#ifndef QT_NO_CLIPBOARD
+	    pasteSubType( subType.latin1(), e );
+#endif
+	    // emit appropriate signals.
+	    emit selectionChanged();
+	    emit cursorPositionChanged( cursor );
+	    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
+	} else {
+	    if ( intern )
+		undo();
+	    e->ignore();
+	}
+    }
+}
+
+#endif
+
+/*!
+    \reimp
+*/
+void TQTextEdit::contentsContextMenuEvent( TQContextMenuEvent *e )
+{
+    e->accept();
+#ifndef QT_NO_IM
+    if ( d->composeMode() )
+	return;
+#endif
+
+    clearUndoRedo();
+    mousePressed = FALSE;
+
+#ifndef QT_NO_POPUPMENU
+    TQGuardedPtr<TQTextEdit> that = this;
+    TQGuardedPtr<TQPopupMenu> popup = createPopupMenu( e->pos() );
+    if ( !popup )
+	popup = createPopupMenu();
+    if ( !popup )
+	return;
+
+    int r = popup->exec( e->globalPos() );
+    delete popup;
+    if (!that)
+        return;
+
+    if ( r == d->id[ IdClear ] )
+	clear();
+    else if ( r == d->id[ IdSelectAll ] ) {
+	selectAll();
+#ifndef QT_NO_CLIPBOARD
+        // if the clipboard support selections, put the newly selected text into
+        // the clipboard
+	if (TQApplication::clipboard()->supportsSelection()) {
+	    d->clipboard_mode = TQClipboard::Selection;
+
+            // don't listen to selection changes
+            disconnect( TQApplication::clipboard(), SIGNAL(selectionChanged()), this, 0);
+	    copy();
+            // listen to selection changes
+            connect( TQApplication::clipboard(), SIGNAL(selectionChanged()),
+                     this, SLOT(clipboardChanged()) );
+
+	    d->clipboard_mode = TQClipboard::Clipboard;
+	}
+#endif
+    } else if ( r == d->id[ IdUndo ] )
+	undo();
+    else if ( r == d->id[ IdRedo ] )
+	redo();
+#ifndef QT_NO_CLIPBOARD
+    else if ( r == d->id[ IdCut ] )
+	cut();
+    else if ( r == d->id[ IdCopy ] )
+	copy();
+    else if ( r == d->id[ IdPaste ] )
+	paste();
+#endif
+#endif
+}
+
+
+void TQTextEdit::autoScrollTimerDone()
+{
+    if ( mousePressed )
+	handleMouseMove(  viewportToContents( viewport()->mapFromGlobal( TQCursor::pos() )  ) );
+}
+
+void TQTextEdit::handleMouseMove( const TQPoint& pos )
+{
+    if ( !mousePressed )
+	return;
+
+    if ( !scrollTimer->isActive() && pos.y() < contentsY() || pos.y() > contentsY() + visibleHeight() )
+	scrollTimer->start( 100, FALSE );
+    else if ( scrollTimer->isActive() && pos.y() >= contentsY() && pos.y() <= contentsY() + visibleHeight() )
+	scrollTimer->stop();
+
+    drawCursor( FALSE );
+    TQTextCursor oldCursor = *cursor;
+
+    placeCursor( pos );
+
+    if ( inDoubleClick ) {
+	TQTextCursor cl = *cursor;
+	cl.gotoPreviousWord();
+	TQTextCursor cr = *cursor;
+	cr.gotoNextWord();
+
+	int diff = TQABS( oldCursor.paragraph()->at( oldCursor.index() )->x - mousePos.x() );
+	int ldiff = TQABS( cl.paragraph()->at( cl.index() )->x - mousePos.x() );
+	int rdiff = TQABS( cr.paragraph()->at( cr.index() )->x - mousePos.x() );
+
+
+	if ( cursor->paragraph()->lineStartOfChar( cursor->index() ) !=
+	     oldCursor.paragraph()->lineStartOfChar( oldCursor.index() ) )
+	    diff = 0xFFFFFF;
+
+	if ( rdiff < diff && rdiff < ldiff )
+	    *cursor = cr;
+	else if ( ldiff < diff && ldiff < rdiff )
+	    *cursor = cl;
+	else
+	    *cursor = oldCursor;
+
+    }
+    ensureCursorVisible();
+
+    bool redraw = FALSE;
+    if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+	redraw = doc->setSelectionEnd( TQTextDocument::Standard, *cursor ) || redraw;
+    }
+
+    if ( !redraw ) {
+	drawCursor( TRUE );
+    } else {
+	repaintChanged();
+	drawCursor( TRUE );
+    }
+
+    if ( currentFormat && currentFormat->key() != cursor->paragraph()->at( cursor->index() )->format()->key() ) {
+	currentFormat->removeRef();
+	currentFormat = doc->formatCollection()->format( cursor->paragraph()->at( cursor->index() )->format() );
+	if ( currentFormat->isMisspelled() ) {
+	    currentFormat->removeRef();
+	    currentFormat = doc->formatCollection()->format( currentFormat->font(), currentFormat->color() );
+	}
+	emit currentFontChanged( currentFormat->font() );
+	emit currentColorChanged( currentFormat->color() );
+	emit currentVerticalAlignmentChanged( (VerticalAlignment)currentFormat->vAlign() );
+    }
+
+    if ( currentAlignment != cursor->paragraph()->alignment() ) {
+	currentAlignment = cursor->paragraph()->alignment();
+	block_set_alignment = TRUE;
+	emit currentAlignmentChanged( currentAlignment );
+	block_set_alignment = FALSE;
+    }
+}
+
+/*! \internal */
+
+void TQTextEdit::placeCursor( const TQPoint &pos, TQTextCursor *c, bool link )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return;
+#endif
+    if ( !c )
+	c = cursor;
+
+    resetInputContext();
+    c->restoreState();
+    TQTextParagraph *s = doc->firstParagraph();
+    c->place( pos, s, link );
+    updateMicroFocusHint();
+}
+
+
+void TQTextEdit::updateMicroFocusHint()
+{
+    TQTextCursor c( *cursor );
+#if 0
+     // Disabled for Asian input method that shows candidate
+     // window. This behavior is same as TQt/E 2.3.7 which supports
+     // Asian input methods. Asian input methods need start point of IM
+     // selection text to place candidate window as adjacent to the
+     // selection text.    
+    if ( d->preeditStart != -1 ) {
+	c.setIndex( d->preeditStart );
+        if(doc->hasSelection(TQTextDocument::IMSelectionText)) {
+            int para, index;
+            doc->selectionStart(TQTextDocument::IMSelectionText, para, index);
+            c.setIndex(index);
+        }
+    }
+#endif
+    
+    if ( hasFocus() || viewport()->hasFocus() ) {
+	int h = c.paragraph()->lineHeightOfChar( cursor->index() );
+	if ( !readonly ) {
+	    TQFont f = c.paragraph()->at( c.index() )->format()->font();
+	    setMicroFocusHint( c.x() - contentsX() + frameWidth(),
+			       c.y() + cursor->paragraph()->rect().y() - contentsY() + frameWidth(), 0, h, TRUE, &f );
+	}
+    }
+}
+
+
+
+void TQTextEdit::formatMore()
+{
+    if ( !lastFormatted )
+	return;
+
+    int bottom = contentsHeight();
+    int lastTop = -1;
+    int lastBottom = -1;
+    int to = 20;
+    bool firstVisible = FALSE;
+    TQRect cr( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
+    for ( int i = 0; lastFormatted &&
+	  ( i < to || ( firstVisible && lastTop < contentsY()+height() ) );
+	  i++ ) {
+	lastFormatted->format();
+	lastTop = lastFormatted->rect().top();
+	lastBottom = lastFormatted->rect().bottom();
+	if ( i == 0 )
+	    firstVisible = lastBottom < cr.bottom();
+	bottom = TQMAX( bottom, lastBottom );
+	lastFormatted = lastFormatted->next();
+    }
+
+    if ( bottom > contentsHeight() ) {
+	resizeContents( contentsWidth(), TQMAX( doc->height(), bottom ) );
+    } else if ( !lastFormatted && lastBottom < contentsHeight() ) {
+	resizeContents( contentsWidth(), TQMAX( doc->height(), lastBottom ) );
+	if ( contentsHeight() < visibleHeight() )
+	    updateContents( 0, contentsHeight(), visibleWidth(),
+			    visibleHeight() - contentsHeight() );
+    }
+
+    if ( lastFormatted )
+	formatTimer->start( interval, TRUE );
+    else
+	interval = TQMAX( 0, interval );
+}
+
+void TQTextEdit::doResize()
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( !d->optimMode )
+#endif
+    {
+	if ( wrapMode == FixedPixelWidth )
+	    return;
+	doc->setMinimumWidth( -1 );
+	resizeContents( 0, 0 );
+	doc->setWidth( visibleWidth() );
+	doc->invalidate();
+	lastFormatted = doc->firstParagraph();
+	interval = 0;
+	formatMore();
+    }
+    repaintContents( FALSE );
+}
+
+/*! \internal */
+
+void TQTextEdit::doChangeInterval()
+{
+    interval = 0;
+}
+
+/*!
+    \reimp
+*/
+
+bool TQTextEdit::eventFilter( TQObject *o, TQEvent *e )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( !d->optimMode && (o == this || o == viewport()) ) {
+#else
+    if ( o == this || o == viewport() ) {
+#endif
+	if ( e->type() == TQEvent::FocusIn ) {
+	    if ( TQApplication::cursorFlashTime() > 0 )
+		blinkTimer->start( TQApplication::cursorFlashTime() / 2 );
+	    drawCursor( TRUE );
+	    updateMicroFocusHint();
+	} else if ( e->type() == TQEvent::FocusOut ) {
+	    blinkTimer->stop();
+	    drawCursor( FALSE );
+	}
+    }
+
+    if ( o == this && e->type() == TQEvent::PaletteChange ) {
+	TQColor old( viewport()->colorGroup().color( TQColorGroup::Text ) );
+	if ( old != colorGroup().color( TQColorGroup::Text ) ) {
+	    TQColor c( colorGroup().color( TQColorGroup::Text ) );
+	    doc->setMinimumWidth( -1 );
+	    doc->setDefaultFormat( doc->formatCollection()->defaultFormat()->font(), c );
+	    lastFormatted = doc->firstParagraph();
+	    formatMore();
+	    repaintChanged();
+	}
+    }
+
+    return TQScrollView::eventFilter( o, e );
+}
+
+/*!
+  \obsolete
+ */
+void TQTextEdit::insert( const TQString &text, bool indent,
+			bool checkNewLine, bool removeSelected )
+{
+    uint f = 0;
+    if ( indent )
+	f |= RedoIndentation;
+    if ( checkNewLine )
+	f |= CheckNewLines;
+    if ( removeSelected )
+	f |= RemoveSelected;
+    insert( text, f );
+}
+
+/*!
+    Inserts \a text at the current cursor position.
+
+    The \a insertionFlags define how the text is inserted. If \c
+    RedoIndentation is set, the paragraph is re-indented. If \c
+    CheckNewLines is set, newline characters in \a text result in hard
+    line breaks (i.e. new paragraphs). If \c checkNewLine is not set,
+    the behaviour of the editor is undefined if the \a text contains
+    newlines. (It is not possible to change TQTextEdit's newline handling
+    behavior, but you can use TQString::replace() to preprocess text
+    before inserting it.) If \c RemoveSelected is set, any selected
+    text (in selection 0) is removed before the text is inserted.
+
+    The default flags are \c CheckNewLines | \c RemoveSelected.
+
+    If the widget is in \c LogText mode this function will do nothing.
+
+    \sa paste() pasteSubType()
+*/
+
+
+void TQTextEdit::insert( const TQString &text, uint insertionFlags )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return;
+#endif
+
+    if ( cursor->nestedDepth() != 0 ) // #### for 3.0, disable editing of tables as this is not advanced enough
+	return;
+
+    bool indent = insertionFlags & RedoIndentation;
+    bool checkNewLine = insertionFlags & CheckNewLines;
+    bool removeSelected = insertionFlags & RemoveSelected;
+    bool imComposition = insertionFlags & AsIMCompositionText;
+    bool imSelection = insertionFlags & WithIMSelection;
+    TQString txt( text );
+    drawCursor( FALSE );
+    if ( !isReadOnly() && doc->hasSelection( TQTextDocument::Standard ) && removeSelected )
+	removeSelectedText();
+    TQTextCursor c2 = *cursor;
+    int oldLen = 0;
+
+    if ( undoEnabled && !isReadOnly() && undoRedoInfo.type != UndoRedoInfo::IME ) {
+	checkUndoRedoInfo( UndoRedoInfo::Insert );
+
+        if (undoRedoInfo.valid() && undoRedoInfo.index + undoRedoInfo.d->text.length() != cursor->index()) {
+            clearUndoRedo();
+            undoRedoInfo.type = UndoRedoInfo::Insert;
+        }
+
+	if ( !undoRedoInfo.valid() ) {
+	    undoRedoInfo.id = cursor->paragraph()->paragId();
+	    undoRedoInfo.index = cursor->index();
+	    undoRedoInfo.d->text = TQString::null;
+	}
+	oldLen = undoRedoInfo.d->text.length();
+    }
+
+    lastFormatted = checkNewLine && cursor->paragraph()->prev() ?
+		    cursor->paragraph()->prev() : cursor->paragraph();
+    TQTextCursor oldCursor = *cursor;
+    cursor->insert( txt, checkNewLine );
+    if ( doc->useFormatCollection() && !doc->preProcessor() ) {
+	doc->setSelectionStart( TQTextDocument::Temp, oldCursor );
+	doc->setSelectionEnd( TQTextDocument::Temp, *cursor );
+	doc->setFormat( TQTextDocument::Temp, currentFormat, TQTextFormat::Format );
+	doc->removeSelection( TQTextDocument::Temp );
+    }
+
+    if ( indent && ( txt == "{" || txt == "}" || txt == ":" || txt == "#" ) )
+	cursor->indent();
+    formatMore();
+    repaintChanged();
+    ensureCursorVisible();
+    // Asian users regard selection text as cursor on candidate
+    // selection phase of input method, so ordinary cursor should be
+    // invisible if IM selection text exists.
+    drawCursor( !imSelection );
+
+    if ( undoEnabled && !isReadOnly() && undoRedoInfo.type != UndoRedoInfo::IME ) {
+	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( TQTextDocument::Standard, oldCursor );
+	doc->setSelectionEnd( TQTextDocument::Standard, *cursor );
+	repaintChanged();
+    }
+    // updateMicroFocusHint() should not be invoked here when this
+    // function is invoked from imComposeEvent() because cursor
+    // postion is incorrect yet. imComposeEvent() invokes
+    // updateMicroFocusHint() later.
+    if ( !imComposition ) {
+      updateMicroFocusHint();
+    }
+    setModified();
+    emit textChanged();
+}
+
+/*!
+    Inserts \a text in the paragraph \a para at position \a index.
+*/
+
+void TQTextEdit::insertAt( const TQString &text, int para, int index )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimInsert( text, para, index );
+	return;
+    }
+#endif
+    resetInputContext();
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return;
+    removeSelection( TQTextDocument::Standard );
+    TQTextCursor tmp = *cursor;
+    cursor->setParagraph( p );
+    cursor->setIndex( index );
+    insert( text, FALSE, TRUE, FALSE );
+    *cursor = tmp;
+    removeSelection( TQTextDocument::Standard );
+}
+
+/*!
+    Inserts \a text as a new paragraph at position \a para. If \a para
+    is -1, the text is appended. Use append() if the append operation
+    is performance critical.
+*/
+
+void TQTextEdit::insertParagraph( const TQString &text, int para )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimInsert( text + "\n", para, 0 );
+	return;
+    }
+#endif
+    resetInputContext();
+    for ( int i = 0; i < (int)doc->numSelections(); ++i )
+	doc->removeSelection( i );
+
+    TQTextParagraph *p = doc->paragAt( para );
+
+    bool append = !p;
+    if ( !p )
+	p = doc->lastParagraph();
+
+    TQTextCursor old = *cursor;
+    drawCursor( FALSE );
+
+    cursor->setParagraph( p );
+    cursor->setIndex( 0 );
+    clearUndoRedo();
+    qtextedit_ignore_readonly = TRUE;
+    if ( append && cursor->paragraph()->length() > 1 ) {
+	cursor->setIndex( cursor->paragraph()->length() - 1 );
+	doKeyboardAction( ActionReturn );
+    }
+    insert( text, FALSE, TRUE, TRUE );
+    doKeyboardAction( ActionReturn );
+    qtextedit_ignore_readonly = FALSE;
+
+    drawCursor( FALSE );
+    *cursor = old;
+    drawCursor( TRUE );
+
+    repaintChanged();
+}
+
+/*!
+    Removes the paragraph \a para.
+*/
+
+void TQTextEdit::removeParagraph( int para )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return;
+#endif
+    resetInputContext();
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return;
+
+    for ( int i = 0; i < doc->numSelections(); ++i )
+	doc->removeSelection( i );
+
+    TQTextCursor start( doc );
+    TQTextCursor end( doc );
+    start.setParagraph( p );
+    start.setIndex( 0 );
+    end.setParagraph( p );
+    end.setIndex( p->length() - 1 );
+
+    if ( !(p == doc->firstParagraph() && p == doc->lastParagraph()) ) {
+	if ( p->next() ) {
+	    end.setParagraph( p->next() );
+	    end.setIndex( 0 );
+	} else if ( p->prev() ) {
+	    start.setParagraph( p->prev() );
+	    start.setIndex( p->prev()->length() - 1 );
+	}
+    }
+
+    doc->setSelectionStart( TQTextDocument::Temp, start );
+    doc->setSelectionEnd( TQTextDocument::Temp, end );
+    removeSelectedText( TQTextDocument::Temp );
+}
+
+/*!
+    Undoes the last operation.
+
+    If there is no operation to undo, i.e. there is no undo step in
+    the undo/redo history, nothing happens.
+
+    \sa undoAvailable() redo() undoDepth()
+*/
+
+void TQTextEdit::undo()
+{
+    clearUndoRedo();
+    if ( isReadOnly() || !doc->commands()->isUndoAvailable() || !undoEnabled )
+	return;
+
+    resetInputContext();
+    for ( int i = 0; i < (int)doc->numSelections(); ++i )
+	doc->removeSelection( i );
+
+#ifndef QT_NO_CURSOR
+    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+
+    clearUndoRedo();
+    drawCursor( FALSE );
+    TQTextCursor *c = doc->undo( cursor );
+    if ( !c ) {
+	drawCursor( TRUE );
+	return;
+    }
+    lastFormatted = 0;
+    repaintChanged();
+    ensureCursorVisible();
+    drawCursor( TRUE );
+    updateMicroFocusHint();
+    setModified();
+    // ### If we get back to a completely blank textedit, it
+    // is possible that cursor is invalid and further actions
+    // might not fix the problem, so reset the cursor here.
+    // This is copied from removeSeletedText(), it might be
+    // okay to just call that.
+    if ( !cursor->isValid() ) {
+	delete cursor;
+	cursor = new TQTextCursor( doc );
+	drawCursor( TRUE );
+	repaintContents( TRUE );
+    }
+    emit undoAvailable( isUndoAvailable() );
+    emit redoAvailable( isRedoAvailable() );
+    emit textChanged();
+}
+
+/*!
+    Redoes the last operation.
+
+    If there is no operation to redo, i.e. there is no redo step in
+    the undo/redo history, nothing happens.
+
+    \sa redoAvailable() undo() undoDepth()
+*/
+
+void TQTextEdit::redo()
+{
+    if ( isReadOnly() || !doc->commands()->isRedoAvailable() || !undoEnabled )
+	return;
+
+    resetInputContext();
+    for ( int i = 0; i < (int)doc->numSelections(); ++i )
+	doc->removeSelection( i );
+
+#ifndef QT_NO_CURSOR
+    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+
+    clearUndoRedo();
+    drawCursor( FALSE );
+    TQTextCursor *c = doc->redo( cursor );
+    if ( !c ) {
+	drawCursor( TRUE );
+	return;
+    }
+    lastFormatted = 0;
+    ensureCursorVisible();
+    repaintChanged();
+    ensureCursorVisible();
+    drawCursor( TRUE );
+    updateMicroFocusHint();
+    setModified();
+    emit undoAvailable( isUndoAvailable() );
+    emit redoAvailable( isRedoAvailable() );
+    emit textChanged();
+}
+
+/*!
+    Pastes the text from the clipboard into the text edit at the
+    current cursor position. Only plain text is pasted.
+
+    If there is no text in the clipboard nothing happens.
+
+    \sa pasteSubType() cut() TQTextEdit::copy()
+*/
+
+void TQTextEdit::paste()
+{
+#ifndef QT_NO_MIMECLIPBOARD
+    if ( isReadOnly() )
+	return;
+    TQString subType = "plain";
+    if ( textFormat() != PlainText ) {
+	TQMimeSource *m = TQApplication::clipboard()->data( d->clipboard_mode );
+	if ( !m )
+	    return;
+	if ( m->provides( "application/x-qrichtext" ) )
+	    subType = "x-qrichtext";
+    }
+
+    pasteSubType( subType.latin1() );
+    updateMicroFocusHint();
+#endif
+}
+
+void TQTextEdit::checkUndoRedoInfo( UndoRedoInfo::Type t )
+{
+    if ( undoRedoInfo.valid() && t != undoRedoInfo.type ) {
+	clearUndoRedo();
+    }
+    undoRedoInfo.type = t;
+}
+
+/*!
+    Repaints any paragraphs that have changed.
+
+    Although used extensively internally you shouldn't need to call
+    this yourself.
+*/
+
+void TQTextEdit::repaintChanged()
+{
+    if ( !isUpdatesEnabled() || !viewport()->isUpdatesEnabled() )
+	return;
+
+    TQPainter p( viewport() );
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimDrawContents( &p, contentsX(), contentsY(), visibleWidth(), visibleHeight() );
+	return;
+    }
+#endif
+    p.translate( -contentsX(), -contentsY() );
+    paintDocument( FALSE, &p, contentsX(), contentsY(), visibleWidth(), visibleHeight() );
+}
+
+#ifndef QT_NO_MIME
+TQTextDrag *TQTextEdit::dragObject( TQWidget *parent ) const
+{
+    if ( !doc->hasSelection( TQTextDocument::Standard ) ||
+	 doc->selectedText( TQTextDocument::Standard ).isEmpty() )
+	return 0;
+    if ( textFormat() != RichText )
+	return new TQTextDrag( doc->selectedText( TQTextDocument::Standard ), parent );
+    TQRichTextDrag *drag = new TQRichTextDrag( parent );
+    drag->setPlainText( doc->selectedText( TQTextDocument::Standard ) );
+    drag->setRichText( doc->selectedText( TQTextDocument::Standard, TRUE ) );
+    return drag;
+}
+#endif
+
+/*!
+    Copies the selected text (from selection 0) to the clipboard and
+    deletes it from the text edit.
+
+    If there is no selected text (in selection 0) nothing happens.
+
+    \sa TQTextEdit::copy() paste() pasteSubType()
+*/
+
+void TQTextEdit::cut()
+{
+    if ( isReadOnly() )
+	return;
+    resetInputContext();
+    normalCopy();
+    removeSelectedText();
+    updateMicroFocusHint();
+}
+
+void TQTextEdit::normalCopy()
+{
+#ifndef QT_NO_MIME
+    TQTextDrag *drag = dragObject();
+    if ( !drag )
+	return;
+#ifndef QT_NO_MIMECLIPBOARD
+    TQApplication::clipboard()->setData( drag, d->clipboard_mode );
+#endif // QT_NO_MIMECLIPBOARD
+#endif // QT_NO_MIME
+}
+
+/*!
+    Copies any selected text (from selection 0) to the clipboard.
+
+    \sa hasSelectedText() copyAvailable()
+*/
+
+void TQTextEdit::copy()
+{
+#ifndef QT_NO_CLIPBOARD
+# ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode && optimHasSelection() )
+	TQApplication::clipboard()->setText( optimSelectedText(), d->clipboard_mode );
+    else
+	normalCopy();
+# else
+    normalCopy();
+# endif
+#endif
+}
+
+/*!
+    \internal
+
+    Re-indents the current paragraph.
+*/
+
+void TQTextEdit::indent()
+{
+    if ( isReadOnly() )
+	return;
+
+    drawCursor( FALSE );
+    if ( !doc->hasSelection( TQTextDocument::Standard ) )
+	cursor->indent();
+    else
+	doc->indentSelection( TQTextDocument::Standard );
+    repaintChanged();
+    drawCursor( TRUE );
+    setModified();
+    emit textChanged();
+}
+
+/*!
+    Reimplemented to allow tabbing through links. If \a n is TRUE the
+    tab moves the focus to the next child; if \a n is FALSE the tab
+    moves the focus to the previous child. Returns TRUE if the focus
+    was moved; otherwise returns FALSE.
+ */
+
+bool TQTextEdit::focusNextPrevChild( bool n )
+{
+    if ( !isReadOnly() || !linksEnabled() )
+	return FALSE;
+    bool b = doc->focusNextPrevChild( n );
+    repaintChanged();
+    if ( b ) {
+        TQTextParagraph *p = doc->focusIndicator.parag;
+        int start = doc->focusIndicator.start;
+        int len = doc->focusIndicator.len;
+
+        int y = p->rect().y();
+        while ( p
+                && len == 0
+                && p->at( start )->isCustom()
+                && p->at( start )->customItem()->isNested() ) {
+
+            TQTextTable *t = (TQTextTable*)p->at( start )->customItem();
+            TQPtrList<TQTextTableCell> cells = t->tableCells();
+            TQTextTableCell *c;
+            for ( c = cells.first(); c; c = cells.next() ) {
+                TQTextDocument *cellDoc = c->richText();
+                if ( cellDoc->hasFocusParagraph() ) {
+                    y += c->geometry().y() + c->verticalAlignmentOffset();
+
+                    p = cellDoc->focusIndicator.parag;
+                    start = cellDoc->focusIndicator.start;
+                    len = cellDoc->focusIndicator.len;
+                    if ( p )
+                        y += p->rect().y();
+
+                    break;
+                }
+            }
+        }
+        setContentsPos( contentsX(), TQMIN( y, contentsHeight() - visibleHeight() ) );
+    }
+    return b;
+}
+
+/*!
+    \internal
+
+  This functions sets the current format to \a f. Only the fields of \a
+  f which are specified by the \a flags are used.
+*/
+
+void TQTextEdit::setFormat( TQTextFormat *f, int flags )
+{
+    if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+	drawCursor( FALSE );
+	TQTextCursor c1 = doc->selectionStartCursor( TQTextDocument::Standard );
+	c1.restoreState();
+	TQTextCursor c2 = doc->selectionEndCursor( TQTextDocument::Standard );
+	c2.restoreState();
+	if ( undoEnabled ) {
+	    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( TQTextDocument::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();
+	    }
+	}
+    }
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::setPalette( const TQPalette &p )
+{
+    TQScrollView::setPalette( p );
+    if ( textFormat() == PlainText ) {
+	TQTextFormat *f = doc->formatCollection()->defaultFormat();
+	f->setColor( colorGroup().text() );
+	updateContents();
+    }
+}
+
+/*! \internal
+  \warning In TQt 3.1 we will provide a cleaer API for the
+  functionality which is provided by this function and in TQt 4.0 this
+  function will go away.
+
+  Sets the paragraph style of the current paragraph
+  to \a dm. If \a dm is TQStyleSheetItem::DisplayListItem, the
+  type of the list item is set to \a listStyle.
+
+  \sa setAlignment()
+*/
+
+void TQTextEdit::setParagType( TQStyleSheetItem::DisplayMode dm,
+			      TQStyleSheetItem::ListStyle listStyle )
+{
+    if ( isReadOnly() )
+	return;
+
+    drawCursor( FALSE );
+    TQTextParagraph *start = cursor->paragraph();
+    TQTextParagraph *end = start;
+    if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+	start = doc->selectionStartCursor( TQTextDocument::Standard ).topParagraph();
+	end = doc->selectionEndCursor( TQTextDocument::Standard ).topParagraph();
+	if ( end->paragId() < start->paragId() )
+	    return; // do not trust our selections
+    }
+
+    clearUndoRedo();
+    undoRedoInfo.type = UndoRedoInfo::Style;
+    undoRedoInfo.id = start->paragId();
+    undoRedoInfo.eid = end->paragId();
+    undoRedoInfo.styleInformation = TQTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
+
+    while ( start != end->next() ) {
+	start->setListStyle( listStyle );
+	if ( dm == TQStyleSheetItem::DisplayListItem ) {
+	    start->setListItem( TRUE );
+	    if( start->listDepth() == 0 )
+		start->setListDepth( 1 );
+	} else if ( start->isListItem() ) {
+	    start->setListItem( FALSE );
+	    start->setListDepth( TQMAX( start->listDepth()-1, 0 ) );
+	}
+	start = start->next();
+    }
+
+    clearUndoRedo();
+    repaintChanged();
+    formatMore();
+    drawCursor( TRUE );
+    setModified();
+    emit textChanged();
+}
+
+/*!
+    Sets the alignment of the current paragraph to \a a. Valid
+    alignments are \c TQt::AlignLeft, \c TQt::AlignRight,
+    \c TQt::AlignJustify and \c TQt::AlignCenter (which centers
+    horizontally).
+*/
+
+void TQTextEdit::setAlignment( int a )
+{
+    if ( isReadOnly() || block_set_alignment )
+	return;
+
+    drawCursor( FALSE );
+    TQTextParagraph *start = cursor->paragraph();
+    TQTextParagraph *end = start;
+    if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+	start = doc->selectionStartCursor( TQTextDocument::Standard ).topParagraph();
+	end = doc->selectionEndCursor( TQTextDocument::Standard ).topParagraph();
+	if ( end->paragId() < start->paragId() )
+	    return; // do not trust our selections
+    }
+
+    clearUndoRedo();
+    undoRedoInfo.type = UndoRedoInfo::Style;
+    undoRedoInfo.id = start->paragId();
+    undoRedoInfo.eid = end->paragId();
+    undoRedoInfo.styleInformation = TQTextStyleCommand::readStyleInformation( doc, undoRedoInfo.id, undoRedoInfo.eid );
+
+    while ( start != end->next() ) {
+	start->setAlignment( a );
+	start = start->next();
+    }
+
+    clearUndoRedo();
+    repaintChanged();
+    formatMore();
+    drawCursor( TRUE );
+    if ( currentAlignment != a ) {
+	currentAlignment = a;
+	emit currentAlignmentChanged( currentAlignment );
+    }
+    setModified();
+    emit textChanged();
+}
+
+void TQTextEdit::updateCurrentFormat()
+{
+    int i = cursor->index();
+    if ( i > 0 )
+	--i;
+    if ( doc->useFormatCollection() &&
+	 ( !currentFormat || currentFormat->key() != cursor->paragraph()->at( i )->format()->key() ) ) {
+	if ( currentFormat )
+	    currentFormat->removeRef();
+	currentFormat = doc->formatCollection()->format( cursor->paragraph()->at( i )->format() );
+	if ( currentFormat->isMisspelled() ) {
+	    currentFormat->removeRef();
+	    currentFormat = doc->formatCollection()->format( currentFormat->font(), currentFormat->color() );
+	}
+	emit currentFontChanged( currentFormat->font() );
+	emit currentColorChanged( currentFormat->color() );
+	emit currentVerticalAlignmentChanged( (VerticalAlignment)currentFormat->vAlign() );
+    }
+
+    if ( currentAlignment != cursor->paragraph()->alignment() ) {
+	currentAlignment = cursor->paragraph()->alignment();
+	block_set_alignment = TRUE;
+	emit currentAlignmentChanged( currentAlignment );
+	block_set_alignment = FALSE;
+    }
+}
+
+/*!
+    If \a b is TRUE sets the current format to italic; otherwise sets
+    the current format to non-italic.
+
+    \sa italic()
+*/
+
+void TQTextEdit::setItalic( bool b )
+{
+    TQTextFormat f( *currentFormat );
+    f.setItalic( b );
+    TQTextFormat *f2 = doc->formatCollection()->format( &f );
+    setFormat(f2, TQTextFormat::Italic );
+}
+
+/*!
+    If \a b is TRUE sets the current format to bold; otherwise sets
+    the current format to non-bold.
+
+    \sa bold()
+*/
+
+void TQTextEdit::setBold( bool b )
+{
+    TQTextFormat f( *currentFormat );
+    f.setBold( b );
+    TQTextFormat *f2 = doc->formatCollection()->format( &f );
+    setFormat( f2, TQTextFormat::Bold );
+}
+
+/*!
+    If \a b is TRUE sets the current format to underline; otherwise
+    sets the current format to non-underline.
+
+    \sa underline()
+*/
+
+void TQTextEdit::setUnderline( bool b )
+{
+    TQTextFormat f( *currentFormat );
+    f.setUnderline( b );
+    TQTextFormat *f2 = doc->formatCollection()->format( &f );
+    setFormat( f2, TQTextFormat::Underline );
+}
+
+/*!
+    Sets the font family of the current format to \a fontFamily.
+
+    \sa family() setCurrentFont()
+*/
+
+void TQTextEdit::setFamily( const TQString &fontFamily )
+{
+    TQTextFormat f( *currentFormat );
+    f.setFamily( fontFamily );
+    TQTextFormat *f2 = doc->formatCollection()->format( &f );
+    setFormat( f2, TQTextFormat::Family );
+}
+
+/*!
+    Sets the point size of the current format to \a s.
+
+    Note that if \a s is zero or negative, the behaviour of this
+    function is not defined.
+
+    \sa pointSize() setCurrentFont() setFamily()
+*/
+
+void TQTextEdit::setPointSize( int s )
+{
+    TQTextFormat f( *currentFormat );
+    f.setPointSize( s );
+    TQTextFormat *f2 = doc->formatCollection()->format( &f );
+    setFormat( f2, TQTextFormat::Size );
+}
+
+/*!
+    Sets the color of the current format, i.e. of the text, to \a c.
+
+    \sa color() setPaper()
+*/
+
+void TQTextEdit::setColor( const TQColor &c )
+{
+    TQTextFormat f( *currentFormat );
+    f.setColor( c );
+    TQTextFormat *f2 = doc->formatCollection()->format( &f );
+    setFormat( f2, TQTextFormat::Color );
+}
+
+/*!
+    Sets the vertical alignment of the current format, i.e. of the
+    text, to \a a.
+
+    \sa color() setPaper()
+*/
+
+void TQTextEdit::setVerticalAlignment( VerticalAlignment a )
+{
+    TQTextFormat f( *currentFormat );
+    f.setVAlign( (TQTextFormat::VerticalAlignment)a );
+    TQTextFormat *f2 = doc->formatCollection()->format( &f );
+    setFormat( f2, TQTextFormat::VAlign );
+}
+
+void TQTextEdit::setFontInternal( const TQFont &f_ )
+{
+    TQTextFormat f( *currentFormat );
+    f.setFont( f_ );
+    TQTextFormat *f2 = doc->formatCollection()->format( &f );
+    setFormat( f2, TQTextFormat::Font );
+}
+
+
+TQString TQTextEdit::text() const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return optimText();
+#endif
+
+    TQTextParagraph *p = doc->firstParagraph();
+    if ( !p || (!p->next() && p->length() <= 1) )
+	return TQString::fromLatin1("");
+
+    if ( isReadOnly() )
+	return doc->originalText();
+    return doc->text();
+}
+
+/*!
+    \overload
+
+    Returns the text of paragraph \a para.
+
+    If textFormat() is \c RichText the text will contain HTML
+    formatting tags.
+*/
+
+TQString TQTextEdit::text( int para ) const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode && (d->od->numLines >= para) ) {
+	TQString paraStr = d->od->lines[ LOGOFFSET(para) ];
+	if ( paraStr.isEmpty() )
+	    paraStr = "\n";
+	return paraStr;
+    } else
+#endif
+    return doc->text( para );
+}
+
+/*!
+    \overload
+
+    Changes the text of the text edit to the string \a text and the
+    context to \a context. Any previous text is removed.
+
+    \a text may be interpreted either as plain text or as rich text,
+    depending on the textFormat(). The default setting is \c AutoText,
+    i.e. the text edit auto-detects the format from \a text.
+
+    For rich text the rendering style and available tags are defined
+    by a styleSheet(); see TQStyleSheet for details.
+
+    The optional \a context is a path which the text edit's
+    TQMimeSourceFactory uses to resolve the locations of files and
+    images. (See \l{TQTextEdit::TQTextEdit()}.) It is passed to the text
+    edit's TQMimeSourceFactory when quering data.
+
+    Note that the undo/redo history is cleared by this function.
+
+    \sa text(), setTextFormat()
+*/
+
+void TQTextEdit::setText( const TQString &text, const TQString &context )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimSetText( text );
+	return;
+    }
+#endif
+    resetInputContext();
+    if ( !isModified() && isReadOnly() &&
+	 this->context() == context && this->text() == text )
+	return;
+
+    emit undoAvailable( FALSE );
+    emit redoAvailable( FALSE );
+    undoRedoInfo.clear();
+    doc->commands()->clear();
+
+    lastFormatted = 0;
+    int oldCursorPos = cursor->index();
+    int oldCursorPar = cursor->paragraph()->paragId();
+    cursor->restoreState();
+    delete cursor;
+    doc->setText( text, context );
+
+    if ( wrapMode == FixedPixelWidth ) {
+	resizeContents( wrapWidth, 0 );
+	doc->setWidth( wrapWidth );
+	doc->setMinimumWidth( wrapWidth );
+    } else {
+	doc->setMinimumWidth( -1 );
+	resizeContents( 0, 0 );
+    }
+
+    lastFormatted = doc->firstParagraph();
+    cursor = new TQTextCursor( doc );
+    updateContents();
+
+    if ( isModified() )
+	setModified( FALSE );
+    emit textChanged();
+    if ( cursor->index() != oldCursorPos || cursor->paragraph()->paragId() != oldCursorPar ) {
+	emit cursorPositionChanged( cursor );
+	emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
+    }
+    formatMore();
+    updateCurrentFormat();
+    d->scrollToAnchor = TQString::null;
+}
+
+/*!
+    \property TQTextEdit::text
+    \brief the text edit's text
+
+    There is no default text.
+
+    On setting, any previous text is deleted.
+
+    The text may be interpreted either as plain text or as rich text,
+    depending on the textFormat(). The default setting is \c AutoText,
+    i.e. the text edit auto-detects the format of the text.
+
+    For richtext, calling text() on an editable TQTextEdit will cause
+    the text to be regenerated from the textedit. This may mean that
+    the TQString returned may not be exactly the same as the one that
+    was set.
+
+    \sa textFormat
+*/
+
+
+/*!
+    \property TQTextEdit::readOnly
+    \brief whether the text edit is read-only
+
+    In a read-only text edit the user can only navigate through the
+    text and select text; modifying the text is not possible.
+
+    This property's default is FALSE.
+*/
+
+/*!
+    Finds the next occurrence of the string, \a expr. Returns TRUE if
+    \a expr was found; otherwise returns FALSE.
+
+    If \a para and \a index are both 0 the search begins from the
+    current cursor position. If \a para and \a index are both not 0,
+    the search begins from the \a *index character position in the
+    \a *para paragraph.
+
+    If \a cs is TRUE the search is case sensitive, otherwise it is
+    case insensitive. If \a wo is TRUE the search looks for whole word
+    matches only; otherwise it searches for any matching text. If \a
+    forward is TRUE (the default) the search works forward from the
+    starting position to the end of the text, otherwise it works
+    backwards to the beginning of the text.
+
+    If \a expr is found the function returns TRUE. If \a index and \a
+    para are not 0, the number of the paragraph in which the first
+    character of the match was found is put into \a *para, and the
+    index position of that character within the paragraph is put into
+    \a *index.
+
+    If \a expr is not found the function returns FALSE. If \a index
+    and \a para are not 0 and \a expr is not found, \a *index
+    and \a *para are undefined.
+
+    Please note that this function will make the next occurrence of
+    the string (if found) the current selection, and will thus
+    modify the cursor position.
+
+    Using the \a para and \a index parameters will not work correctly
+    in case the document contains tables.
+*/
+
+bool TQTextEdit::find( const TQString &expr, bool cs, bool wo, bool forward,
+		      int *para, int *index )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return optimFind( expr, cs, wo, forward, para, index );
+#endif
+    drawCursor( FALSE );
+#ifndef QT_NO_CURSOR
+    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+    TQTextCursor findcur = *cursor;
+    if ( para && index ) {
+	if ( doc->paragAt( *para ) )
+	    findcur.gotoPosition( doc->paragAt(*para), *index );
+	else
+	    findcur.gotoEnd();
+    } else if ( doc->hasSelection( TQTextDocument::Standard ) ){
+	// maks sure we do not find the same selection again
+	if ( forward )
+	    findcur.gotoNextLetter();
+	else
+	    findcur.gotoPreviousLetter();
+    } else if (!forward && findcur.index() == 0 && findcur.paragraph() == findcur.topParagraph()) {
+	findcur.gotoEnd();
+    }
+    removeSelection( TQTextDocument::Standard );
+    bool found = doc->find( findcur, expr, cs, wo, forward );
+    if ( found ) {
+	if ( para )
+	    *para = findcur.paragraph()->paragId();
+	if ( index )
+	    *index = findcur.index();
+	*cursor = findcur;
+	repaintChanged();
+	ensureCursorVisible();
+    }
+    drawCursor( TRUE );
+    if (found) {
+	emit cursorPositionChanged( cursor );
+	emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
+    }
+    return found;
+}
+
+void TQTextEdit::blinkCursor()
+{
+    if ( !cursorVisible )
+	return;
+    bool cv = cursorVisible;
+    blinkCursorVisible = !blinkCursorVisible;
+    drawCursor( blinkCursorVisible );
+    cursorVisible = cv;
+}
+
+/*!
+    Sets the cursor to position \a index in paragraph \a para.
+
+    \sa getCursorPosition()
+*/
+
+void TQTextEdit::setCursorPosition( int para, int index )
+{
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return;
+
+    resetInputContext();
+    if ( index > p->length() - 1 )
+	index = p->length() - 1;
+
+    drawCursor( FALSE );
+    cursor->setParagraph( p );
+    cursor->setIndex( index );
+    ensureCursorVisible();
+    drawCursor( TRUE );
+    updateCurrentFormat();
+    emit cursorPositionChanged( cursor );
+    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
+}
+
+/*!
+    This function sets the \a *para and \a *index parameters to the
+    current cursor position. \a para and \a index must not be 0.
+
+    \sa setCursorPosition()
+*/
+
+void TQTextEdit::getCursorPosition( int *para, int *index ) const
+{
+    if ( !para || !index )
+	return;
+    *para = cursor->paragraph()->paragId();
+    *index = cursor->index();
+}
+
+/*!
+    Sets a selection which starts at position \a indexFrom in
+    paragraph \a paraFrom and ends at position \a indexTo in paragraph
+    \a paraTo.
+
+    Any existing selections which have a different id (\a selNum) are
+    left alone, but if an existing selection has the same id as \a
+    selNum it is removed and replaced by this selection.
+
+    Uses the selection settings of selection \a selNum. If \a selNum
+    is 0, this is the default selection.
+
+    The cursor is moved to the end of the selection if \a selNum is 0,
+    otherwise the cursor position remains unchanged.
+
+    \sa getSelection() selectedText
+*/
+
+void TQTextEdit::setSelection( int paraFrom, int indexFrom,
+			      int paraTo, int indexTo, int selNum )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if (d->optimMode) {
+	optimSetSelection(paraFrom, indexFrom, paraTo, indexTo);
+	repaintContents(FALSE);
+	return;
+    }
+#endif
+    resetInputContext();
+    if ( doc->hasSelection( selNum ) ) {
+	doc->removeSelection( selNum );
+	repaintChanged();
+    }
+    if ( selNum > doc->numSelections() - 1 )
+	doc->addSelection( selNum );
+    TQTextParagraph *p1 = doc->paragAt( paraFrom );
+    if ( !p1 )
+	return;
+    TQTextParagraph *p2 = doc->paragAt( paraTo );
+    if ( !p2 )
+	return;
+
+    if ( indexFrom > p1->length() - 1 )
+	indexFrom = p1->length() - 1;
+    if ( indexTo > p2->length() - 1 )
+	indexTo = p2->length() - 1;
+
+    drawCursor( FALSE );
+    TQTextCursor c = *cursor;
+    TQTextCursor oldCursor = *cursor;
+    c.setParagraph( p1 );
+    c.setIndex( indexFrom );
+    cursor->setParagraph( p2 );
+    cursor->setIndex( indexTo );
+    doc->setSelectionStart( selNum, c );
+    doc->setSelectionEnd( selNum, *cursor );
+    repaintChanged();
+    ensureCursorVisible();
+    if ( selNum != TQTextDocument::Standard )
+	*cursor = oldCursor;
+    drawCursor( TRUE );
+}
+
+/*!
+    If there is a selection, \a *paraFrom is set to the number of the
+    paragraph in which the selection begins and \a *paraTo is set to
+    the number of the paragraph in which the selection ends. (They
+    could be the same.) \a *indexFrom is set to the index at which the
+    selection begins within \a *paraFrom, and \a *indexTo is set to
+    the index at which the selection ends within \a *paraTo.
+
+    If there is no selection, \a *paraFrom, \a *indexFrom, \a *paraTo
+    and \a *indexTo are all set to -1.
+
+    If \a paraFrom, \a indexFrom, \a paraTo or \a indexTo is 0 this
+    function does nothing.
+
+    The \a selNum is the number of the selection (multiple selections
+    are supported). It defaults to 0 (the default selection).
+
+    \sa setSelection() selectedText
+*/
+
+void TQTextEdit::getSelection( int *paraFrom, int *indexFrom,
+			      int *paraTo, int *indexTo, int selNum ) const
+{
+    if ( !paraFrom || !paraTo || !indexFrom || !indexTo )
+	return;
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if (d->optimMode) {
+	*paraFrom = d->od->selStart.line;
+	*paraTo = d->od->selEnd.line;
+	*indexFrom = d->od->selStart.index;
+	*indexTo = d->od->selEnd.index;
+	return;
+    }
+#endif
+    if ( !doc->hasSelection( selNum ) ) {
+	*paraFrom = -1;
+	*indexFrom = -1;
+	*paraTo = -1;
+	*indexTo = -1;
+	return;
+    }
+
+    doc->selectionStart( selNum, *paraFrom, *indexFrom );
+    doc->selectionEnd( selNum, *paraTo, *indexTo );
+}
+
+/*!
+    \property TQTextEdit::textFormat
+    \brief the text format: rich text, plain text, log text or auto text.
+
+    The text format is one of the following:
+    \list
+    \i PlainText - all characters, except newlines, are displayed
+    verbatim, including spaces. Whenever a newline appears in the text
+    the text edit inserts a hard line break and begins a new
+    paragraph.
+    \i RichText - rich text rendering. The available styles are
+    defined in the default stylesheet TQStyleSheet::defaultSheet().
+    \i LogText -  optimized mode for very large texts. Supports a very
+    limited set of formatting tags (color, bold, underline and italic
+    settings).
+    \i AutoText - this is the default. The text edit autodetects which
+    rendering style is best, \c PlainText or \c RichText. This is done
+    by using the TQStyleSheet::mightBeRichText() function.
+    \endlist
+*/
+
+void TQTextEdit::setTextFormat( TextFormat format )
+{
+    doc->setTextFormat( format );
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    checkOptimMode();
+#endif
+}
+
+TQt::TextFormat TQTextEdit::textFormat() const
+{
+    return doc->textFormat();
+}
+
+/*!
+    Returns the number of paragraphs in the text; an empty textedit is always
+    considered to have one paragraph, so 1 is returned in this case.
+*/
+
+int TQTextEdit::paragraphs() const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	return d->od->numLines;
+    }
+#endif
+    return doc->lastParagraph()->paragId() + 1;
+}
+
+/*!
+    Returns the number of lines in paragraph \a para, or -1 if there
+    is no paragraph with index \a para.
+*/
+
+int TQTextEdit::linesOfParagraph( int para ) const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	if ( d->od->numLines >= para )
+	    return 1;
+	else
+	    return -1;
+    }
+#endif
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return -1;
+    return p->lines();
+}
+
+/*!
+    Returns the length of the paragraph \a para (i.e. the number of
+    characters), or -1 if there is no paragraph with index \a para.
+
+    This function ignores newlines.
+*/
+
+int TQTextEdit::paragraphLength( int para ) const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	if ( d->od->numLines >= para ) {
+	    if ( d->od->lines[ LOGOFFSET(para) ].isEmpty() ) // CR
+		return 1;
+	    else
+		return d->od->lines[ LOGOFFSET(para) ].length();
+	}
+	return -1;
+    }
+#endif
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return -1;
+    return p->length() - 1;
+}
+
+/*!
+    Returns the number of lines in the text edit; this could be 0.
+
+    \warning This function may be slow. Lines change all the time
+    during word wrapping, so this function has to iterate over all the
+    paragraphs and get the number of lines from each one individually.
+*/
+
+int TQTextEdit::lines() const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	return d->od->numLines;
+    }
+#endif
+    TQTextParagraph *p = doc->firstParagraph();
+    int l = 0;
+    while ( p ) {
+	l += p->lines();
+	p = p->next();
+    }
+
+    return l;
+}
+
+/*!
+    Returns the line number of the line in paragraph \a para in which
+    the character at position \a index appears. The \a index position is
+    relative to the beginning of the paragraph. If there is no such
+    paragraph or no such character at the \a index position (e.g. the
+    index is out of range) -1 is returned.
+*/
+
+int TQTextEdit::lineOfChar( int para, int index )
+{
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return -1;
+
+    int idx, line;
+    TQTextStringChar *c = p->lineStartOfChar( index, &idx, &line );
+    if ( !c )
+	return -1;
+
+    return line;
+}
+
+void TQTextEdit::setModified( bool m )
+{
+    bool oldModified = modified;
+    modified = m;
+    if ( modified && doc->oTextValid )
+	doc->invalidateOriginalText();
+    if ( oldModified != modified )
+	emit modificationChanged( modified );
+}
+
+/*!
+    \property TQTextEdit::modified
+    \brief whether the document has been modified by the user
+*/
+
+bool TQTextEdit::isModified() const
+{
+    return modified;
+}
+
+void TQTextEdit::setModified()
+{
+    if ( !isModified() )
+	setModified( TRUE );
+}
+
+/*!
+    Returns TRUE if the current format is italic; otherwise returns FALSE.
+
+    \sa setItalic()
+*/
+
+bool TQTextEdit::italic() const
+{
+    return currentFormat->font().italic();
+}
+
+/*!
+    Returns TRUE if the current format is bold; otherwise returns FALSE.
+
+    \sa setBold()
+*/
+
+bool TQTextEdit::bold() const
+{
+    return currentFormat->font().bold();
+}
+
+/*!
+    Returns TRUE if the current format is underlined; otherwise returns
+    FALSE.
+
+    \sa setUnderline()
+*/
+
+bool TQTextEdit::underline() const
+{
+    return currentFormat->font().underline();
+}
+
+/*!
+    Returns the font family of the current format.
+
+    \sa setFamily() setCurrentFont() setPointSize()
+*/
+
+TQString TQTextEdit::family() const
+{
+    return currentFormat->font().family();
+}
+
+/*!
+    Returns the point size of the font of the current format.
+
+    \sa setFamily() setCurrentFont() setPointSize()
+*/
+
+int TQTextEdit::pointSize() const
+{
+    return currentFormat->font().pointSize();
+}
+
+/*!
+    Returns the color of the current format.
+
+    \sa setColor() setPaper()
+*/
+
+TQColor TQTextEdit::color() const
+{
+    return currentFormat->color();
+}
+
+/*!
+    \obsolete
+
+    Returns TQScrollView::font()
+
+    \warning In previous versions this function returned the font of
+    the current format. This lead to confusion. Please use
+    currentFont() instead.
+*/
+
+TQFont TQTextEdit::font() const
+{
+    return TQScrollView::font();
+}
+
+/*!
+    Returns the font of the current format.
+
+    \sa setCurrentFont() setFamily() setPointSize()
+*/
+
+TQFont TQTextEdit::currentFont() const
+{
+    return currentFormat->font();
+}
+
+
+/*!
+    Returns the alignment of the current paragraph.
+
+    \sa setAlignment()
+*/
+
+int TQTextEdit::alignment() const
+{
+    return currentAlignment;
+}
+
+void TQTextEdit::startDrag()
+{
+#ifndef QT_NO_DRAGANDDROP
+    mousePressed = FALSE;
+    inDoubleClick = FALSE;
+    TQDragObject *drag = dragObject( viewport() );
+    if ( !drag )
+	return;
+    if ( isReadOnly() ) {
+	drag->dragCopy();
+    } else {
+	if ( drag->drag() && TQDragObject::target() != this && TQDragObject::target() != viewport() )
+	    removeSelectedText();
+    }
+#endif
+}
+
+/*!
+    If \a select is TRUE (the default), all the text is selected as
+    selection 0. If \a select is FALSE any selected text is
+    unselected, i.e. the default selection (selection 0) is cleared.
+
+    \sa selectedText
+*/
+
+void TQTextEdit::selectAll( bool select )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	if ( select )
+	    optimSelectAll();
+	else
+	    optimRemoveSelection();
+	return;
+    }
+#endif
+    if ( !select )
+	doc->removeSelection( TQTextDocument::Standard );
+    else
+	doc->selectAll( TQTextDocument::Standard );
+    repaintChanged();
+    emit copyAvailable( doc->hasSelection( TQTextDocument::Standard ) );
+    emit selectionChanged();
+#ifndef QT_NO_CURSOR
+    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+}
+
+void TQTextEdit::UndoRedoInfo::clear()
+{
+    if ( valid() ) {
+	if ( type == Insert || type == Return )
+	    doc->addCommand( new TQTextInsertCommand( doc, id, index, d->text.rawData(), styleInformation ) );
+	else if ( type == Format )
+	    doc->addCommand( new TQTextFormatCommand( doc, id, index, eid, eindex, d->text.rawData(), format, flags ) );
+	else if ( type == Style )
+	    doc->addCommand( new TQTextStyleCommand( doc, id, eid, styleInformation ) );
+	else if ( type != Invalid ) {
+	    doc->addCommand( new TQTextDeleteCommand( doc, id, index, d->text.rawData(), styleInformation ) );
+	}
+    }
+    type = Invalid;
+    d->text = TQString::null;
+    id = -1;
+    index = -1;
+    styleInformation = TQByteArray();
+}
+
+
+/*!
+    If there is some selected text (in selection 0) it is deleted. If
+    there is no selected text (in selection 0) the character to the
+    right of the text cursor is deleted.
+
+    \sa removeSelectedText() cut()
+*/
+
+void TQTextEdit::del()
+{
+    if ( doc->hasSelection( TQTextDocument::Standard ) ) {
+	removeSelectedText();
+	return;
+    }
+
+    doKeyboardAction( ActionDelete );
+}
+
+
+TQTextEdit::UndoRedoInfo::UndoRedoInfo( TQTextDocument *dc )
+    : type( Invalid ), doc( dc )
+{
+    d = new TQUndoRedoInfoPrivate;
+    d->text = TQString::null;
+    id = -1;
+    index = -1;
+}
+
+TQTextEdit::UndoRedoInfo::~UndoRedoInfo()
+{
+    delete d;
+}
+
+bool TQTextEdit::UndoRedoInfo::valid() const
+{
+    return id >= 0 &&  type != Invalid;
+}
+
+/*!
+    \internal
+
+  Resets the current format to the default format.
+*/
+
+void TQTextEdit::resetFormat()
+{
+    setAlignment( TQt::AlignAuto );
+    setParagType( TQStyleSheetItem::DisplayBlock, TQStyleSheetItem::ListDisc );
+    setFormat( doc->formatCollection()->defaultFormat(), TQTextFormat::Format );
+}
+
+/*!
+    Returns the TQStyleSheet which is being used by this text edit.
+
+    \sa setStyleSheet()
+*/
+
+TQStyleSheet* TQTextEdit::styleSheet() const
+{
+    return doc->styleSheet();
+}
+
+/*!
+    Sets the stylesheet to use with this text edit to \a styleSheet.
+    Changes will only take effect for new text added with setText() or
+    append().
+
+    \sa styleSheet()
+*/
+
+void TQTextEdit::setStyleSheet( TQStyleSheet* styleSheet )
+{
+    doc->setStyleSheet( styleSheet );
+}
+
+/*!
+    \property TQTextEdit::paper
+    \brief the background (paper) brush.
+
+    The brush that is currently used to draw the background of the
+    text edit. The initial setting is an empty brush.
+*/
+
+void TQTextEdit::setPaper( const TQBrush& pap )
+{
+    doc->setPaper( new TQBrush( pap ) );
+
+    if ( pap.pixmap() ) {
+        viewport()->setBackgroundPixmap( *pap.pixmap() );
+    } else {
+        setPaletteBackgroundColor( pap.color() );
+        viewport()->setPaletteBackgroundColor( pap.color() );
+    }
+
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    // force a repaint of the entire viewport - using updateContents()
+    // would clip the coords to the content size
+    if (d->optimMode)
+	repaintContents(contentsX(), contentsY(), viewport()->width(), viewport()->height());
+    else
+#endif
+	updateContents();
+}
+
+TQBrush TQTextEdit::paper() const
+{
+    if ( doc->paper() )
+	return *doc->paper();
+    return TQBrush( colorGroup().base() );
+}
+
+/*!
+    \property TQTextEdit::linkUnderline
+    \brief whether hypertext links will be underlined
+
+    If TRUE (the default) hypertext links will be displayed
+    underlined. If FALSE links will not be displayed underlined.
+*/
+
+void TQTextEdit::setLinkUnderline( bool b )
+{
+    if ( doc->underlineLinks() == b )
+	return;
+    doc->setUnderlineLinks( b );
+    repaintChanged();
+}
+
+bool TQTextEdit::linkUnderline() const
+{
+    return doc->underlineLinks();
+}
+
+/*!
+    Sets the text edit's mimesource factory to \a factory. See
+    TQMimeSourceFactory for further details.
+
+    \sa mimeSourceFactory()
+ */
+
+#ifndef QT_NO_MIME
+void TQTextEdit::setMimeSourceFactory( TQMimeSourceFactory* factory )
+{
+    doc->setMimeSourceFactory( factory );
+}
+
+/*!
+    Returns the TQMimeSourceFactory which is being used by this text
+    edit.
+
+    \sa setMimeSourceFactory()
+*/
+
+TQMimeSourceFactory* TQTextEdit::mimeSourceFactory() const
+{
+    return doc->mimeSourceFactory();
+}
+#endif
+
+/*!
+    Returns how many pixels high the text edit needs to be to display
+    all the text if the text edit is \a w pixels wide.
+*/
+
+int TQTextEdit::heightForWidth( int w ) const
+{
+    int oldw = doc->width();
+    doc->doLayout( 0, w );
+    int h = doc->height();
+    doc->setWidth( oldw );
+    doc->invalidate();
+    ( (TQTextEdit*)this )->formatMore();
+    return h;
+}
+
+/*!
+    Appends a new paragraph with \a text to the end of the text edit. Note that
+    the undo/redo history is cleared by this function, and no undo
+    history is kept for appends which makes them faster than
+    insert()s. If you want to append text which is added to the
+    undo/redo history as well, use insertParagraph().
+*/
+
+void TQTextEdit::append( const TQString &text )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimAppend( text );
+	return;
+    }
+#endif
+    // flush and clear the undo/redo stack if necessary
+    undoRedoInfo.clear();
+    doc->commands()->clear();
+
+    doc->removeSelection( TQTextDocument::Standard );
+    TextFormat f = doc->textFormat();
+    if ( f == AutoText ) {
+	if ( TQStyleSheet::mightBeRichText( text ) )
+	    f = RichText;
+	else
+	    f = PlainText;
+    }
+
+    drawCursor( FALSE );
+    TQTextCursor oldc( *cursor );
+    ensureFormatted( doc->lastParagraph() );
+    bool atBottom = contentsY() >= contentsHeight() - visibleHeight();
+    cursor->gotoEnd();
+    if ( cursor->index() > 0 )
+	cursor->splitAndInsertEmptyParagraph();
+    TQTextCursor oldCursor2 = *cursor;
+
+    if ( f == TQt::PlainText ) {
+	cursor->insert( text, TRUE );
+	if ( doc->useFormatCollection() && !doc->preProcessor() &&
+	     currentFormat != cursor->paragraph()->at( cursor->index() )->format() ) {
+	    doc->setSelectionStart( TQTextDocument::Temp, oldCursor2 );
+	    doc->setSelectionEnd( TQTextDocument::Temp, *cursor );
+	    doc->setFormat( TQTextDocument::Temp, currentFormat, TQTextFormat::Format );
+	    doc->removeSelection( TQTextDocument::Temp );
+	}
+    } else {
+	cursor->paragraph()->setListItem( FALSE );
+	cursor->paragraph()->setListDepth( 0 );
+	if ( cursor->paragraph()->prev() )
+	    cursor->paragraph()->prev()->invalidate(0); // vertical margins might have to change
+	doc->setRichTextInternal( text );
+    }
+    formatMore();
+    repaintChanged();
+    if ( atBottom )
+        scrollToBottom();
+    *cursor = oldc;
+    if ( !isReadOnly() )
+	cursorVisible = TRUE;
+    setModified();
+    emit textChanged();
+}
+
+/*!
+    \property TQTextEdit::hasSelectedText
+    \brief whether some text is selected in selection 0
+*/
+
+bool TQTextEdit::hasSelectedText() const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return optimHasSelection();
+    else
+#endif
+	return doc->hasSelection( TQTextDocument::Standard );
+}
+
+/*!
+    \property TQTextEdit::selectedText
+    \brief The selected text (from selection 0) or an empty string if
+    there is no currently selected text (in selection 0).
+
+    The text is always returned as \c PlainText if the textFormat() is
+    \c PlainText or \c AutoText, otherwise it is returned as HTML.
+
+    \sa hasSelectedText
+*/
+
+TQString TQTextEdit::selectedText() const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return optimSelectedText();
+    else
+#endif
+	return doc->selectedText( TQTextDocument::Standard, textFormat() == RichText );
+}
+
+bool TQTextEdit::handleReadOnlyKeyEvent( TQKeyEvent *e )
+{
+    switch( e->key() ) {
+    case Key_Down:
+	setContentsPos( contentsX(), contentsY() + 10 );
+	break;
+    case Key_Up:
+	setContentsPos( contentsX(), contentsY() - 10 );
+	break;
+    case Key_Left:
+	setContentsPos( contentsX() - 10, contentsY() );
+	break;
+    case Key_Right:
+	setContentsPos( contentsX() + 10, contentsY() );
+	break;
+    case Key_PageUp:
+	setContentsPos( contentsX(), contentsY() - visibleHeight() );
+	break;
+    case Key_PageDown:
+	setContentsPos( contentsX(), contentsY() + visibleHeight() );
+	break;
+    case Key_Home:
+	setContentsPos( contentsX(), 0 );
+	break;
+    case Key_End:
+	setContentsPos( contentsX(), contentsHeight() - visibleHeight() );
+	break;
+    case Key_F16: // Copy key on Sun keyboards
+	copy();
+	break;
+#ifndef QT_NO_NETWORKPROTOCOL
+    case Key_Return:
+    case Key_Enter:
+    case Key_Space: {
+	if (!doc->focusIndicator.href.isEmpty()
+		|| !doc->focusIndicator.name.isEmpty()) {
+	    if (!doc->focusIndicator.href.isEmpty()) {
+		TQUrl u( doc->context(), doc->focusIndicator.href, TRUE );
+		emitLinkClicked( u.toString( FALSE, FALSE ) );
+	    }
+	    if (!doc->focusIndicator.name.isEmpty()) {
+		if (::qt_cast<TQTextBrowser*>(this)) { // change for 4.0
+		    TQConnectionList *clist = receivers(
+			    "anchorClicked(const TQString&,const TQString&)");
+		    if (!signalsBlocked() && clist) {
+			TQUObject o[3];
+			static_QUType_TQString.set(o+1,
+				doc->focusIndicator.name);
+			static_QUType_TQString.set(o+2,
+				doc->focusIndicator.href);
+			activate_signal( clist, o);
+		    }
+		}
+	    }
+#ifndef QT_NO_CURSOR
+	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+	}
+    } break;
+#endif
+    default:
+	if ( e->state() & ControlButton ) {
+	    switch ( e->key() ) {
+	    case Key_C: case Key_F16: // Copy key on Sun keyboards
+		copy();
+		break;
+#ifdef Q_WS_WIN
+	    case Key_Insert:
+		copy();
+		break;
+	    case Key_A:
+		selectAll();
+		break;
+#endif
+	    }
+
+	}
+	return FALSE;
+    }
+    return TRUE;
+}
+
+/*!
+    Returns the context of the text edit. The context is a path which
+    the text edit's TQMimeSourceFactory uses to resolve the locations
+    of files and images.
+
+    \sa text
+*/
+
+TQString TQTextEdit::context() const
+{
+    return doc->context();
+}
+
+/*!
+    \property TQTextEdit::documentTitle
+    \brief the title of the document parsed from the text.
+
+    For \c PlainText the title will be an empty string. For \c
+    RichText the title will be the text between the \c{<title>} tags,
+    if present, otherwise an empty string.
+*/
+
+TQString TQTextEdit::documentTitle() const
+{
+    return doc->attributes()[ "title" ];
+}
+
+void TQTextEdit::makeParagVisible( TQTextParagraph *p )
+{
+    setContentsPos( contentsX(), TQMIN( p->rect().y(), contentsHeight() - visibleHeight() ) );
+}
+
+/*!
+    Scrolls the text edit to make the text at the anchor called \a
+    name visible, if it can be found in the document. If the anchor
+    isn't found no scrolling will occur. An anchor is defined using
+    the HTML anchor tag, e.g. \c{<a name="target">}.
+*/
+
+void TQTextEdit::scrollToAnchor( const TQString& name )
+{
+    if ( !isVisible() ) {
+	d->scrollToAnchor = name;
+	return;
+    }
+    if ( name.isEmpty() )
+	return;
+    sync();
+    TQTextCursor cursor( doc );
+    TQTextParagraph* last = doc->lastParagraph();
+    for (;;) {
+	TQTextStringChar* c = cursor.paragraph()->at( cursor.index() );
+	if( c->isAnchor() ) {
+	    TQString a = c->anchorName();
+	    if ( a == name ||
+		 (a.contains( '#' ) && TQStringList::split( '#', a ).contains( name ) ) ) {
+		setContentsPos( contentsX(), TQMIN( cursor.paragraph()->rect().top() + cursor.totalOffsetY(), contentsHeight() - visibleHeight() ) );
+		break;
+	    }
+	}
+	if ( cursor.paragraph() == last && cursor.atParagEnd()  )
+	    break;
+	cursor.gotoNextLetter();
+    }
+}
+
+#if (QT_VERSION-0 >= 0x040000)
+#error "function anchorAt(const TQPoint& pos) should be merged into function anchorAt(const TQPoint& pos, AnchorAttribute attr)"
+#endif
+
+/*!
+    \overload
+
+    If there is an anchor at position \a pos (in contents
+    coordinates), its \c href is returned, otherwise TQString::null is
+    returned.
+*/
+
+TQString TQTextEdit::anchorAt( const TQPoint& pos )
+{
+    return anchorAt(pos, AnchorHref);
+}
+
+/*!
+    If there is an anchor at position \a pos (in contents
+    coordinates), the text for attribute \a attr is returned,
+    otherwise TQString::null is returned.
+*/
+
+TQString TQTextEdit::anchorAt( const TQPoint& pos, AnchorAttribute attr )
+{
+    TQTextCursor c( doc );
+    placeCursor( pos, &c );
+    switch(attr) {
+	case AnchorName:
+	    return c.paragraph()->at( c.index() )->anchorName();
+	case AnchorHref:
+	    return c.paragraph()->at( c.index() )->anchorHref();
+    }
+    // incase the compiler is really dumb about determining if a function
+    // returns something :)
+    return TQString::null;
+}
+
+void TQTextEdit::documentWidthChanged( int w )
+{
+    resizeContents( TQMAX( visibleWidth(), w), contentsHeight() );
+}
+
+/*! \internal
+
+  This function does nothing
+*/
+
+void TQTextEdit::updateStyles()
+{
+}
+
+void TQTextEdit::setDocument( TQTextDocument *dc )
+{
+    if ( dc == 0 ) {
+        qWarning( "Q3TextEdit::setDocument() called with null Q3TextDocument pointer" );
+        return;
+    }
+    if ( dc == doc )
+	return;
+    resetInputContext();
+    doc = dc;
+    delete cursor;
+    cursor = new TQTextCursor( doc );
+    clearUndoRedo();
+    undoRedoInfo.doc = doc;
+    lastFormatted = 0;
+}
+
+#ifndef QT_NO_CLIPBOARD
+
+/*!
+    Pastes the text with format \a subtype from the clipboard into the
+    text edit at the current cursor position. The \a subtype can be
+    "plain" or "html".
+
+    If there is no text with format \a subtype in the clipboard
+    nothing happens.
+
+    \sa paste() cut() TQTextEdit::copy()
+*/
+
+void TQTextEdit::pasteSubType( const TQCString &subtype )
+{
+#ifndef QT_NO_MIMECLIPBOARD
+    TQMimeSource *m = TQApplication::clipboard()->data( d->clipboard_mode );
+    pasteSubType( subtype, m );
+#endif
+}
+
+/*! \internal */
+
+void TQTextEdit::pasteSubType( const TQCString& subtype, TQMimeSource *m )
+{
+#ifndef QT_NO_MIME
+    TQCString st = subtype;
+    if ( subtype != "x-qrichtext" )
+	st.prepend( "text/" );
+    else
+	st.prepend( "application/" );
+    if ( !m )
+	return;
+    if ( doc->hasSelection( TQTextDocument::Standard ) )
+	removeSelectedText();
+    if ( !TQRichTextDrag::canDecode( m ) )
+	return;
+    TQString t;
+    if ( !TQRichTextDrag::decode( m, t, st.data(), subtype ) )
+	return;
+    if ( st == "application/x-qrichtext" ) {
+	int start;
+	if ( (start = t.find( "<!--StartFragment-->" )) != -1 ) {
+	    start += 20;
+	    int end = t.find( "<!--EndFragment-->" );
+	    TQTextCursor oldC = *cursor;
+
+	    // during the setRichTextInternal() call the cursors
+	    // paragraph might get joined with the provious one, so
+	    // the cursors one would get deleted and oldC.paragraph()
+	    // would be a dnagling pointer. To avoid that try to go
+	    // one letter back and later go one forward again.
+	    oldC.gotoPreviousLetter();
+	    bool couldGoBack = oldC != *cursor;
+	    // first para might get deleted, so remember to reset it
+	    bool wasAtFirst = oldC.paragraph() == doc->firstParagraph();
+
+	    if ( start < end )
+		t = t.mid( start, end - start );
+	    else
+		t = t.mid( start );
+	    lastFormatted = cursor->paragraph();
+	    if ( lastFormatted->prev() )
+		lastFormatted = lastFormatted->prev();
+	    doc->setRichTextInternal( t, cursor );
+
+	    // the first para might have been deleted in
+	    // setRichTextInternal(). To be sure, reset it if
+	    // necessary.
+	    if ( wasAtFirst ) {
+		int index = oldC.index();
+		oldC.setParagraph( doc->firstParagraph() );
+		oldC.setIndex( index );
+	    }
+
+	    // if we went back one letter before (see last comment),
+	    // go one forward to point to the right position
+	    if ( couldGoBack )
+		oldC.gotoNextLetter();
+
+	    if ( undoEnabled && !isReadOnly() ) {
+		doc->setSelectionStart( TQTextDocument::Temp, oldC );
+		doc->setSelectionEnd( TQTextDocument::Temp, *cursor );
+
+		checkUndoRedoInfo( UndoRedoInfo::Insert );
+		if ( !undoRedoInfo.valid() ) {
+		    undoRedoInfo.id = oldC.paragraph()->paragId();
+		    undoRedoInfo.index = oldC.index();
+		    undoRedoInfo.d->text = TQString::null;
+		}
+		int oldLen = undoRedoInfo.d->text.length();
+		if ( !doc->preProcessor() ) {
+		    TQString txt = doc->selectedText( TQTextDocument::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( TQTextDocument::Temp );
+	    }
+
+	    formatMore();
+	    setModified();
+	    emit textChanged();
+	    repaintChanged();
+	    ensureCursorVisible();
+	    return;
+	}
+    } else {
+#if defined(Q_OS_WIN32)
+	// Need to convert CRLF to LF
+	t.replace( "\r\n", "\n" );
+#elif defined(Q_OS_MAC)
+	//need to convert CR to LF
+	t.replace( '\r', '\n' );
+#endif
+	TQChar *uc = (TQChar *)t.unicode();
+	for ( int i=0; (uint) i<t.length(); i++ ) {
+	    if ( uc[ i ] < ' ' && uc[ i ] != '\n' && uc[ i ] != '\t' )
+		uc[ i ] = ' ';
+	}
+	if ( !t.isEmpty() )
+	    insert( t, FALSE, TRUE );
+    }
+#endif //QT_NO_MIME
+}
+
+#ifndef QT_NO_MIMECLIPBOARD
+/*!
+    Prompts the user to choose a type from a list of text types
+    available, then copies text from the clipboard (if there is any)
+    into the text edit at the current text cursor position. Any
+    selected text (in selection 0) is first deleted.
+*/
+void TQTextEdit::pasteSpecial( const TQPoint& pt )
+{
+    TQCString st = pickSpecial( TQApplication::clipboard()->data( d->clipboard_mode ),
+			       TRUE, pt );
+    if ( !st.isEmpty() )
+	pasteSubType( st );
+}
+#endif
+#ifndef QT_NO_MIME
+TQCString TQTextEdit::pickSpecial( TQMimeSource* ms, bool always_ask, const TQPoint& pt )
+{
+    if ( ms )  {
+#ifndef QT_NO_POPUPMENU
+	TQPopupMenu popup( this, "qt_pickspecial_menu" );
+	TQString fmt;
+	int n = 0;
+	TQDict<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
+	TQString 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 TQCString();
+}
+#endif // QT_NO_MIME
+#endif // QT_NO_CLIPBOARD
+
+/*!
+    \enum TQTextEdit::WordWrap
+
+    This enum defines the TQTextEdit's word wrap modes.
+
+    \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().
+
+    \value FixedPixelWidth Wrap the text at a fixed number of pixels
+    from the widget's left side. The number of pixels is set with
+    wrapColumnOrWidth().
+
+    \value FixedColumnWidth Wrap the text at a fixed number of
+    character columns from the widget's left side. The number of
+    characters is set with wrapColumnOrWidth(). This is useful if you
+    need formatted text that can also be displayed gracefully on
+    devices with monospaced fonts, for example a standard VT100
+    terminal, where you might set wrapColumnOrWidth() to 80.
+
+    \sa setWordWrap() wordWrap()
+*/
+
+/*!
+    \property TQTextEdit::wordWrap
+    \brief the word wrap mode
+
+    The default mode is \c WidgetWidth which causes words to be
+    wrapped at the right edge of the text edit. Wrapping occurs at
+    whitespace, keeping whole words intact. If you want wrapping to
+    occur within words use setWrapPolicy(). If you set a wrap mode of
+    \c FixedPixelWidth or \c FixedColumnWidth you should also call
+    setWrapColumnOrWidth() with the width you want.
+
+    \sa WordWrap, wrapColumnOrWidth, wrapPolicy,
+*/
+
+void TQTextEdit::setWordWrap( WordWrap mode )
+{
+    if ( wrapMode == mode )
+	return;
+    wrapMode = mode;
+    switch ( mode ) {
+    case NoWrap:
+	document()->formatter()->setWrapEnabled( FALSE );
+	document()->formatter()->setWrapAtColumn( -1 );
+	doc->setWidth( visibleWidth() );
+	doc->setMinimumWidth( -1 );
+	doc->invalidate();
+	updateContents();
+	lastFormatted = doc->firstParagraph();
+	interval = 0;
+	formatMore();
+	break;
+    case WidgetWidth:
+	document()->formatter()->setWrapEnabled( TRUE );
+	document()->formatter()->setWrapAtColumn( -1 );
+	doResize();
+	break;
+    case FixedPixelWidth:
+	document()->formatter()->setWrapEnabled( TRUE );
+	document()->formatter()->setWrapAtColumn( -1 );
+	if ( wrapWidth < 0 )
+	    wrapWidth = 200;
+	setWrapColumnOrWidth( wrapWidth );
+	break;
+    case FixedColumnWidth:
+	if ( wrapWidth < 0 )
+	    wrapWidth = 80;
+	document()->formatter()->setWrapEnabled( TRUE );
+	document()->formatter()->setWrapAtColumn( wrapWidth );
+	setWrapColumnOrWidth( wrapWidth );
+	break;
+    }
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    checkOptimMode();
+#endif
+}
+
+TQTextEdit::WordWrap TQTextEdit::wordWrap() const
+{
+    return wrapMode;
+}
+
+/*!
+    \property TQTextEdit::wrapColumnOrWidth
+    \brief the position (in pixels or columns depending on the wrap mode) where text will be wrapped
+
+    If the wrap mode is \c FixedPixelWidth, the value is the number of
+    pixels from the left edge of the text edit at which text should be
+    wrapped. If the wrap mode is \c FixedColumnWidth, the value is the
+    column number (in character columns) from the left edge of the
+    text edit at which text should be wrapped.
+
+    \sa wordWrap
+*/
+void TQTextEdit::setWrapColumnOrWidth( int value )
+{
+    wrapWidth = value;
+    if ( wrapMode == FixedColumnWidth ) {
+	document()->formatter()->setWrapAtColumn( wrapWidth );
+	resizeContents( 0, 0 );
+	doc->setWidth( visibleWidth() );
+	doc->setMinimumWidth( -1 );
+    } else if (wrapMode == FixedPixelWidth ) {
+	document()->formatter()->setWrapAtColumn( -1 );
+	resizeContents( wrapWidth, 0 );
+	doc->setWidth( wrapWidth );
+	doc->setMinimumWidth( wrapWidth );
+    } else {
+	return;
+    }
+    doc->invalidate();
+    updateContents();
+    lastFormatted = doc->firstParagraph();
+    interval = 0;
+    formatMore();
+}
+
+int TQTextEdit::wrapColumnOrWidth() const
+{
+    if ( wrapMode == WidgetWidth )
+	return visibleWidth();
+    return wrapWidth;
+}
+
+
+/*!
+    \enum TQTextEdit::WrapPolicy
+
+    This enum defines where text can be wrapped in word wrap mode.
+
+    \value AtWhiteSpace Don't use this deprecated value (it is a
+    synonym for \c AtWordBoundary which you should use instead).
+    \value Anywhere  Break anywhere, including within words.
+    \value AtWordBoundary Break lines at word boundaries, e.g. spaces or
+    newlines
+    \value AtWordOrDocumentBoundary Break lines at whitespace, e.g.
+    spaces or newlines if possible. Break it anywhere otherwise.
+
+    \sa setWrapPolicy()
+*/
+
+/*!
+    \property TQTextEdit::wrapPolicy
+    \brief the word wrap policy, at whitespace or anywhere
+
+    Defines where text can be wrapped when word wrap mode is not \c
+    NoWrap. The choices are \c AtWordBoundary (the default), \c
+    Anywhere and \c AtWordOrDocumentBoundary
+
+    \sa wordWrap
+*/
+
+void TQTextEdit::setWrapPolicy( WrapPolicy policy )
+{
+    if ( wPolicy == policy )
+	return;
+    wPolicy = policy;
+    TQTextFormatter *formatter;
+    if ( policy == AtWordBoundary || policy == AtWordOrDocumentBoundary ) {
+	formatter = new TQTextFormatterBreakWords;
+	formatter->setAllowBreakInWords( policy == AtWordOrDocumentBoundary );
+    } else {
+	formatter = new TQTextFormatterBreakInWords;
+    }
+    formatter->setWrapAtColumn( document()->formatter()->wrapAtColumn() );
+    formatter->setWrapEnabled( document()->formatter()->isWrapEnabled( 0 ) );
+    document()->setFormatter( formatter );
+    doc->invalidate();
+    updateContents();
+    lastFormatted = doc->firstParagraph();
+    interval = 0;
+    formatMore();
+}
+
+TQTextEdit::WrapPolicy TQTextEdit::wrapPolicy() const
+{
+    return wPolicy;
+}
+
+/*!
+    Deletes all the text in the text edit.
+
+    \sa cut() removeSelectedText() setText()
+*/
+
+void TQTextEdit::clear()
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	optimSetText("");
+    } else
+#endif
+    {
+	// make clear undoable
+	doc->selectAll( TQTextDocument::Temp );
+	removeSelectedText( TQTextDocument::Temp );
+	setContentsPos( 0, 0 );
+	if ( cursor->isValid() )
+	    cursor->restoreState();
+	doc->clear( TRUE );
+	delete cursor;
+	cursor = new TQTextCursor( doc );
+	lastFormatted = 0;
+    }
+    updateContents();
+
+    emit cursorPositionChanged( cursor );
+    emit cursorPositionChanged( cursor->paragraph()->paragId(), cursor->index() );
+}
+
+int TQTextEdit::undoDepth() const
+{
+    return document()->undoDepth();
+}
+
+/*!
+    \property TQTextEdit::length
+    \brief the number of characters in the text
+*/
+
+int TQTextEdit::length() const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode )
+	return d->od->len;
+    else
+#endif
+	return document()->length();
+}
+
+/*!
+    \property TQTextEdit::tabStopWidth
+    \brief the tab stop width in pixels
+*/
+
+int TQTextEdit::tabStopWidth() const
+{
+    return document()->tabStopWidth();
+}
+
+void TQTextEdit::setUndoDepth( int d )
+{
+    document()->setUndoDepth( d );
+}
+
+void TQTextEdit::setTabStopWidth( int ts )
+{
+    document()->setTabStops( ts );
+    doc->invalidate();
+    lastFormatted = doc->firstParagraph();
+    interval = 0;
+    formatMore();
+    updateContents();
+}
+
+/*!
+    \reimp
+*/
+
+TQSize TQTextEdit::sizeHint() const
+{
+    // cf. TQScrollView::sizeHint()
+    constPolish();
+    int f = 2 * frameWidth();
+    int h = fontMetrics().height();
+    TQSize sz( f, f );
+    return sz.expandedTo( TQSize(12 * h, 8 * h) );
+}
+
+void TQTextEdit::clearUndoRedo()
+{
+    if ( !undoEnabled )
+	return;
+    undoRedoInfo.clear();
+    emit undoAvailable( doc->commands()->isUndoAvailable() );
+    emit redoAvailable( doc->commands()->isRedoAvailable() );
+}
+
+/*!  \internal
+  \warning In TQt 3.1 we will provide a cleaer API for the
+  functionality which is provided by this function and in TQt 4.0 this
+  function will go away.
+
+  This function gets the format of the character at position \a
+  index in paragraph \a para. Sets \a font to the character's font, \a
+  color to the character's color and \a verticalAlignment to the
+  character's vertical alignment.
+
+  Returns FALSE if \a para or \a index is out of range otherwise
+  returns TRUE.
+*/
+
+bool TQTextEdit::getFormat( int para, int index, TQFont *font, TQColor *color, VerticalAlignment *verticalAlignment )
+{
+    if ( !font || !color )
+	return FALSE;
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return FALSE;
+    if ( index < 0 || index >= p->length() )
+	return FALSE;
+    *font = p->at( index )->format()->font();
+    *color = p->at( index )->format()->color();
+    *verticalAlignment = (VerticalAlignment)p->at( index )->format()->vAlign();
+    return TRUE;
+}
+
+/*!  \internal
+  \warning In TQt 3.1 we will provide a cleaer API for the
+  functionality which is provided by this function and in TQt 4.0 this
+  function will go away.
+
+  This function gets the format of the paragraph \a para. Sets \a
+  font to the paragraphs's font, \a color to the paragraph's color, \a
+  verticalAlignment to the paragraph's vertical alignment, \a
+  alignment to the paragraph's alignment, \a displayMode to the
+  paragraph's display mode, \a listStyle to the paragraph's list style
+  (if the display mode is TQStyleSheetItem::DisplayListItem) and \a
+  listDepth to the depth of the list (if the display mode is
+  TQStyleSheetItem::DisplayListItem).
+
+  Returns FALSE if \a para is out of range otherwise returns TRUE.
+*/
+
+bool TQTextEdit::getParagraphFormat( int para, TQFont *font, TQColor *color,
+				    VerticalAlignment *verticalAlignment, int *alignment,
+				    TQStyleSheetItem::DisplayMode *displayMode,
+				    TQStyleSheetItem::ListStyle *listStyle,
+				    int *listDepth )
+{
+    if ( !font || !color || !alignment || !displayMode || !listStyle )
+	return FALSE;
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return FALSE;
+    *font = p->at(0)->format()->font();
+    *color = p->at(0)->format()->color();
+    *verticalAlignment = (VerticalAlignment)p->at(0)->format()->vAlign();
+    *alignment = p->alignment();
+    *displayMode = p->isListItem() ? TQStyleSheetItem::DisplayListItem : TQStyleSheetItem::DisplayBlock;
+    *listStyle = p->listStyle();
+    *listDepth = p->listDepth();
+    return TRUE;
+}
+
+
+
+/*!
+    This function is called to create a right mouse button popup menu
+    at the document position \a pos. If you want to create a custom
+    popup menu, reimplement this function and return the created popup
+    menu. Ownership of the popup menu is transferred to the caller.
+
+    \warning The TQPopupMenu ID values 0-7 are reserved, and they map to the
+    standard operations. When inserting items into your custom popup menu, be
+    sure to specify ID values larger than 7.
+*/
+
+TQPopupMenu *TQTextEdit::createPopupMenu( const TQPoint& pos )
+{
+    Q_UNUSED( pos )
+#ifndef QT_NO_POPUPMENU
+    TQPopupMenu *popup = new TQPopupMenu( this, "qt_edit_menu" );
+    if ( !isReadOnly() ) {
+	d->id[ IdUndo ] = popup->insertItem( tr( "&Undo" ) + ACCEL_KEY( Z ) );
+	d->id[ IdRedo ] = popup->insertItem( tr( "&Redo" ) + ACCEL_KEY( Y ) );
+	popup->insertSeparator();
+    }
+#ifndef QT_NO_CLIPBOARD
+    if ( !isReadOnly() )
+	d->id[ IdCut ] = popup->insertItem( tr( "Cu&t" ) + ACCEL_KEY( X ) );
+    d->id[ IdCopy ] = popup->insertItem( tr( "&Copy" ) + ACCEL_KEY( C ) );
+    if ( !isReadOnly() )
+	d->id[ IdPaste ] = popup->insertItem( tr( "&Paste" ) + ACCEL_KEY( V ) );
+#endif
+    if ( !isReadOnly() ) {
+	d->id[ IdClear ] = popup->insertItem( tr( "Clear" ) );
+	popup->insertSeparator();
+    }
+#if defined(Q_WS_X11)
+    d->id[ IdSelectAll ] = popup->insertItem( tr( "Select All" ) );
+#else
+    d->id[ IdSelectAll ] = popup->insertItem( tr( "Select All" ) + ACCEL_KEY( A ) );
+#endif
+
+#ifndef QT_NO_IM
+    TQInputContext *qic = getInputContext();
+    if ( qic )
+	qic->addMenusTo( popup );
+#endif
+    
+    popup->setItemEnabled( d->id[ IdUndo ], !isReadOnly() && doc->commands()->isUndoAvailable() );
+    popup->setItemEnabled( d->id[ IdRedo ], !isReadOnly() && doc->commands()->isRedoAvailable() );
+#ifndef QT_NO_CLIPBOARD
+    popup->setItemEnabled( d->id[ IdCut ], !isReadOnly() && doc->hasSelection( TQTextDocument::Standard, TRUE ) );
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    popup->setItemEnabled( d->id[ IdCopy ], d->optimMode ? optimHasSelection() : doc->hasSelection( TQTextDocument::Standard, TRUE ) );
+#else
+    popup->setItemEnabled( d->id[ IdCopy ], doc->hasSelection( TQTextDocument::Standard, TRUE ) );
+#endif
+    popup->setItemEnabled( d->id[ IdPaste ], !isReadOnly() && !TQApplication::clipboard()->text( d->clipboard_mode ).isEmpty() );
+#endif
+    const bool isEmptyDocument = (length() == 0);
+    popup->setItemEnabled( d->id[ IdClear ], !isReadOnly() && !isEmptyDocument );
+    popup->setItemEnabled( d->id[ IdSelectAll ], !isEmptyDocument );
+    return popup;
+#else
+    return 0;
+#endif
+}
+
+/*! \overload
+    \obsolete
+    This function is called to create a right mouse button popup menu.
+    If you want to create a custom popup menu, reimplement this function
+    and return the created popup menu. Ownership of the popup menu is
+    transferred to the caller.
+
+    This function is only called if createPopupMenu( const TQPoint & )
+    returns 0.
+*/
+
+TQPopupMenu *TQTextEdit::createPopupMenu()
+{
+    return 0;
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::setFont( const TQFont &f )
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	TQScrollView::setFont( f );
+	doc->setDefaultFormat( f, doc->formatCollection()->defaultFormat()->color() );
+	// recalculate the max string width
+	TQFontMetrics fm(f);
+	int i, sw;
+	d->od->maxLineWidth = 0;
+	for ( i = 0; i < d->od->numLines; i++ ) {
+	    sw = fm.width(d->od->lines[LOGOFFSET(i)]);
+	    if (d->od->maxLineWidth < sw)
+		d->od->maxLineWidth = sw;
+	}
+	resizeContents(d->od->maxLineWidth + 4, d->od->numLines * fm.lineSpacing() + 1);
+	return;
+    }
+#endif
+    TQScrollView::setFont( f );
+    doc->setMinimumWidth( -1 );
+    doc->setDefaultFormat( f, doc->formatCollection()->defaultFormat()->color() );
+    lastFormatted = doc->firstParagraph();
+    formatMore();
+    repaintChanged();
+}
+
+/*!
+    \fn TQTextEdit::zoomIn()
+
+    \overload
+
+    Zooms in on the text by making the base font size one point
+    larger and recalculating all font sizes to be the new size. This
+    does not change the size of any images.
+
+    \sa zoomOut()
+*/
+
+/*!
+    \fn TQTextEdit::zoomOut()
+
+    \overload
+
+    Zooms out on the text by making the base font size one point
+    smaller and recalculating all font sizes to be the new size. This
+    does not change the size of any images.
+
+    \sa zoomIn()
+*/
+
+
+/*!
+    Zooms in on the text by making the base font size \a range
+    points larger and recalculating all font sizes to be the new size.
+    This does not change the size of any images.
+
+    \sa zoomOut()
+*/
+
+void TQTextEdit::zoomIn( int range )
+{
+    TQFont f( TQScrollView::font() );
+    f.setPointSize( TQFontInfo(f).pointSize() + range );
+    setFont( f );
+}
+
+/*!
+    Zooms out on the text by making the base font size \a range points
+    smaller and recalculating all font sizes to be the new size. This
+    does not change the size of any images.
+
+    \sa zoomIn()
+*/
+
+void TQTextEdit::zoomOut( int range )
+{
+    TQFont f( TQScrollView::font() );
+    f.setPointSize( TQMAX( 1, TQFontInfo(f).pointSize() - range ) );
+    setFont( f );
+}
+
+/*!
+    Zooms the text by making the base font size \a size points and
+    recalculating all font sizes to be the new size. This does not
+    change the size of any images.
+*/
+
+void TQTextEdit::zoomTo( int size )
+{
+    TQFont f( TQScrollView::font() );
+    f.setPointSize( size );
+    setFont( f );
+}
+
+/*!
+   TQTextEdit is optimized for large amounts text. One of its
+   optimizations is to format only the visible text, formatting the rest
+   on demand, e.g. as the user scrolls, so you don't usually need to
+   call this function.
+
+    In some situations you may want to force the whole text
+    to be formatted. For example, if after calling setText(), you wanted
+    to know the height of the document (using contentsHeight()), you
+    would call this function first.
+*/
+
+void TQTextEdit::sync()
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	TQFontMetrics fm( TQScrollView::font() );
+	resizeContents( d->od->maxLineWidth + 4, d->od->numLines * fm.lineSpacing() + 1 );
+    } else
+#endif
+    {
+	while ( lastFormatted ) {
+	    lastFormatted->format();
+	    lastFormatted = lastFormatted->next();
+	}
+	resizeContents( contentsWidth(), doc->height() );
+    }
+    updateScrollBars();
+}
+
+/*!
+    \reimp
+*/
+
+void TQTextEdit::setEnabled( bool b )
+{
+    TQScrollView::setEnabled( b );
+    if ( textFormat() == PlainText ) {
+	TQTextFormat *f = doc->formatCollection()->defaultFormat();
+	f->setColor( colorGroup().text() );
+	updateContents();
+    }
+}
+
+/*!
+    Sets the background color of selection number \a selNum to \a back
+    and specifies whether the text of this selection should be
+    inverted with \a invertText.
+
+    This only works for \a selNum > 0. The default selection (\a
+    selNum == 0) gets its attributes from the text edit's
+    colorGroup().
+*/
+
+void TQTextEdit::setSelectionAttributes( int selNum, const TQColor &back, bool invertText )
+{
+    if ( selNum < 1 )
+	return;
+    if ( selNum > doc->numSelections() )
+	doc->addSelection( selNum );
+    doc->setSelectionColor( selNum, back );
+    doc->setInvertSelectionText( selNum, invertText );
+}
+
+/*!
+    \reimp
+*/
+void TQTextEdit::windowActivationChange( bool oldActive )
+{
+    if ( oldActive && scrollTimer )
+	scrollTimer->stop();
+    if ( palette().active() != palette().inactive() )
+	updateContents();
+    TQScrollView::windowActivationChange( oldActive );
+}
+
+void TQTextEdit::setReadOnly( bool b )
+{
+    if ( (bool) readonly == b )
+	return;
+    readonly = b;
+#ifndef QT_NO_CURSOR
+    if ( readonly )
+	viewport()->setCursor( arrowCursor );
+    else
+	viewport()->setCursor( ibeamCursor );
+    setInputMethodEnabled( !readonly );
+#endif
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    checkOptimMode();
+#endif
+}
+
+/*!
+    Scrolls to the bottom of the document and does formatting if
+    retquired.
+*/
+
+void TQTextEdit::scrollToBottom()
+{
+    sync();
+    setContentsPos( contentsX(), contentsHeight() - visibleHeight() );
+}
+
+/*!
+    Returns the rectangle of the paragraph \a para in contents
+    coordinates, or an invalid rectangle if \a para is out of range.
+*/
+
+TQRect TQTextEdit::paragraphRect( int para ) const
+{
+    TQTextEdit *that = (TQTextEdit *)this;
+    that->sync();
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return TQRect( -1, -1, -1, -1 );
+    return p->rect();
+}
+
+/*!
+    Returns the paragraph which is at position \a pos (in contents
+    coordinates).
+*/
+
+int TQTextEdit::paragraphAt( const TQPoint &pos ) const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	TQFontMetrics fm( TQScrollView::font() );
+	int parag = pos.y() / fm.lineSpacing();
+	if ( parag <= d->od->numLines )
+	    return parag;
+	else
+	    return 0;
+    }
+#endif
+    TQTextCursor c( doc );
+    c.place( pos, doc->firstParagraph() );
+    if ( c.paragraph() )
+	return c.paragraph()->paragId();
+    return -1; // should never happen..
+}
+
+/*!
+    Returns the index of the character (relative to its paragraph) at
+    position \a pos (in contents coordinates). If \a para is not 0,
+    \a *para is set to the character's paragraph.
+*/
+
+int TQTextEdit::charAt( const TQPoint &pos, int *para ) const
+{
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+    if ( d->optimMode ) {
+	int par = paragraphAt( pos );
+	if ( para )
+	    *para = par;
+	return optimCharIndex( d->od->lines[ LOGOFFSET(par) ], pos.x() );
+    }
+#endif
+    TQTextCursor c( doc );
+    c.place( pos, doc->firstParagraph() );
+    if ( c.paragraph() ) {
+	if ( para )
+	    *para = c.paragraph()->paragId();
+	return c.index();
+    }
+    return -1; // should never happen..
+}
+
+/*!
+    Sets the background color of the paragraph \a para to \a bg.
+*/
+
+void TQTextEdit::setParagraphBackgroundColor( int para, const TQColor &bg )
+{
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return;
+    p->setBackgroundColor( bg );
+    repaintChanged();
+}
+
+/*!
+    Clears the background color of the paragraph \a para, so that the
+    default color is used again.
+*/
+
+void TQTextEdit::clearParagraphBackground( int para )
+{
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return;
+    p->clearBackgroundColor();
+    repaintChanged();
+}
+
+/*!
+    Returns the background color of the paragraph \a para or an
+    invalid color if \a para is out of range or the paragraph has no
+    background set
+*/
+
+TQColor TQTextEdit::paragraphBackgroundColor( int para ) const
+{
+    TQTextParagraph *p = doc->paragAt( para );
+    if ( !p )
+	return TQColor();
+    TQColor *c = p->backgroundColor();
+    if ( c )
+	return *c;
+    return TQColor();
+}
+
+/*!
+    \property TQTextEdit::undoRedoEnabled
+    \brief whether undo/redo is enabled
+
+    When changing this property, the undo/redo history is cleared.
+
+    The default is TRUE.
+*/
+
+void TQTextEdit::setUndoRedoEnabled( bool b )
+{
+    undoRedoInfo.clear();
+    doc->commands()->clear();
+
+    undoEnabled = b;
+}
+
+bool TQTextEdit::isUndoRedoEnabled() const
+{
+    return undoEnabled;
+}
+
+/*!
+    Returns TRUE if undo is available; otherwise returns FALSE.
+*/
+
+bool TQTextEdit::isUndoAvailable() const
+{
+    return undoEnabled && (doc->commands()->isUndoAvailable() || undoRedoInfo.valid());
+}
+
+/*!
+    Returns TRUE if redo is available; otherwise returns FALSE.
+*/
+
+bool TQTextEdit::isRedoAvailable() const
+{
+    return undoEnabled && doc->commands()->isRedoAvailable();
+}
+
+void TQTextEdit::ensureFormatted( TQTextParagraph *p )
+{
+    while ( !p->isValid() ) {
+	if ( !lastFormatted )
+	    return;
+	formatMore();
+    }
+}
+
+/*! \internal */
+void TQTextEdit::updateCursor( const TQPoint & pos )
+{
+    if ( isReadOnly() && linksEnabled() ) {
+	TQTextCursor c = *cursor;
+	placeCursor( pos, &c, TRUE );
+
+#ifndef QT_NO_NETWORKPROTOCOL
+	bool insideParagRect = TRUE;
+	if (c.paragraph() == doc->lastParagraph()
+	    && c.paragraph()->rect().y() + c.paragraph()->rect().height() < pos.y())
+	    insideParagRect = FALSE;
+	if (insideParagRect && c.paragraph() && c.paragraph()->at( c.index() ) &&
+	    c.paragraph()->at( c.index() )->isAnchor()) {
+	    if (!c.paragraph()->at( c.index() )->anchorHref().isEmpty()
+		    && c.index() < c.paragraph()->length() - 1 )
+		onLink = c.paragraph()->at( c.index() )->anchorHref();
+	    else
+		onLink = TQString::null;
+
+	    if (!c.paragraph()->at( c.index() )->anchorName().isEmpty()
+		    && c.index() < c.paragraph()->length() - 1 )
+		d->onName = c.paragraph()->at( c.index() )->anchorName();
+	    else
+		d->onName = TQString::null;
+
+	    if (!c.paragraph()->at( c.index() )->anchorHref().isEmpty() ) {
+#ifndef QT_NO_CURSOR
+		viewport()->setCursor( onLink.isEmpty() ? arrowCursor : pointingHandCursor );
+#endif
+		TQUrl u( doc->context(), onLink, TRUE );
+		emitHighlighted( u.toString( FALSE, FALSE ) );
+	    }
+	} else {
+#ifndef QT_NO_CURSOR
+	    viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor );
+#endif
+	    onLink = TQString::null;
+	    emitHighlighted( TQString::null );
+	}
+#endif
+    }
+}
+
+/*!
+  Places the cursor \a c at the character which is closest to position
+  \a pos (in contents coordinates). If \a c is 0, the default text
+  cursor is used.
+
+  \sa setCursorPosition()
+*/
+void TQTextEdit::placeCursor( const TQPoint &pos, TQTextCursor *c )
+{
+    placeCursor( pos, c, FALSE );
+}
+
+/*! \internal */
+void TQTextEdit::clipboardChanged()
+{
+#ifndef QT_NO_CLIPBOARD
+    // don't listen to selection changes
+    disconnect( TQApplication::clipboard(), SIGNAL(selectionChanged()), this, 0);
+#endif
+    selectAll(FALSE);
+}
+
+/*! \property TQTextEdit::tabChangesFocus
+  \brief whether TAB changes focus or is accepted as input
+
+  In some occasions text edits should not allow the user to input
+  tabulators or change indentation using the TAB key, as this breaks
+  the focus chain. The default is FALSE.
+
+*/
+
+void TQTextEdit::setTabChangesFocus( bool b )
+{
+    d->tabChangesFocus = b;
+}
+
+bool TQTextEdit::tabChangesFocus() const
+{
+    return d->tabChangesFocus;
+}
+
+#ifdef QT_TEXTEDIT_OPTIMIZATION
+/* Implementation of optimized LogText mode follows */
+
+static void qSwap( int * a, int * b )
+{
+    if ( !a || !b )
+	return;
+    int tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+/*! \internal */
+bool TQTextEdit::checkOptimMode()
+{
+    bool oldMode = d->optimMode;
+    if ( textFormat() == LogText ) {
+	setReadOnly( TRUE );
+	d->optimMode = TRUE;
+    } else {
+	d->optimMode = FALSE;
+    }
+
+    // when changing mode - try to keep selections and text
+    if ( oldMode != d->optimMode ) {
+	if ( d->optimMode ) {
+	    d->od = new TQTextEditOptimPrivate;
+	    connect( scrollTimer, SIGNAL( timeout() ), this, SLOT( optimDoAutoScroll() ) );
+	    disconnect( doc, SIGNAL( minimumWidthChanged(int) ), this, SLOT( documentWidthChanged(int) ) );
+	    disconnect( scrollTimer, SIGNAL( timeout() ), this, SLOT( autoScrollTimerDone() ) );
+	    disconnect( formatTimer, SIGNAL( timeout() ), this, SLOT( formatMore() ) );
+	    optimSetText( doc->originalText() );
+	    doc->clear(TRUE);
+	    delete cursor;
+	    cursor = new TQTextCursor( doc );
+	} else {
+	    disconnect( scrollTimer, SIGNAL( timeout() ), this, SLOT( optimDoAutoScroll() ) );
+	    connect( doc, SIGNAL( minimumWidthChanged(int) ), this, SLOT( documentWidthChanged(int) ) );
+	    connect( scrollTimer, SIGNAL( timeout() ), this, SLOT( autoScrollTimerDone() ) );
+	    connect( formatTimer, SIGNAL( timeout() ), this, SLOT( formatMore() ) );
+	    setText( optimText() );
+	    delete d->od;
+	    d->od = 0;
+	}
+    }
+    return d->optimMode;
+}
+
+/*! \internal */
+TQString TQTextEdit::optimText() const
+{
+    TQString str, tmp;
+
+    if ( d->od->len == 0 )
+	return str;
+
+    // concatenate all strings
+    int i;
+    int offset;
+    TQMapConstIterator<int,TQTextEditOptimPrivate::Tag *> it;
+    TQTextEditOptimPrivate::Tag * ftag = 0;
+    for ( i = 0; i < d->od->numLines; i++ ) {
+	if ( d->od->lines[ LOGOFFSET(i) ].isEmpty() ) { // CR lines are empty
+	    str += "\n";
+	} else {
+	    tmp = d->od->lines[ LOGOFFSET(i) ] + "\n";
+	    // inject the tags for this line
+	    if ( (it = d->od->tagIndex.find( LOGOFFSET(i) )) != d->od->tagIndex.end() )
+		ftag = it.data();
+	    offset = 0;
+	    while ( ftag && ftag->line == i ) {
+		tmp.insert( ftag->index + offset, "<" + ftag->tag + ">" );
+		offset += ftag->tag.length() + 2; // 2 -> the '<' and '>' chars
+		ftag = ftag->next;
+	    }
+	    str += tmp;
+	}
+    }
+    return str;
+}
+
+/*! \internal */
+void TQTextEdit::optimSetText( const TQString &str )
+{
+    optimRemoveSelection();
+// this is just too slow - but may have to go in due to compatibility reasons
+//     if ( str == optimText() )
+//	return;
+    d->od->numLines = 0;
+    d->od->lines.clear();
+    d->od->maxLineWidth = 0;
+    d->od->len = 0;
+    d->od->clearTags();
+    TQFontMetrics fm( TQScrollView::font() );
+    if ( !(str.isEmpty() || str.isNull() || d->maxLogLines == 0) ) {
+	TQStringList strl = TQStringList::split( '\n', str, TRUE );
+	int lWidth = 0;
+	for ( TQStringList::Iterator it = strl.begin(); it != strl.end(); ++it ) {
+	    optimParseTags( &*it );
+	    optimCheckLimit( *it );
+	    lWidth = fm.width( *it );
+	    if ( lWidth > d->od->maxLineWidth )
+		d->od->maxLineWidth = lWidth;
+	}
+    }
+    resizeContents( d->od->maxLineWidth + 4, d->od->numLines * fm.lineSpacing() + 1 );
+    repaintContents();
+    emit textChanged();
+}
+
+/*! \internal
+
+  Append \a tag to the tag list.
+*/
+TQTextEditOptimPrivate::Tag * TQTextEdit::optimAppendTag( int index, const TQString & tag )
+{
+    TQTextEditOptimPrivate::Tag * t = new TQTextEditOptimPrivate::Tag, * tmp;
+
+    if ( d->od->tags == 0 )
+	d->od->tags = t;
+    t->bold = t->italic = t->underline = FALSE;
+    t->line  = d->od->numLines;
+    t->index = index;
+    t->tag   = tag;
+    t->leftTag = 0;
+    t->parent  = 0;
+    t->prev = d->od->lastTag;
+    if ( d->od->lastTag )
+	d->od->lastTag->next = t;
+    t->next = 0;
+    d->od->lastTag = t;
+    tmp = d->od->tagIndex[ LOGOFFSET(t->line) ];
+    if ( !tmp || (tmp && tmp->index > t->index) ) {
+	d->od->tagIndex.replace( LOGOFFSET(t->line), t );
+    }
+    return t;
+}
+
+ /*! \internal
+
+   Insert \a tag in the tag - according to line and index numbers
+*/
+
+TQTextEditOptimPrivate::Tag *TQTextEdit::optimInsertTag(int line, int index, const TQString &tag)
+{
+    TQTextEditOptimPrivate::Tag *t = new TQTextEditOptimPrivate::Tag, *tmp;
+
+    if (d->od->tags == 0)
+	d->od->tags = t;
+    t->bold = t->italic = t->underline = FALSE;
+    t->line  = line;
+    t->index = index;
+    t->tag   = tag;
+    t->leftTag = 0;
+    t->parent  = 0;
+    t->next = 0;
+    t->prev = 0;
+
+    // find insertion pt. in tag struct.
+    TQMap<int,TQTextEditOptimPrivate::Tag *>::ConstIterator it;
+    if ((it = d->od->tagIndex.find(LOGOFFSET(line))) != d->od->tagIndex.end()) {
+	tmp = *it;
+	if (tmp->index >= index) { // the exisiting tag may be placed AFTER the one we want to insert
+	    tmp = tmp->prev;
+	} else {
+	    while (tmp && tmp->next && tmp->next->line == line && tmp->next->index <= index)
+		tmp = tmp->next;
+	}
+    } else {
+	tmp = d->od->tags;
+	while (tmp && tmp->next && tmp->next->line < line)
+	    tmp = tmp->next;
+	if (tmp == d->od->tags)
+	    tmp = 0;
+    }
+
+    t->prev = tmp;
+    t->next = tmp ? tmp->next : 0;
+    if (t->next)
+	t->next->prev = t;
+    if (tmp)
+	tmp->next = t;
+
+    tmp = d->od->tagIndex[LOGOFFSET(t->line)];
+    if (!tmp || (tmp && tmp->index >= t->index)) {
+	d->od->tagIndex.replace(LOGOFFSET(t->line), t);
+    }
+    return t;
+}
+
+
+/*! \internal
+
+  Find tags in \a line, remove them from \a line and put them in a
+  structure.
+
+  A tag is delimited by '<' and '>'. The characters '<', '>' and '&'
+  are escaped by using '&lt;', '&gt;' and '&amp;'. Left-tags marks
+  the starting point for formatting, while right-tags mark the ending
+  point. A right-tag is the same as a left-tag, but with a '/'
+  appearing before the tag keyword.  E.g a valid left-tag: <b>, and
+  a valid right-tag: </b>.  Tags can be nested, but they have to be
+  closed in the same order as they are opened. E.g:
+  <font color=red><font color=blue>blue</font>red</font> - is valid, while:
+  <font color=red><b>bold red</font> just bold</b> - is invalid since the font tag is
+  closed before the bold tag. Note that a tag does not have to be
+  closed: '<font color=blue>Lots of text - and then some..'  is perfectly valid for
+  setting all text appearing after the tag to blue.  A tag can be used
+  to change the color of a piece of text, or set one of the following
+  formatting attributes: bold, italic and underline.  These attributes
+  are set using the <b>, <i> and <u> tags.  Example of valid tags:
+  <font color=red>, </font>, <b>, <u>, <i>, </i>.
+  Example of valid text:
+  This is some <font color=red>red text</font>, while this is some <font color=green>green
+  text</font>. <font color=blue><font color=yellow>This is yellow</font>, while this is
+  blue.</font>
+
+  Note that only the color attribute of the HTML font tag is supported.
+
+  Limitations:
+  1. A tag cannot span several lines.
+  2. Very limited error checking - mismatching left/right-tags is the
+  only thing that is detected.
+
+*/
+void TQTextEdit::optimParseTags( TQString * line, int lineNo, int indexOffset )
+{
+    int len = line->length();
+    int i, startIndex = -1, endIndex = -1, escIndex = -1;
+    int state = 0; // 0 = outside tag, 1 = inside tag
+    bool tagOpen, tagClose;
+    int bold = 0, italic = 0, underline = 0;
+    TQString tagStr;
+    TQPtrStack<TQTextEditOptimPrivate::Tag> tagStack;
+
+    for ( i = 0; i < len; i++ ) {
+	tagOpen = (*line)[i] == '<';
+	tagClose = (*line)[i] == '>';
+
+	// handle '&lt;' and '&gt;' and '&amp;'
+	if ( (*line)[i] == '&' ) {
+	    escIndex = i;
+	    continue;
+	} else if ( escIndex != -1 && (*line)[i] == ';' ) {
+	    TQString esc = line->mid( escIndex, i - escIndex + 1 );
+	    TQString c;
+	    if ( esc == "&lt;" )
+		c = '<';
+	    else if ( esc == "&gt;" )
+		c = '>';
+	    else if ( esc == "&amp;" )
+		c = '&';
+	    line->replace( escIndex, i - escIndex + 1, c );
+	    len = line->length();
+	    i -= i-escIndex;
+	    escIndex = -1;
+	    continue;
+	}
+
+	if ( state == 0 && tagOpen ) {
+	    state = 1;
+	    startIndex = i;
+	    continue;
+	}
+	if ( state == 1 && tagClose ) {
+	    state = 0;
+	    endIndex = i;
+	    if ( !tagStr.isEmpty() ) {
+		TQTextEditOptimPrivate::Tag * tag, * cur, * tmp;
+		bool format = TRUE;
+
+		if ( tagStr == "b" )
+		    bold++;
+		else if ( tagStr == "/b" )
+		    bold--;
+		else if ( tagStr == "i" )
+		    italic++;
+		else if ( tagStr == "/i" )
+		    italic--;
+		else if ( tagStr == "u" )
+		    underline++;
+		else if ( tagStr == "/u" )
+		    underline--;
+		else
+		    format = FALSE;
+		if ( lineNo > -1 )
+		    tag = optimInsertTag( lineNo, startIndex + indexOffset, tagStr );
+		else
+		    tag = optimAppendTag( startIndex, tagStr );
+		// everything that is not a b, u or i tag is considered
+		// to be a color tag.
+		tag->type = format ? TQTextEditOptimPrivate::Format
+			    : TQTextEditOptimPrivate::Color;
+		if ( tagStr[0] == '/' ) {
+		    // this is a right-tag - search for the left-tag
+		    // and possible parent tag
+		    cur = tag->prev;
+		    if ( !cur ) {
+#ifdef QT_CHECK_RANGE
+			qWarning( "TQTextEdit::optimParseTags: no left-tag for '<%s>' in line %d.", tag->tag.ascii(), tag->line + 1 );
+#endif
+			return; // something is wrong - give up
+		    }
+		    while ( cur ) {
+			if ( cur->leftTag ) { // push right-tags encountered
+			    tagStack.push( cur );
+			} else {
+			    tmp = tagStack.pop();
+			    if ( !tmp ) {
+				if ( (("/" + cur->tag) == tag->tag) ||
+				     (tag->tag == "/font" && cur->tag.left(4) == "font") ) {
+				    // set up the left and parent of this tag
+				    tag->leftTag = cur;
+				    tmp = cur->prev;
+				    if ( tmp && tmp->parent ) {
+					tag->parent = tmp->parent;
+				    } else if ( tmp && !tmp->leftTag ) {
+					tag->parent = tmp;
+				    }
+				    break;
+				} else if ( !cur->leftTag ) {
+#ifdef QT_CHECK_RANGE
+				    qWarning( "TQTextEdit::optimParseTags: mismatching %s-tag for '<%s>' in line %d.", cur->tag[0] == '/' ? "left" : "right", cur->tag.ascii(), cur->line + 1 );
+#endif
+				    return; // something is amiss - give up
+				}
+			    }
+			}
+			cur = cur->prev;
+		    }
+		} else {
+		    tag->bold = bold > 0;
+		    tag->italic = italic > 0;
+		    tag->underline = underline > 0;
+		    tmp = tag->prev;
+		    while ( tmp && tmp->leftTag ) {
+			tmp = tmp->leftTag->parent;
+		    }
+		    if ( tmp ) {
+			tag->bold |= tmp->bold;
+			tag->italic |= tmp->italic;
+			tag->underline |= tmp->underline;
+		    }
+		}
+	    }
+	    if ( startIndex != -1 ) {
+		int l = (endIndex == -1) ?
+			line->length() - startIndex : endIndex - startIndex;
+		line->remove( startIndex, l+1 );
+		len = line->length();
+		i -= l+1;
+	    }
+	    tagStr = "";
+	    continue;
+	}
+
+	if ( state == 1 ) {
+	    tagStr += (*line)[i];
+	}
+    }
+}
+
+// calculate the width of a string in pixels inc. tabs
+static int qStrWidth(const TQString& str, int tabWidth, const TQFontMetrics& fm)
+{
+    int tabs = str.contains('\t');
+
+    if (!tabs)
+	return fm.width(str);
+
+    int newIdx = 0;
+    int lastIdx = 0;
+    int strWidth = 0;
+    int tn;
+    for (tn = 1; tn <= tabs; ++tn) {
+	newIdx = str.find('\t', newIdx);
+	strWidth += fm.width(str.mid(lastIdx, newIdx - lastIdx));
+	if (strWidth >= tn * tabWidth) {
+	    int u = tn;
+	    while (strWidth >= u * tabWidth)
+		++u;
+	    strWidth = u * tabWidth;
+	} else {
+	    strWidth = tn * tabWidth;
+	}
+	lastIdx = ++newIdx;
+    }
+    if ((int)str.length() > newIdx)
+	strWidth += fm.width(str.mid(newIdx));
+    return strWidth;
+}
+
+bool TQTextEdit::optimHasBoldMetrics(int line)
+{
+    TQTextEditOptimPrivate::Tag *t;
+    TQMapConstIterator<int,TQTextEditOptimPrivate::Tag *> it;
+    if ((it = d->od->tagIndex.find(line)) != d->od->tagIndex.end()) {
+	t = *it;
+	while (t && t->line == line) {
+	    if (t->bold)
+		return TRUE;
+	    t = t->next;
+	}
+    } else if ((t = optimPreviousLeftTag(line)) && t->bold) {
+	return TRUE;
+    }
+    return FALSE;
+}
+
+/*! \internal
+
+  Append \a str to the current text buffer. Parses each line to find
+  formatting tags.
+*/
+void TQTextEdit::optimAppend( const TQString &str )
+{
+    if ( str.isEmpty() || str.isNull() || d->maxLogLines == 0 )
+	return;
+
+    TQStringList strl = TQStringList::split( '\n', str, TRUE );
+    TQStringList::Iterator it = strl.begin();
+
+    TQFontMetrics fm(TQScrollView::font());
+    int lWidth = 0;
+
+    for ( ; it != strl.end(); ++it ) {
+	optimParseTags( &*it );
+	optimCheckLimit( *it );
+	if (optimHasBoldMetrics(d->od->numLines-1)) {
+	    TQFont fnt = TQScrollView::font();
+	    fnt.setBold(TRUE);
+	    fm = TQFontMetrics(fnt);
+	}
+	lWidth = qStrWidth(*it, tabStopWidth(), fm) + 4;
+	if ( lWidth > d->od->maxLineWidth )
+	    d->od->maxLineWidth = lWidth;
+    }
+    bool scrollToEnd = contentsY() >= contentsHeight() - visibleHeight();
+    resizeContents( d->od->maxLineWidth + 4, d->od->numLines * fm.lineSpacing() + 1 );
+    if ( scrollToEnd ) {
+	updateScrollBars();
+	ensureVisible( contentsX(), contentsHeight(), 0, 0 );
+    }
+    // when a max log size is set, the text may not be redrawn because
+    // the size of the viewport may not have changed
+    if ( d->maxLogLines > -1 )
+	viewport()->update();
+    emit textChanged();
+}
+
+
+static void qStripTags(TQString *line)
+{
+    int len = line->length();
+    int i, startIndex = -1, endIndex = -1, escIndex = -1;
+    int state = 0; // 0 = outside tag, 1 = inside tag
+    bool tagOpen, tagClose;
+
+    for ( i = 0; i < len; i++ ) {
+	tagOpen = (*line)[i] == '<';
+	tagClose = (*line)[i] == '>';
+
+	// handle '&lt;' and '&gt;' and '&amp;'
+	if ( (*line)[i] == '&' ) {
+	    escIndex = i;
+	    continue;
+	} else if ( escIndex != -1 && (*line)[i] == ';' ) {
+	    TQString esc = line->mid( escIndex, i - escIndex + 1 );
+	    TQString c;
+	    if ( esc == "&lt;" )
+		c = '<';
+	    else if ( esc == "&gt;" )
+		c = '>';
+	    else if ( esc == "&amp;" )
+		c = '&';
+	    line->replace( escIndex, i - escIndex + 1, c );
+	    len = line->length();
+	    i -= i-escIndex;
+	    escIndex = -1;
+	    continue;
+	}
+
+	if ( state == 0 && tagOpen ) {
+	    state = 1;
+	    startIndex = i;
+	    continue;
+	}
+	if ( state == 1 && tagClose ) {
+	    state = 0;
+	    endIndex = i;
+	    if ( startIndex != -1 ) {
+		int l = (endIndex == -1) ?
+			line->length() - startIndex : endIndex - startIndex;
+		line->remove( startIndex, l+1 );
+		len = line->length();
+		i -= l+1;
+	    }
+	    continue;
+	}
+    }
+}
+
+/*! \internal
+
+    Inserts the text into \a line at index \a index.
+*/
+
+void TQTextEdit::optimInsert(const TQString& text, int line, int index)
+{
+    if (text.isEmpty() || d->maxLogLines == 0)
+	return;
+    if (line < 0)
+	line = 0;
+    if (line > d->od->numLines-1)
+	line = d->od->numLines-1;
+    if (index < 0)
+	index = 0;
+    if (index > (int) d->od->lines[line].length())
+	index = d->od->lines[line].length();
+
+    TQStringList strl = TQStringList::split('\n', text, TRUE);
+    int numNewLines = (int)strl.count() - 1;
+    TQTextEditOptimPrivate::Tag *tag = 0;
+    TQMap<int,TQTextEditOptimPrivate::Tag *>::ConstIterator ii;
+    int x;
+
+    if (numNewLines == 0) {
+	// Case 1. Fast single line case - just inject it!
+	TQString stripped = text;
+	qStripTags( &stripped );
+	d->od->lines[LOGOFFSET(line)].insert(index, stripped);
+	// move the tag indices following the insertion pt.
+	if ((ii = d->od->tagIndex.find(LOGOFFSET(line))) != d->od->tagIndex.end()) {
+	    tag = *ii;
+	    while (tag && (LOGOFFSET(tag->line) == line && tag->index < index))
+		tag = tag->next;
+	    while (tag && (LOGOFFSET(tag->line) == line)) {
+		tag->index += stripped.length();
+		tag = tag->next;
+	    }
+	}
+	stripped = text;
+	optimParseTags(&stripped, line, index);
+    } else if (numNewLines > 0) {
+        // Case 2. We have at least 1 newline char - split at
+        // insertion pt. and make room for new lines - complex and slow!
+	TQString left = d->od->lines[LOGOFFSET(line)].left(index);
+	TQString right = d->od->lines[LOGOFFSET(line)].mid(index);
+
+	// rearrange lines for insertion
+	for (x = d->od->numLines - 1; x > line; x--)
+	    d->od->lines[x + numNewLines] = d->od->lines[x];
+	d->od->numLines += numNewLines;
+
+	// fix the tag index and the tag line/index numbers - this
+	// might take a while..
+	for (x = line; x < d->od->numLines; x++) {
+	    if ((ii = d->od->tagIndex.find(LOGOFFSET(line))) != d->od->tagIndex.end()) {
+		tag = ii.data();
+		if (LOGOFFSET(tag->line) == line)
+		    while (tag && (LOGOFFSET(tag->line) == line && tag->index < index))
+			tag = tag->next;
+	    }
+	}
+
+	// relabel affected tags with new line numbers and new index
+	// positions
+	while (tag) {
+	    if (LOGOFFSET(tag->line) == line)
+		tag->index -= index;
+	    tag->line += numNewLines;
+	    tag = tag->next;
+	}
+
+	// generate a new tag index
+	d->od->tagIndex.clear();
+	tag = d->od->tags;
+	while (tag) {
+	    if (!((ii = d->od->tagIndex.find(LOGOFFSET(tag->line))) != d->od->tagIndex.end()))
+		d->od->tagIndex[LOGOFFSET(tag->line)] = tag;
+	    tag = tag->next;
+	}
+
+	// update the tag indices on the spliced line - needs to be done before new tags are added
+	TQString stripped = strl[strl.count() - 1];
+	qStripTags(&stripped);
+	if ((ii = d->od->tagIndex.find(LOGOFFSET(line + numNewLines))) != d->od->tagIndex.end()) {
+	    tag = *ii;
+	    while (tag && (LOGOFFSET(tag->line) == line + numNewLines)) {
+		tag->index += stripped.length();
+		tag = tag->next;
+	    }
+	}
+
+	// inject the new lines
+	TQStringList::Iterator it = strl.begin();
+	x = line;
+	int idx;
+	for (; it != strl.end(); ++it) {
+	    stripped = *it;
+	    qStripTags(&stripped);
+	    if (x == line) {
+		stripped = left + stripped;
+		idx = index;
+	    } else {
+		idx = 0;
+	    }
+	    d->od->lines[LOGOFFSET(x)] = stripped;
+	    optimParseTags(&*it, x++, idx);
+	}
+	d->od->lines[LOGOFFSET(x - 1)] += right;
+    }
+    // recalculate the pixel width of the longest injected line -
+    TQFontMetrics fm(TQScrollView::font());
+    int lWidth = 0;
+
+    for (x = line; x < line + numNewLines; x++) {
+	if (optimHasBoldMetrics(x)) {
+	    TQFont fnt = TQScrollView::font();
+	    fnt.setBold(TRUE);
+	    fm = TQFontMetrics(fnt);
+	}
+	lWidth = fm.width(d->od->lines[x]) + 4;
+	if (lWidth > d->od->maxLineWidth)
+	    d->od->maxLineWidth = lWidth;
+    }
+    resizeContents(d->od->maxLineWidth + 4, d->od->numLines * fm.lineSpacing() + 1);
+    repaintContents();
+    emit textChanged();
+}
+
+
+
+/*! \internal
+
+  Returns the first open left-tag appearing before line \a line.
+ */
+TQTextEditOptimPrivate::Tag * TQTextEdit::optimPreviousLeftTag( int line )
+{
+    TQTextEditOptimPrivate::Tag * ftag = 0;
+    TQMapConstIterator<int,TQTextEditOptimPrivate::Tag *> it;
+    if ( (it = d->od->tagIndex.find( LOGOFFSET(line) )) != d->od->tagIndex.end() )
+	ftag = it.data();
+    if ( !ftag ) {
+	// start searching for an open tag
+	ftag = d->od->tags;
+	while ( ftag ) {
+	    if ( ftag->line > line || ftag->next == 0 ) {
+		if ( ftag->line > line )
+		    ftag = ftag->prev;
+		break;
+	    }
+	    ftag = ftag->next;
+	}
+    } else {
+	ftag = ftag->prev;
+    }
+
+    if ( ftag ) {
+	if ( ftag && ftag->parent ) // use the open parent tag
+	    ftag = ftag->parent;
+	else if ( ftag && ftag->leftTag ) // this is a right-tag with no parent
+	    ftag = 0;
+    }
+    return ftag;
+}
+
+/*! \internal
+
+  Set the format for the string starting at index \a start and ending
+  at \a end according to \a tag. If \a tag is a Format tag, find the
+  first open color tag appearing before \a tag and use that tag to
+  color the string.
+*/
+void TQTextEdit::optimSetTextFormat( TQTextDocument * td, TQTextCursor * cur,
+				    TQTextFormat * f, int start, int end,
+				    TQTextEditOptimPrivate::Tag * tag )
+{
+    int formatFlags = TQTextFormat::Bold | TQTextFormat::Italic |
+		      TQTextFormat::Underline;
+    cur->setIndex( start );
+    td->setSelectionStart( 0, *cur );
+    cur->setIndex( end );
+    td->setSelectionEnd( 0, *cur );
+    TQStyleSheetItem * ssItem = styleSheet()->item( tag->tag );
+    if ( !ssItem || tag->type == TQTextEditOptimPrivate::Format ) {
+	f->setBold( tag->bold );
+	f->setItalic( tag->italic );
+	f->setUnderline( tag->underline );
+	if ( tag->type == TQTextEditOptimPrivate::Format ) {
+	    // check to see if there are any open color tags prior to
+	    // this format tag
+	    tag = tag->prev;
+	    while ( tag && (tag->type == TQTextEditOptimPrivate::Format ||
+			    tag->leftTag) ) {
+		tag = tag->leftTag ? tag->parent : tag->prev;
+	    }
+	}
+	if ( tag ) {
+	    TQString col = tag->tag.simplifyWhiteSpace();
+	    if ( col.left( 10 ) == "font color" ) {
+		int i = col.find( '=', 10 );
+		col = col.mid( i + 1 ).simplifyWhiteSpace();
+		if ( col[0] == '\"' )
+		    col = col.mid( 1, col.length() - 2 );
+	    }
+	    TQColor color = TQColor( col );
+	    if ( color.isValid() ) {
+		formatFlags |= TQTextFormat::Color;
+		f->setColor( color );
+	    }
+	}
+    } else { // use the stylesheet tag definition
+	if ( ssItem->color().isValid() ) {
+	    formatFlags |= TQTextFormat::Color;
+	    f->setColor( ssItem->color() );
+	}
+	f->setBold( ssItem->fontWeight() == TQFont::Bold );
+	f->setItalic( ssItem->fontItalic() );
+	f->setUnderline( ssItem->fontUnderline() );
+    }
+    td->setFormat( 0, f, formatFlags );
+    td->removeSelection( 0 );
+}
+
+/*! \internal */
+void TQTextEdit::optimDrawContents( TQPainter * p, int clipx, int clipy,
+				   int clipw, int cliph )
+{
+    TQFontMetrics fm( TQScrollView::font() );
+    int startLine = clipy / fm.lineSpacing();
+
+    // we always have to fetch at least two lines for drawing because the
+    // painter may be translated so that parts of two lines cover the area
+    // of a single line
+    int nLines = (cliph / fm.lineSpacing()) + 2;
+    int endLine = startLine + nLines;
+
+    if ( startLine >= d->od->numLines )
+	return;
+    if ( (startLine + nLines) > d->od->numLines )
+	nLines = d->od->numLines - startLine;
+
+    int i = 0;
+    TQString str;
+    for ( i = startLine; i < (startLine + nLines); i++ )
+	str.append( d->od->lines[ LOGOFFSET(i) ] + "\n" );
+
+    TQTextDocument * td = new TQTextDocument( 0 );
+    td->setDefaultFormat( TQScrollView::font(), TQColor() );
+    td->setPlainText( str );
+    td->setFormatter( new TQTextFormatterBreakWords ); // deleted by TQTextDoc
+    td->formatter()->setWrapEnabled( FALSE );
+    td->setTabStops(doc->tabStopWidth());
+
+    // get the current text color from the current format
+    td->selectAll( TQTextDocument::Standard );
+    TQTextFormat f;
+    f.setColor( colorGroup().text() );
+    f.setFont( TQScrollView::font() );
+    td->setFormat( TQTextDocument::Standard, &f,
+		   TQTextFormat::Color | TQTextFormat::Font );
+    td->removeSelection( TQTextDocument::Standard );
+
+    // add tag formatting
+    if ( d->od->tags ) {
+	int i = startLine;
+	TQMapConstIterator<int,TQTextEditOptimPrivate::Tag *> it;
+	TQTextEditOptimPrivate::Tag * tag = 0, * tmp = 0;
+	TQTextCursor cur( td );
+	// Step 1 - find previous left-tag
+	tmp = optimPreviousLeftTag( i );
+	for ( ; i < startLine + nLines; i++ ) {
+	    if ( (it = d->od->tagIndex.find( LOGOFFSET(i) )) != d->od->tagIndex.end() )
+		tag = it.data();
+	    // Step 2 - iterate over tags on the current line
+	    int lastIndex = 0;
+	    while ( tag && tag->line == i ) {
+		tmp = 0;
+		if ( tag->prev && !tag->prev->leftTag ) {
+		    tmp = tag->prev;
+		} else if ( tag->prev && tag->prev->parent ) {
+		    tmp = tag->prev->parent;
+		}
+		if ( (tag->index - lastIndex) > 0 && tmp ) {
+		    optimSetTextFormat( td, &cur, &f, lastIndex, tag->index, tmp );
+		}
+		lastIndex = tag->index;
+		tmp = tag;
+		tag = tag->next;
+	    }
+	    // Step 3 - color last part of the line - if necessary
+	    if ( tmp && tmp->parent )
+		tmp = tmp->parent;
+	    if ( (cur.paragraph()->length()-1 - lastIndex) > 0 && tmp && !tmp->leftTag ) {
+		optimSetTextFormat( td, &cur, &f, lastIndex,
+				    cur.paragraph()->length() - 1, tmp );
+	    }
+	    cur.setParagraph( cur.paragraph()->next() );
+	}
+        // useful debug info
+	//
+//	tag = d->od->tags;
+//	qWarning("###");
+//	while ( tag ) {
+//	    qWarning( "Tag: %p, parent: %09p, leftTag: %09p, Name: %-15s, ParentName: %s, %d%d%d", tag,
+//		       tag->parent, tag->leftTag, tag->tag.latin1(), tag->parent ? tag->parent->tag.latin1():"<none>",
+//		      tag->bold, tag->italic, tag->underline );
+//	    tag = tag->next;
+//	}
+    }
+
+    // if there is a selection, make sure that the selection in the
+    // part we need to redraw is set correctly
+    if ( optimHasSelection() ) {
+	TQTextCursor c1( td );
+	TQTextCursor c2( td );
+	int selStart = d->od->selStart.line;
+	int idxStart = d->od->selStart.index;
+	int selEnd = d->od->selEnd.line;
+	int idxEnd = d->od->selEnd.index;
+	if ( selEnd < selStart ) {
+	    qSwap( &selStart, &selEnd );
+	    qSwap( &idxStart, &idxEnd );
+	}
+	if ( selEnd > d->od->numLines-1 ) {
+	    selEnd = d->od->numLines-1;
+	}
+	if ( startLine <= selStart && endLine >= selEnd ) {
+	    // case 1: area to paint covers entire selection
+	    int paragS = selStart - startLine;
+	    int paragE = paragS + (selEnd - selStart);
+	    TQTextParagraph * parag = td->paragAt( paragS );
+	    if ( parag ) {
+		c1.setParagraph( parag );
+		if ( td->text( paragS ).length() >= (uint) idxStart )
+		    c1.setIndex( idxStart );
+	    }
+	    parag = td->paragAt( paragE );
+	    if ( parag ) {
+		c2.setParagraph( parag );
+		if ( td->text( paragE ).length() >= (uint) idxEnd )
+		    c2.setIndex( idxEnd );
+	    }
+	} else if ( startLine > selStart && endLine < selEnd ) {
+	    // case 2: area to paint is all part of the selection
+	    td->selectAll( TQTextDocument::Standard );
+	} else if ( startLine > selStart && endLine >= selEnd &&
+		    startLine <= selEnd ) {
+	    // case 3: area to paint starts inside a selection, ends past it
+	    c1.setParagraph( td->firstParagraph() );
+	    c1.setIndex( 0 );
+	    int paragE = selEnd - startLine;
+	    TQTextParagraph * parag = td->paragAt( paragE );
+	    if ( parag ) {
+		c2.setParagraph( parag );
+		if ( td->text( paragE ).length() >= (uint) idxEnd )
+		    c2.setIndex( idxEnd );
+	    }
+	} else if ( startLine <= selStart && endLine < selEnd &&
+		    endLine > selStart ) {
+	    // case 4: area to paint starts before a selection, ends inside it
+	    int paragS = selStart - startLine;
+	    TQTextParagraph * parag = td->paragAt( paragS );
+	    if ( parag ) {
+		c1.setParagraph( parag );
+		c1.setIndex( idxStart );
+	    }
+	    c2.setParagraph( td->lastParagraph() );
+	    c2.setIndex( td->lastParagraph()->string()->toString().length() - 1 );
+
+	}
+	// previously selected?
+	if ( !td->hasSelection( TQTextDocument::Standard ) ) {
+	    td->setSelectionStart( TQTextDocument::Standard, c1 );
+	    td->setSelectionEnd( TQTextDocument::Standard, c2 );
+	}
+    }
+    td->doLayout( p, contentsWidth() );
+
+    // have to align the painter so that partly visible lines are
+    // drawn at the correct position within the area that needs to be
+    // painted
+    int offset = clipy % fm.lineSpacing() + 2;
+    TQRect r( clipx, 0, clipw, cliph + offset );
+    p->translate( 0, clipy - offset );
+    td->draw( p, r.x(), r.y(), r.width(), r.height(), colorGroup() );
+    p->translate( 0, -(clipy - offset) );
+    delete td;
+}
+
+/*! \internal */
+void TQTextEdit::optimMousePressEvent( TQMouseEvent * e )
+{
+    if ( e->button() != LeftButton )
+	return;
+
+    TQFontMetrics fm( TQScrollView::font() );
+    mousePressed = TRUE;
+    mousePos = e->pos();
+    d->od->selStart.line = e->y() / fm.lineSpacing();
+    if ( d->od->selStart.line > d->od->numLines-1 ) {
+	d->od->selStart.line = d->od->numLines-1;
+	d->od->selStart.index = d->od->lines[ LOGOFFSET(d->od->numLines-1) ].length();
+    } else {
+	TQString str = d->od->lines[ LOGOFFSET(d->od->selStart.line) ];
+	d->od->selStart.index = optimCharIndex( str, mousePos.x() );
+    }
+    d->od->selEnd.line = d->od->selStart.line;
+    d->od->selEnd.index = d->od->selStart.index;
+    oldMousePos = e->pos();
+    repaintContents( FALSE );
+}
+
+/*! \internal */
+void TQTextEdit::optimMouseReleaseEvent( TQMouseEvent * e )
+{
+    if ( e->button() != LeftButton )
+	return;
+
+    if ( scrollTimer->isActive() )
+	scrollTimer->stop();
+    if ( !inDoubleClick ) {
+	TQFontMetrics fm( TQScrollView::font() );
+	d->od->selEnd.line = e->y() / fm.lineSpacing();
+	if ( d->od->selEnd.line > d->od->numLines-1 ) {
+	    d->od->selEnd.line = d->od->numLines-1;
+	}
+	TQString str = d->od->lines[ LOGOFFSET(d->od->selEnd.line) ];
+	mousePos = e->pos();
+	d->od->selEnd.index = optimCharIndex( str, mousePos.x() );
+	if ( d->od->selEnd.line < d->od->selStart.line ) {
+	    qSwap( &d->od->selStart.line, &d->od->selEnd.line );
+	    qSwap( &d->od->selStart.index, &d->od->selEnd.index );
+	} else if ( d->od->selStart.line == d->od->selEnd.line &&
+		    d->od->selStart.index > d->od->selEnd.index ) {
+	    qSwap( &d->od->selStart.index, &d->od->selEnd.index );
+	}
+	oldMousePos = e->pos();
+	repaintContents( FALSE );
+    }
+    if ( mousePressed ) {
+	mousePressed = FALSE;
+	copyToClipboard();
+    }
+
+    inDoubleClick = FALSE;
+    emit copyAvailable( optimHasSelection() );
+    emit selectionChanged();
+}
+
+/*! \internal */
+void TQTextEdit::optimMouseMoveEvent( TQMouseEvent * e )
+{
+    mousePos = e->pos();
+    optimDoAutoScroll();
+    oldMousePos = mousePos;
+}
+
+/*! \internal */
+void TQTextEdit::optimDoAutoScroll()
+{
+    if ( !mousePressed )
+	return;
+
+    TQFontMetrics fm( TQScrollView::font() );
+    TQPoint pos( mapFromGlobal( TQCursor::pos() ) );
+    bool doScroll = FALSE;
+    int xx = contentsX() + pos.x();
+    int yy = contentsY() + pos.y();
+
+    // find out how much we have to scroll in either dir.
+    if ( pos.x() < 0 || pos.x() > viewport()->width() ||
+	 pos.y() < 0 || pos.y() > viewport()->height() ) {
+	int my = yy;
+	if ( pos.x() < 0 )
+	    xx = contentsX() - fm.width( 'w');
+	else if ( pos.x() > viewport()->width() )
+	    xx = contentsX() + viewport()->width() + fm.width('w');
+
+	if ( pos.y() < 0 ) {
+	    my = contentsY() - 1;
+	    yy = (my / fm.lineSpacing()) * fm.lineSpacing() + 1;
+	} else if ( pos.y() > viewport()->height() ) {
+	    my = contentsY() + viewport()->height() + 1;
+	    yy = (my / fm.lineSpacing() + 1) * fm.lineSpacing() - 1;
+	}
+	d->od->selEnd.line = my / fm.lineSpacing();
+	mousePos.setX( xx );
+	mousePos.setY( my );
+	doScroll = TRUE;
+    } else {
+	d->od->selEnd.line = mousePos.y() / fm.lineSpacing();
+    }
+
+    if ( d->od->selEnd.line < 0 ) {
+	d->od->selEnd.line = 0;
+    } else if ( d->od->selEnd.line > d->od->numLines-1 ) {
+	d->od->selEnd.line = d->od->numLines-1;
+    }
+
+    TQString str = d->od->lines[ LOGOFFSET(d->od->selEnd.line) ];
+    d->od->selEnd.index = optimCharIndex( str, mousePos.x() );
+
+    // have to have a valid index before generating a paint event
+    if ( doScroll )
+	ensureVisible( xx, yy, 1, 1 );
+
+    // if the text document is smaller than the heigth of the viewport
+    // - redraw the whole thing otherwise calculate the rect that
+    // needs drawing.
+    if ( d->od->numLines * fm.lineSpacing() < viewport()->height() ) {
+	repaintContents( contentsX(), contentsY(), width(), height(), FALSE );
+    } else {
+	int h = TQABS(mousePos.y() - oldMousePos.y()) + fm.lineSpacing() * 2;
+	int y;
+	if ( oldMousePos.y() < mousePos.y() ) {
+	    y = oldMousePos.y() - fm.lineSpacing();
+	} else {
+	    // expand paint area for a fully selected line
+	    h += fm.lineSpacing();
+	    y = mousePos.y() - fm.lineSpacing()*2;
+	}
+	if ( y < 0 )
+	    y = 0;
+	repaintContents( contentsX(), y, width(), h, FALSE );
+    }
+
+    if ( !scrollTimer->isActive() && pos.y() < 0 || pos.y() > height() )
+	scrollTimer->start( 100, FALSE );
+    else if ( scrollTimer->isActive() && pos.y() >= 0 && pos.y() <= height() )
+	scrollTimer->stop();
+}
+
+/*! \internal
+
+  Returns the index of the character in the string \a str that is
+  currently under the mouse pointer.
+*/
+int TQTextEdit::optimCharIndex( const TQString &str, int mx ) const
+{
+    TQFontMetrics fm(TQScrollView::font());
+    uint i = 0;
+    int dd, dist = 10000000;
+    int curpos = 0;
+    int strWidth;
+    mx = mx - 4; // ### get the real margin from somewhere
+
+    if (!str.contains('\t') && mx > fm.width(str))
+	return str.length();
+
+    while (i < str.length()) {
+	strWidth = qStrWidth(str.left(i), tabStopWidth(), fm);
+	dd = strWidth - mx;
+	if (TQABS(dd) <= dist) {
+	    dist = TQABS(dd);
+	    if (mx >= strWidth)
+		curpos = i;
+	}
+	++i;
+    }
+    return curpos;
+}
+
+/*! \internal */
+void TQTextEdit::optimSelectAll()
+{
+    d->od->selStart.line = d->od->selStart.index = 0;
+    d->od->selEnd.line = d->od->numLines - 1;
+    d->od->selEnd.index = d->od->lines[ LOGOFFSET(d->od->selEnd.line) ].length();
+
+    repaintContents( FALSE );
+    emit copyAvailable( optimHasSelection() );
+    emit selectionChanged();
+}
+
+/*! \internal */
+void TQTextEdit::optimRemoveSelection()
+{
+    d->od->selStart.line = d->od->selEnd.line = -1;
+    d->od->selStart.index = d->od->selEnd.index = -1;
+    repaintContents( FALSE );
+}
+
+/*! \internal */
+void TQTextEdit::optimSetSelection( int startLine, int startIdx,
+				       int endLine, int endIdx )
+{
+    d->od->selStart.line = startLine;
+    d->od->selEnd.line = endLine;
+    d->od->selStart.index = startIdx;
+    d->od->selEnd.index = endIdx;
+}
+
+/*! \internal */
+bool TQTextEdit::optimHasSelection() const
+{
+    if ( d->od->selStart.line != d->od->selEnd.line ||
+	 d->od->selStart.index != d->od->selEnd.index )
+	return TRUE;
+    return FALSE;
+}
+
+/*! \internal */
+TQString TQTextEdit::optimSelectedText() const
+{
+    TQString str;
+
+    if ( !optimHasSelection() )
+	return str;
+
+    // concatenate all strings
+    if ( d->od->selStart.line == d->od->selEnd.line ) {
+	str = d->od->lines[ LOGOFFSET(d->od->selEnd.line) ].mid( d->od->selStart.index,
+			   d->od->selEnd.index - d->od->selStart.index );
+    } else {
+	int i = d->od->selStart.line;
+	str = d->od->lines[ LOGOFFSET(i) ].right( d->od->lines[ LOGOFFSET(i) ].length() -
+				  d->od->selStart.index ) + "\n";
+	i++;
+	for ( ; i < d->od->selEnd.line; i++ ) {
+	    if ( d->od->lines[ LOGOFFSET(i) ].isEmpty() ) // CR lines are empty
+		str += "\n";
+	    else
+		str += d->od->lines[ LOGOFFSET(i) ] + "\n";
+	}
+	str += d->od->lines[ LOGOFFSET(d->od->selEnd.line) ].left( d->od->selEnd.index );
+    }
+    return str;
+}
+
+/*! \internal */
+bool TQTextEdit::optimFind( const TQString & expr, bool cs, bool /*wo*/,
+			       bool fw, int * para, int * index )
+{
+    bool found = FALSE;
+    int parag = para ? *para : d->od->search.line,
+	  idx = index ? *index : d->od->search.index, i;
+
+    if ( d->od->len == 0 )
+	return FALSE;
+
+    for ( i = parag; fw ? i < d->od->numLines : i >= 0; fw ? i++ : i-- ) {
+	idx = fw ? d->od->lines[ LOGOFFSET(i) ].find( expr, idx, cs ) :
+	      d->od->lines[ LOGOFFSET(i) ].findRev( expr, idx, cs );
+	if ( idx != -1 ) {
+	    found = TRUE;
+	    break;
+	} else if ( fw )
+	    idx = 0;
+    }
+
+    if ( found ) {
+	if ( index )
+	    *index = idx;
+	if ( para )
+	    *para = i;
+	d->od->search.index = idx + 1;
+	d->od->search.line = i;
+	optimSetSelection( i, idx, i, idx + expr.length() );
+	TQFontMetrics fm( TQScrollView::font() );
+	int h = fm.lineSpacing();
+	int x = fm.width( d->od->lines[ LOGOFFSET(i) ].left( idx + expr.length()) ) + 4;
+	ensureVisible( x, i * h + h / 2, 1, h / 2 + 2 );
+	repaintContents(); // could possibly be optimized
+    }
+    return found;
+}
+
+/*! \reimp */
+void TQTextEdit::polish()
+{
+    // this will ensure that the last line is visible if text have
+    // been added to the widget before it is shown
+    if ( d->optimMode )
+	scrollToBottom();
+    TQWidget::polish();
+}
+
+/*!
+    Sets the maximum number of lines a TQTextEdit can hold in \c
+    LogText mode to \a limit. If \a limit is -1 (the default), this
+    signifies an unlimited number of lines.
+
+    \warning Never use formatting tags that span more than one line
+    when the maximum log lines is set. When lines are removed from the
+    top of the buffer it could result in an unbalanced tag pair, i.e.
+    the left formatting tag is removed before the right one.
+ */
+void TQTextEdit::setMaxLogLines( int limit )
+{
+    d->maxLogLines = limit;
+    if ( d->maxLogLines < -1 )
+	d->maxLogLines = -1;
+    if ( d->maxLogLines == -1 )
+	d->logOffset = 0;
+}
+
+/*!
+    Returns the maximum number of lines TQTextEdit can hold in \c
+    LogText mode. By default the number of lines is unlimited, which
+    is signified by a value of -1.
+ */
+int TQTextEdit::maxLogLines()
+{
+    return d->maxLogLines;
+}
+
+/*!
+    Check if the number of lines in the buffer is limited, and uphold
+    that limit when appending new lines.
+ */
+void TQTextEdit::optimCheckLimit( const TQString& str )
+{
+    if ( d->maxLogLines > -1 && d->maxLogLines <= d->od->numLines ) {
+	// NB! Removing the top line in the buffer will potentially
+	// destroy the structure holding the formatting tags - if line
+	// spanning tags are used.
+	TQTextEditOptimPrivate::Tag *t = d->od->tags, *tmp, *itr;
+	TQPtrList<TQTextEditOptimPrivate::Tag> lst;
+	while ( t ) {
+	    t->line -= 1;
+	    // unhook the ptr from the tag structure
+	    if ( ((uint) LOGOFFSET(t->line) < (uint) d->logOffset &&
+		  (uint) LOGOFFSET(t->line) < (uint) LOGOFFSET(d->od->numLines) &&
+		  (uint) LOGOFFSET(d->od->numLines) > (uint) d->logOffset) )
+	    {
+		if ( t->prev )
+		    t->prev->next = t->next;
+		if ( t->next )
+		    t->next->prev = t->prev;
+		if ( d->od->tags == t )
+		    d->od->tags = t->next;
+		if ( d->od->lastTag == t ) {
+		    if ( t->prev )
+			d->od->lastTag = t->prev;
+		    else
+			d->od->lastTag = d->od->tags;
+		}
+		tmp = t;
+		t = t->next;
+		lst.append( tmp );
+		delete tmp;
+	    } else {
+		t = t->next;
+	    }
+	}
+	// Remove all references to the ptrs we just deleted
+	itr = d->od->tags;
+	while ( itr ){
+	    for ( tmp = lst.first(); tmp; tmp = lst.next() ) {
+		if ( itr->parent == tmp )
+		    itr->parent = 0;
+		if ( itr->leftTag == tmp )
+		    itr->leftTag = 0;
+	    }
+	    itr = itr->next;
+	}
+	// ...in the tag index as well
+	TQMapIterator<int, TQTextEditOptimPrivate::Tag *> idx;
+	if ( (idx = d->od->tagIndex.find( d->logOffset )) != d->od->tagIndex.end() )
+	    d->od->tagIndex.remove( idx );
+
+	TQMapIterator<int,TQString> it;
+	if ( (it = d->od->lines.find( d->logOffset )) != d->od->lines.end() ) {
+	    d->od->len -= (*it).length();
+	    d->od->lines.remove( it );
+	    d->od->numLines--;
+	    d->logOffset = LOGOFFSET(1);
+	}
+    }
+    d->od->len += str.length();
+    d->od->lines[ LOGOFFSET(d->od->numLines++) ] = str;
+}
+
+#endif // QT_TEXTEDIT_OPTIMIZATION
+
+/*!
+    \property TQTextEdit::autoFormatting
+    \brief the enabled set of auto formatting features
+
+    The value can be any combination of the values in the \c
+    AutoFormatting enum.  The default is \c AutoAll. Choose \c AutoNone
+    to disable all automatic formatting.
+
+    Currently, the only automatic formatting feature provided is \c
+    AutoBulletList; future versions of TQt may offer more.
+*/
+
+void TQTextEdit::setAutoFormatting( uint features )
+{
+    d->autoFormatting = features;
+}
+
+uint TQTextEdit::autoFormatting() const
+{
+    return d->autoFormatting;
+}
+
+/*!
+    Returns the TQSyntaxHighlighter set on this TQTextEdit. 0 is
+    returned if no syntax highlighter is set.
+ */
+TQSyntaxHighlighter * TQTextEdit::syntaxHighlighter() const
+{
+    if (document()->preProcessor())
+	return ((TQSyntaxHighlighterInternal *) document()->preProcessor())->highlighter;
+    else
+	return 0;
+}
+
+#endif //QT_NO_TEXTEDIT