diff options
Diffstat (limited to 'experimental/tqtinterface/qt4/src/attic/qtmultilineedit.cpp')
-rw-r--r-- | experimental/tqtinterface/qt4/src/attic/qtmultilineedit.cpp | 4236 |
1 files changed, 4236 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/attic/qtmultilineedit.cpp b/experimental/tqtinterface/qt4/src/attic/qtmultilineedit.cpp new file mode 100644 index 000000000..203ed5643 --- /dev/null +++ b/experimental/tqtinterface/qt4/src/attic/qtmultilineedit.cpp @@ -0,0 +1,4236 @@ +/********************************************************************** +** +** Implementation of TQtMultiLineEdit widget class +** +** Created : 961005 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file tqcontains a class moved out of the TQt GUI Toolkit API. It +** may be used, distributed and modified without limitation. +** +**********************************************************************/ + +#include "tqtmultilineedit.h" +#ifndef TQT_NO_TQTMULTILINEEDIT +#include "tqpainter.h" +#include "tqscrollbar.h" +#include "tqclipboard.h" +#include "tqpixmap.h" +#include "tqregexp.h" +#include "tqapplication.h" +#include "tqdragobject.h" +#include "tqpopupmenu.h" +#include "tqtimer.h" +#include "tqdict.h" +#include "tqcursor.h" +#ifndef TQT_NO_COMPAT +#include "tqstyle.h" +#endif + + +class TQtMultiLineEditCommand +{ +public: + enum Commands { Invalid, Begin, End, Insert, Delete }; + virtual ~TQtMultiLineEditCommand() {}; + virtual Commands type() { return Invalid; }; + virtual int terminator() { return 0; } + + virtual bool merge( TQtMultiLineEditCommand* ) { return FALSE;} +}; + +class TQBeginCommand : public TQtMultiLineEditCommand +{ + +public: + TQBeginCommand() {} + int terminator() { return 1; } + Commands type() { return Begin; }; +}; + +class TQEndCommand : public TQtMultiLineEditCommand +{ +public: + TQEndCommand() {} + int terminator() { return -1; } + Commands type() { return End; }; +}; + +// TQtMultiLineEditUndoRedo methods +class TQDelTextCmd : public TQtMultiLineEditCommand +{ +public: + int mOffset; + TQString mStr; + + // have to handle deletion of current selection + TQDelTextCmd(int offset, const TQString &str ) + : mOffset( offset ), + mStr ( str ) + { + } + Commands type() { return Delete; }; + + bool merge( TQtMultiLineEditCommand* other) + { + if ( other->type() == type() ) { + TQDelTextCmd* o = (TQDelTextCmd*) other; + if ( mOffset + int(mStr.length()) == o->mOffset ) { + o->mStr.prepend( mStr ); + o->mOffset = mOffset; + return TRUE; + } + } + return FALSE; + } + + +}; + +class TQInsTextCmd : public TQDelTextCmd +{ + +public: + TQInsTextCmd(int offset,const TQString &str ) + : TQDelTextCmd( offset, str ) + { + } + + Commands type() { return Insert; }; + + bool merge( TQtMultiLineEditCommand* other) + { + if ( other->type() == type() ) { + TQInsTextCmd* o = (TQInsTextCmd*) other; + if ( mOffset == o->mOffset + int(o->mStr.length()) ) { + o->mStr += mStr; + return TRUE; + } + } + return FALSE; + } +}; + + +/* + \class TQtMultiLineEdit qtmultilineedit.h + + \brief The TQtMultiLineEdit widget is a simple editor for inputting text. + + \obsolete + + The TQtMultiLineEdit widget provides multiple line text input and display. + It is intended for moderate amounts of text. There are no arbitrary + limitations, but if you try to handle megabytes of data, performance + will suffer. + + Per default, the edit widget does not perform any word + wrapping. This can be adjusted by calling setWordWrap(). Both + dynamic wrapping according to the visible width or a fixed number of + character or pixels is supported. + + The widget can be used to display text by calling setReadOnly(TRUE). + + The default key bindings are described in keyPressEvent(); they cannot + be customized except by inheriting the class. + + <img src=qmlined-m.png> <img src=qmlined-w.png> +*/ + +/* + \property TQtMultiLineEdit::numLines + \brief the number of lines in the multi-line edit + + numLines() returns the number of lines in the editor. The count + includes any empty lines at top and bottom, so for an empty editor + this method will return 1. +*/ +/* + \property TQtMultiLineEdit::atBeginning + \brief whether the cursor is at the beginning + + atBeginning() returns TRUE if the cursor is placed at the + beginning of the text. +*/ +/* + \property TQtMultiLineEdit::atEnd + \brief whether the cursor is at the end + + atEnd() returns TRUE if the cursor is placed at the end of the text. +*/ +/* + \property TQtMultiLineEdit::maxLineWidth + \brief the maximum line width in pixels + Returns the width in pixels of the longest text line in this editor. +*/ +/* + \property TQtMultiLineEdit::tqalignment + \brief the tqalignment + + Possible values are \c AlignLeft, \c Align(H)Center and \c + AlignRight. + \sa TQt::AlignmentFlags +*/ +/* + \property TQtMultiLineEdit::edited + \brief whether the text had been edited + +edited() returns the edited flag of the line edit. If this returns FALSE, +the contents has not been changed since the construction of the +TQtMultiLineEdit (or the last call to setEdited( FALSE ), if any). If +it returns TRUE, the contents have been edited, or setEdited( TRUE ) +has been called. + +setEdited() sets the edited flag of this line edit to \e e. The +edited flag is never read by TQtMultiLineEdit, but is changed to TRUE +whenever the user changes its contents. + +This is useful e.g. for things that need to provide a default value, +but cannot tqfind the default at once. Just open the widget without the +best default and when the default is known, check the edited() return +value and set the line edit's contents if the user has not started +editing the line edit. Another example is to detect whether the +contents need saving. + +*/ +/* + \property TQtMultiLineEdit::echoMode + \brief the echo mode +*/ +/* + \property TQtMultiLineEdit::maxLength + \brief the maximum length of the text + + The currently set text length limit, or -1 if there is + no limit (this is the default). + +*/ +/* + \property TQtMultiLineEdit::maxLines + \brief the maximum number of lines + The currently set line limit, or -1 if there is + no limit (the default). + + Note that excess lines are deleted from the \e bottom of the + lines. If you want teletype behaviour with lines disappearing + from the \e top as the limit is exceed, you probably just want + to use removeLine(0) prior to adding an excess line. + +*/ +/* + \property TQtMultiLineEdit::hMargin + \brief the horizontal margin + The horizontal margin current set. The default is 3. +*/ +/* + \property TQtMultiLineEdit::wordWrap + \brief the word wrap mode + + By default, wrapping keeps words intact. To allow breaking within + words, set the wrap policy to \c Anywhere (see setWrapPolicy() ). + + The default wrap mode is \c NoWrap. + + \sa wordWrap(), setWrapColumnOrWidth(), setWrapPolicy() +*/ +/* + \property TQtMultiLineEdit::wrapColumnOrWidth + \brief the wrap width in columns or pixels + The wrap column or wrap width, depending on the word wrap + mode. + \sa setWordWrap(), setWrapColumnOrWidth() +*/ +/* + \property TQtMultiLineEdit::wrapPolicy + \brief the wrap policy mode + The default is \c AtWhiteSpace. + +*/ +/* + \property TQtMultiLineEdit::autoUpdate + \brief whether auto update is enabled + + autoUpdate() returns TRUE if the view updates itself automatically + whenever it is changed in some way. + + If autoUpdate() is TRUE (this is the default) then the editor updates + itself automatically whenever it has changed in some way (generally, + when text has been inserted or deleted). + + If autoUpdate() is FALSE, the view does NOT tqrepaint itself, or update + its internal state variables itself when it is changed. This can be + useful to avoid flicker during large changes, and is singularly + useless otherwise: Disable auto-update, do the changes, re-enable + auto-update, and call tqrepaint(). + + \warning Do not leave the view in this state for a long time + (i.e. between events ). If, for example, the user interacts with the + view when auto-update is off, strange things can happen. + + Setting auto-update to TRUE does not tqrepaint the view, you must call + tqrepaint() to do this (preferable tqrepaint(FALSE) to avoid flicker). + + \sa autoUpdate() tqrepaint() + +*/ +/* + \property TQtMultiLineEdit::undoEnabled + \brief whether undo is enabled +*/ +/* + \property TQtMultiLineEdit::undoDepth + \brief the undo depth + + The maximum number of operations that can be stored on the undo stack. + + \sa setUndoDepth() +*/ +/* + \property TQtMultiLineEdit::readOnly + \brief whether the multi-line edit is read-only +*/ +/* + \property TQtMultiLineEdit::overWriteMode + \brief the overwrite mode +*/ +/* + \property TQtMultiLineEdit::text + \brief the multi-line edit's text +*/ +/* + \property TQtMultiLineEdit::length + \brief the length of the text +*/ + +static const char * const arrow_xpm[] = { + " 8 8 2 1", + ". c None", + "# c #000000", + "........", + "..####..", + "..#####.", + ".....##.", + ".#..###.", + ".#####..", + ".####...", + ".#####.." +}; + +enum { + IdUndo, + IdRedo, +#ifndef TQT_NO_CLIPBOARD + IdCut, + IdCopy, + IdPaste, + IdPasteSpecial, +#endif + IdClear, + IdSelectAll, + IdCount +}; + +struct TQtMultiLineData +{ + TQtMultiLineData() : + isHandlingEvent(FALSE), + edited(FALSE), + maxLineWidth(0), + align(TQt::AlignLeft), + maxlines(-1), + maxlinelen(-1), + maxlen(-1), + wordwrap( TQtMultiLineEdit::NoWrap ), + wrapcol( -1 ), + wrappolicy( TQtMultiLineEdit::AtWhiteSpace ), + // This doesn't use font bearings, as textWidthWithTabs does that. + // This is just an aesthetics value. + // It should probably be TQMAX(0,3-fontMetrics().minLeftBearing()) though, + // as bearings give some border anyway. + lr_marg(3), + marg_extra(0), + echomode(TQtMultiLineEdit::Normal), + val(0), + dnd_primed(FALSE), + dnd_forcecursor(FALSE), + undo( TRUE ), + undodepth( 256 ) + { + undoList.setAutoDelete( TRUE ); + redoList.setAutoDelete( TRUE ); + clearChartable(); + } + bool isHandlingEvent; + bool edited; + int maxLineWidth; + int scrollTime; + int scrollAccel; + int align; + int numlines; + int maxlines; + int maxlinelen; + int maxlen; + TQtMultiLineEdit::WordWrap wordwrap; + int wrapcol; + TQtMultiLineEdit::WrapPolicy wrappolicy; + int lr_marg; + int marg_extra; + TQtMultiLineEdit::EchoMode echomode; + const TQValidator* val; + + bool dnd_primed; // If TRUE, user has pressed + bool dnd_forcecursor; // If TRUE show cursor for DND feedback, + // even if !hasFocus() + TQPtrList<TQtMultiLineEditCommand> undoList; + TQPtrList<TQtMultiLineEditCommand> redoList; + bool undo; + int undodepth; + short chartable[256]; + void clearChartable() + { + int i = 256; + while ( i ) + chartable[--i] = 0; + } + TQPixmap arrow; + TQPoint dnd_startpos; + TQTimer *blinkTimer, *scrollTimer; +#ifndef TQT_NO_DRAGANDDROP + TQTimer *dnd_timer; +#endif +}; + + +#define CLEAR_UNDO {d->undoList.clear(); emit undoAvailable( FALSE );\ + d->redoList.clear(); emit redoAvailable( FALSE );} + +void TQtMultiLineEdit::addUndoCmd(TQtMultiLineEditCommand* c) +{ + if ( d->undoList.isEmpty() ) + emit undoAvailable(TRUE); + else if ( c->merge( d->undoList.last() ) ) { + delete c; + return; + } + if ( int(d->undoList.count()) >= d->undodepth ) + d->undoList.removeFirst(); + d->undoList.append(c); + + if ( !d->redoList.isEmpty() ) { + d->redoList.clear(); + emit redoAvailable( FALSE ); + } +} + +void TQtMultiLineEdit::addRedoCmd(TQtMultiLineEditCommand* c) +{ + if ( d->redoList.isEmpty() ) + emit redoAvailable(TRUE); + d->redoList.append(c); +} + +static const int initialScrollTime = 50; // mark text scroll time +static const int initialScrollAccel = 5; // mark text scroll accel (0=fastest) +static const int scroll_margin = 16; // auto-scroll edge in DND + +#define WORD_WRAP ( d->wordwrap != TQtMultiLineEdit::NoWrap ) +#define DYNAMIC_WRAP ( d->wordwrap == TQtMultiLineEdit::WidgetWidth ) +#define FIXED_WIDTH_WRAP ( d->wordwrap == TQtMultiLineEdit::FixedPixelWidth ) +#define FIXED_COLUMN_WRAP ( d->wordwrap == TQtMultiLineEdit::FixedColumnWidth ) +#define BREAK_WITHIN_WORDS ( d->wrappolicy == TQtMultiLineEdit::Anywhere ) + +static int defTabStop = 8; + +static int tabStopDist( const TQFontMetrics &fm ) +{ + int dist; + dist = fm.width( TQChar('x' )); + if( dist == 0 ) + dist = fm.maxWidth(); + return defTabStop*dist; +} + + +/* + Sets the distance between tab stops for all TQtMultiLineEdit instances + to \a ex, which is measured in multiples of the width of a lower case 'x' + in the widget's font. The initial value is 8. + + \warning This function does not cause a redraw. It is best to call + it before any TQtMultiLineEdit widgets are shown. + + \sa defaultTabStop() +*/ + +void TQtMultiLineEdit::setDefaultTabStop( int ex ) +{ + defTabStop = ex; +} + + + +/* + Returns the distance between tab stops. + + \sa setDefaultTabStop(); +*/ + +int TQtMultiLineEdit::defaultTabStop() +{ + return defTabStop; +} + + + + +static int textWidthWithTabs( const TQFontMetrics &fm, const TQString &s, uint start, uint nChars, int align ) +{ + if ( s.isEmpty() ) + return 0; + + int dist = -fm.leftBearing( s[(int)start] ); + int i = start; + int tabDist = -1; // lazy eval + while ( (uint)i < s.length() && (uint)i < start+nChars ) { + if ( s[i] == '\t' && align == TQt::AlignLeft ) { + if ( tabDist<0 ) + tabDist = tabStopDist(fm); + dist = ( (dist+tabDist+1)/tabDist ) * tabDist; + i++; + } else { + int ii = i; + while ( (uint)i < s.length() && (uint)i < start + nChars && ( align != TQt::AlignLeft || s[i] != '\t' ) ) + i++; + dist += fm.width( s.mid(ii,i-ii) ); + } + } + return dist; +} + +static int xPosToCursorPos( const TQString &s, const TQFontMetrics &fm, + int xPos, int width, int align ) +{ + int i = 0; + int dist; + int tabDist; + + if ( s.isEmpty() ) + return 0; + if ( xPos > width ) + xPos = width; + if ( xPos <= 0 ) + return 0; + + dist = -fm.leftBearing( s[0] ); + + if ( align == TQt::AlignCenter || align == TQt::AlignHCenter ) + dist = ( width - textWidthWithTabs( fm, s, 0, s.length(), align ) ) / 2; + else if ( align == TQt::AlignRight ) + dist = width - textWidthWithTabs( fm, s, 0, s.length(), align ); + + int distBeforeLastTab = dist; + tabDist = tabStopDist(fm); + while ( (uint)i < s.length() && dist < xPos ) { + if ( s[i] == '\t' && align == TQt::AlignLeft ) { + distBeforeLastTab = dist; + dist = (dist/tabDist + 1) * tabDist; + } else { + dist += fm.width( s[i] ); + } + i++; + } + if ( dist > xPos ) { + if ( dist > width ) { + i--; + } else { + if ( s[i-1] == '\t' && align == TQt::AlignLeft ) { // dist equals a tab stop position + if ( xPos - distBeforeLastTab < (dist - distBeforeLastTab)/2 ) + i--; + } else { + if ( fm.width(s[i-1])/2 < dist-xPos ) + i--; + } + } + } + return i; +} + +/* + Constructs a new, empty, TQtMultiLineEdit with tqparent \a tqparent and + called \a name. +*/ + +TQtMultiLineEdit::TQtMultiLineEdit( TQWidget *tqparent , const char *name ) + :TQtTableView( tqparent, name, WStaticContents | WRepaintNoErase ) +{ + d = new TQtMultiLineData; + TQFontMetrics fm( font() ); + setCellHeight( fm.lineSpacing() ); + setNumCols( 1 ); + + contents = new TQPtrList<TQtMultiLineEditRow>; + contents->setAutoDelete( TRUE ); + + cursorX = 0; cursorY = 0; + curXPos = 0; + + setTableFlags( Tbl_autoVScrollBar|Tbl_autoHScrollBar| + Tbl_smoothVScrolling | + Tbl_clipCellPainting + ); + setFrameStyle( TQFrame::WinPanel | TQFrame::Sunken ); + setBackgroundMode( PaletteBase ); + setWFlags( WResizeNoErase ); + setKeyCompression( TRUE ); + setFocusPolicy( WheelFocus ); +#ifndef TQT_NO_CURSOR + setCursor( ibeamCursor ); + verticalScrollBar()->setCursor( arrowCursor ); + horizontalScrollBar()->setCursor( arrowCursor ); +#endif + readOnly = FALSE; + cursorOn = FALSE; + markIsOn = FALSE; + dragScrolling = FALSE; + dragMarking = FALSE; + textDirty = FALSE; + wordMark = FALSE; + overWrite = FALSE; + markAnchorX = 0; + markAnchorY = 0; + markDragX = 0; + markDragY = 0; + d->blinkTimer = new TQTimer( this ); + connect( d->blinkTimer, TQT_SIGNAL( timeout() ), + this, TQT_SLOT( blinkTimerTimeout() ) ); + d->scrollTimer = new TQTimer( this ); + connect( d->scrollTimer, TQT_SIGNAL( timeout() ), + this, TQT_SLOT( scrollTimerTimeout() ) ); +#ifndef TQT_NO_DRAGANDDROP + d->dnd_timer = new TQTimer( this ); + connect( d->dnd_timer, TQT_SIGNAL( timeout() ), + this, TQT_SLOT( dndTimeout() ) ); +#endif + d->scrollTime = 0; + + dummy = TRUE; + + int w = textWidth( TQString::tqfromLatin1("") ); + contents->append( new TQtMultiLineEditRow(TQString::tqfromLatin1(""), w) ); + (void)setNumRowsAndTruncate(); + setWidth( w ); + setAcceptDrops(TRUE); + if ( d->maxlines >= 0 && d->maxlines <= 6 ) { + tqsetSizePolicy( TQSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Fixed ) ); + } else { + tqsetSizePolicy( TQSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Expanding ) ); + } +} + +/* + \fn int TQtMultiLineEdit::lineLength( int line ) const + Returns the number of characters at line number \a line. +*/ + +/* \fn TQString *TQtMultiLineEdit::getString( int line ) const + + Returns a pointer to the text at line \a line. +*/ + +/* \fn void TQtMultiLineEdit::textChanged() + + This signal is emitted when the text is changed by an event or by a + slot. Note that the signal is not emitted when you call a non-slot + function such as insertLine(). + + \sa returnPressed() +*/ + +/* \fn void TQtMultiLineEdit::returnPressed() + + This signal is emitted when the user presses the return or enter + key. It is not emitted if isReadOnly() is TRUE. + + \sa textChanged() +*/ + +/* + \fn void TQtMultiLineEdit::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. +*/ + +/* + \fn void TQtMultiLineEdit::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. +*/ + +/* + \fn void TQtMultiLineEdit::copyAvailable (bool yes) + + This signal is emitted when the availability of cut/copy changes. + If \a yes is TRUE, then cut() and copy() will work until + copyAvailable( FALSE ) is next emitted. +*/ + + +/* + If \a on is FALSE, this multi line edit accepts text input. + Scrolling and cursor movements are accepted in any case. + + \sa isReadOnly() TQWidget::setEnabled() +*/ + +void TQtMultiLineEdit::setReadOnly( bool on ) +{ + if ( readOnly != on ) { + readOnly = on; +#ifndef TQT_NO_CURSOR + setCursor( on ? arrowCursor : ibeamCursor ); +#endif + } +} + +/* +*/ +int TQtMultiLineEdit::maxLineWidth() const +{ + return d->maxLineWidth; +} + +/* + Destroys the TQtMultiLineEdit +*/ + +TQtMultiLineEdit::~TQtMultiLineEdit() +{ + delete contents; + delete d; +} + +static TQPixmap *buffer = 0; + +static void cleanupMLBuffer() +{ + delete buffer; + buffer = 0; +} + +static TQPixmap *getCacheBuffer( TQSize sz ) +{ + if ( !buffer ) { + qAddPostRoutine( cleanupMLBuffer ); + buffer = new TQPixmap; + } + + if ( buffer->width() < sz.width() || buffer->height() < sz.height() ) + buffer->resize( sz ); + return buffer; +} + +/* + Implements the basic drawing logic. Paints the line at row \a row + using painter \a painter. The \a col parameter is ignored. +*/ +void TQtMultiLineEdit::paintCell( TQPainter *painter, int row, int ) +{ + const TQColorGroup & g = tqcolorGroup(); + TQFontMetrics fm( painter->font() ); + TQString s = stringShown(row); + if ( s.isNull() ) { + qWarning( "TQtMultiLineEdit::paintCell: (%s) no text at line %d", + name( "unnamed" ), row ); + return; + } + TQRect updateR = cellUpdateRect(); + TQPixmap *buffer = getCacheBuffer( updateR.size() ); + ASSERT(buffer); + buffer->fill ( g.base() ); + + TQPainter p( buffer ); + p.setFont( painter->font() ); + p.translate( -updateR.left(), -updateR.top() ); + + p.setTabStops( tabStopDist(fm) ); + + int yPos = 0; + int markX1, markX2; // in x-coordinate pixels + markX1 = markX2 = 0; // avoid gcc warning + if ( markIsOn ) { + int markBeginX, markBeginY; + int markEndX, markEndY; + getMarkedRegion( &markBeginY, &markBeginX, &markEndY, &markEndX ); + if ( row >= markBeginY && row <= markEndY ) { + if ( row == markBeginY ) { + markX1 = markBeginX; + if ( row == markEndY ) // both marks on same row + markX2 = markEndX; + else + markX2 = s.length(); // mark till end of line + } else { + if ( row == markEndY ) { + markX1 = 0; + markX2 = markEndX; + } else { + markX1 = 0; // whole line is marked + markX2 = s.length(); // whole line is marked + } + } + } + } + p.setPen( g.text() ); + TQtMultiLineEditRow* r = contents->at( row ); + int wcell = cellWidth() - 2*d->lr_marg;// - d->marg_extra; + int wrow = r->w; + int x = d->lr_marg - p.fontMetrics().leftBearing(s[0]); + if ( d->align == TQt::AlignCenter || d->align == TQt::AlignHCenter ) + x += (wcell - wrow) / 2; + else if ( d->align == TQt::AlignRight ) + x += wcell - wrow; + p.drawText( x, yPos, cellWidth()-d->lr_marg-x, cellHeight(), + d->align == AlignLeft?ExpandTabs:0, s ); + if ( !r->newline && BREAK_WITHIN_WORDS ) + p.drawPixmap( x + wrow - d->lr_marg - d->marg_extra, yPos, d->arrow ); +#if 0 + if ( r->newline ) + p.drawLine( d->lr_marg, yPos+cellHeight()-2, cellWidth() - d->lr_marg, yPos+cellHeight()-2); +#endif + if ( markX1 != markX2 ) { + int sLength = s.length(); + int xpos1 = mapToView( markX1, row ); + int xpos2 = mapToView( markX2, row ); + int fillxpos1 = xpos1; + int fillxpos2 = xpos2; + if ( markX1 == 0 ) + fillxpos1 -= 2; + if ( markX2 == sLength ) + fillxpos2 += 3; + p.setClipping( TRUE ); + p.setClipRect( fillxpos1 - updateR.left(), 0, + fillxpos2 - fillxpos1, cellHeight(row) ); + p.fillRect( fillxpos1, 0, fillxpos2 - fillxpos1, cellHeight(row), + g.brush( TQColorGroup::Highlight ) ); + p.setPen( g.highlightedText() ); + p.drawText( x, yPos, cellWidth()-d->lr_marg-x, cellHeight(), + d->align == AlignLeft?ExpandTabs:0, s ); + p.setClipping( FALSE ); + } + + if ( row == cursorY && cursorOn && !readOnly ) { + int cursorPos = TQMIN( (int)s.length(), cursorX ); + int cXPos = TQMAX( mapToView( cursorPos, row ), 0 ); + int cYPos = 0; + if ( hasFocus() || d->dnd_forcecursor ) { + p.setPen( g.text() ); + /* styled? + p.drawLine( cXPos - 2, cYPos, + cXPos + 2, cYPos ); + */ + p.drawLine( cXPos, cYPos, + cXPos, cYPos + fm.height() - 2); + /* styled? + p.drawLine( cXPos - 2, cYPos + fm.height() - 2, + cXPos + 2, cYPos + fm.height() - 2); + */ + +#ifndef TQT_NO_TRANSFORMATIONS + // TODO: set it other times, eg. when scrollbar moves view + TQWMatrix wm = painter->tqworldMatrix(); + setMicroFocusHint( int(wm.dx()+cXPos), + int (wm.dy()+cYPos), + 1, fm.ascent() ); +#else + setMicroFocusHint( cXPos, + cYPos, + 1, fm.ascent() ); +#endif + } + } + p.end(); + painter->drawPixmap( updateR.left(), updateR.top(), *buffer, + 0, 0, updateR.width(), updateR.height() ); +} + + +/* + \overload + Returns the width in pixels of the string \a s. + NOTE: only appropriate for whole lines. +*/ + +int TQtMultiLineEdit::textWidth( const TQString &s ) +{ + int w = 0; + if ( !s.isNull() ) { + w = textWidthWithTabs( TQFontMetrics( font() ), s, 0, s.length(), + d->align ); + } + return w + 2 * d->lr_marg + d->marg_extra; +} + + +/* + Returns the width in pixels of the text at line \a line. +*/ + +int TQtMultiLineEdit::textWidth( int line ) +{ + if ( d->echomode == Password) { + TQString s = stringShown(line); + return textWidth( s ); + } + TQtMultiLineEditRow* r = contents->at(line); + return r?r->w:0; +} + +/* + Starts the cursor blinking. +*/ + +void TQtMultiLineEdit::focusInEvent( TQFocusEvent * ) +{ + stopAutoScroll(); + if ( !d->blinkTimer->isActive() ) + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); + cursorOn = TRUE; + updateCell( cursorY, 0, FALSE ); +} + + +/*\reimp +*/ +void TQtMultiLineEdit::leaveEvent( TQEvent * ) +{ +} + + +/*\reimp +*/ +void TQtMultiLineEdit::focusOutEvent( TQFocusEvent * ) +{ + stopAutoScroll(); + d->blinkTimer->stop(); + if ( cursorOn ) { + cursorOn = FALSE; + updateCell( cursorY, 0, FALSE ); + } +} + + +/* + \reimp + Present for binary compatibility only! +*/ + +void TQtMultiLineEdit::timerEvent( TQTimerEvent * ) +{ + // ############ Remove in 3.0!!!!!!!! +} + +#ifndef TQT_NO_DRAGANDDROP +void TQtMultiLineEdit::doDrag() +{ + if ( d->dnd_timer ) { + d->dnd_timer->stop(); + } + TQDragObject *drag_text = new TQTextDrag(markedText(), this); + if ( readOnly ) { + drag_text->dragCopy(); + } else { + if ( drag_text->drag() && TQDragObject::target() != this ) { + del(); + if ( textDirty && !d->isHandlingEvent ) + emit textChanged(); + } + } + d->dnd_primed = FALSE; +} +#endif + +/* + If there is marked text, sets \a line1, \a col1, \a line2 and \a col2 + to the start and end of the marked region and returns TRUE. Returns + FALSE if there is no marked text. + */ +bool TQtMultiLineEdit::getMarkedRegion( int *line1, int *col1, + int *line2, int *col2 ) const +{ + if ( !markIsOn || !line1 || !line2 || !col1 || !col2 ) + return FALSE; + if ( markAnchorY < markDragY || + markAnchorY == markDragY && markAnchorX < markDragX) { + *line1 = markAnchorY; + *col1 = markAnchorX; + *line2 = markDragY; + *col2 = markDragX; + if ( *line2 > numLines() - 1 ) { + *line2 = numLines() - 1; + *col2 = lineLength( *line2 ); + } + } else { + *line1 = markDragY; + *col1 = markDragX; + *line2 = markAnchorY; + *col2 = markAnchorX; + if ( *line2 > numLines() - 1 ) { + *line2 = numLines() - 1; + *col2 = lineLength( *line2 ); + } + } + return markIsOn; +} + + +/* + Returns TRUE if there is marked text. +*/ + +bool TQtMultiLineEdit::hasMarkedText() const +{ + return markIsOn; +} + + +/* + Returns a copy of the marked text. +*/ + +TQString TQtMultiLineEdit::markedText() const +{ + int markBeginX, markBeginY; + int markEndX, markEndY; + if ( !getMarkedRegion( &markBeginY, &markBeginX, &markEndY, &markEndX ) ) + return TQString(); + if ( markBeginY == markEndY ) { //just one line + TQString *s = getString( markBeginY ); + return s->mid( markBeginX, markEndX - markBeginX ); + } else { //multiline + TQString *firstS, *lastS; + firstS = getString( markBeginY ); + lastS = getString( markEndY ); + int i; + TQString tmp; + if ( firstS ) + tmp += firstS->mid(markBeginX); + if ( contents->at( markBeginY )->newline ) + tmp += '\n'; + + for( i = markBeginY + 1; i < markEndY ; i++ ) { + tmp += *getString(i); + if ( contents->at( i )->newline ) + tmp += '\n'; + } + + if ( lastS ) { + tmp += lastS->left(markEndX); + } else { + tmp.truncate(tmp.length()-1); + } + + return tmp; + } +} + + + +/* + Returns the text at line number \a line (possibly the empty string), + or a \link TQString::operator!() null string\endlink if \a line is invalid. +*/ + +TQString TQtMultiLineEdit::textLine( int line ) const +{ + TQString *s = getString(line); + if ( s ) { + if ( s->isNull() ) + return TQString::tqfromLatin1(""); + else + return *s; + } else + return TQString::null; +} + + +/* + Returns a copy of the whole text. If the multi line edit tqcontains no + text, a + \link TQString::operator!() null string\endlink + is returned. +*/ + +TQString TQtMultiLineEdit::text() const +{ + TQString tmp; + for( int i = 0 ; i < (int)contents->count() ; i++ ) { + tmp += *getString(i); + if ( i+1 < (int)contents->count() && contents->at(i)->newline ) + tmp += '\n'; + } + return tmp; +} + + +/* + Selects all text without moving the cursor. +*/ + +void TQtMultiLineEdit::selectAll() +{ + markAnchorX = 0; + markAnchorY = 0; + markDragY = numLines() - 1; + markDragX = lineLength( markDragY ); + turnMark( markDragX != markAnchorX || markDragY != markAnchorY ); + if ( autoUpdate() ) + update(); +} + + + +/* + Deselects all text (i.e. removes marking) and leaves the cursor at the + current position. +*/ + +void TQtMultiLineEdit::deselect() +{ + turnMark( FALSE ); +} + + +/* + Sets the text to \a s, removing old text, if any. +*/ + +void TQtMultiLineEdit::setText( const TQString &s ) +{ + bool oldUndo = isUndoEnabled(); + setUndoEnabled( FALSE ); + bool oldAuto = autoUpdate(); + setAutoUpdate( FALSE ); + bool b = tqsignalsBlocked(); + blockSignals( TRUE ); + clear(); + CLEAR_UNDO + blockSignals( b ); + insertLine( s, -1 ); + emit textChanged(); + setAutoUpdate(oldAuto); + if ( autoUpdate() ) + update(); + setUndoEnabled( oldUndo ); +} + + +/* + Appends \a s to the text. +*/ + +void TQtMultiLineEdit::append( const TQString &s ) +{ + bool oldUndo = isUndoEnabled(); + setUndoEnabled( FALSE ); + insertLine( s, -1 ); + setUndoEnabled( oldUndo ); + emit textChanged(); +} + +/* \reimp +Passes wheel events to the vertical scrollbar. +*/ +void TQtMultiLineEdit::wheelEvent( TQWheelEvent *e ){ + TQApplication::sendEvent( verticalScrollBar(), e); +} + + +/* + The key press event handler converts a key press in event \a e to + some line editor action. + + Here are the default key bindings when isReadOnly() is FALSE: + \list + \i <i> Left Arrow </i> Move the cursor one character leftwards + \i <i> Right Arrow </i> Move the cursor one character rightwards + \i <i> Up Arrow </i> Move the cursor one line upwards + \i <i> Down Arrow </i> Move the cursor one line downwards + \i <i> Page Up </i> Move the cursor one page upwards + \i <i> Page Down </i> Move the cursor one page downwards + \i <i> Backspace </i> Delete the character to the left of the cursor + \i <i> Home </i> Move the cursor to the beginning of the line + \i <i> End </i> Move the cursor to the end of the line + \i <i> Delete </i> Delete the character to the right of the cursor + \i <i> Shift - Left Arrow </i> Mark text one character leftwards + \i <i> Shift - Right Arrow </i> Mark text one character rightwards + \i <i> Control-A </i> Move the cursor to the beginning of the line + \i <i> Control-B </i> Move the cursor one character leftwards + \i <i> Control-C </i> Copy the marked text to the clipboard + \i <i> Control-D </i> Delete the character to the right of the cursor + \i <i> Control-E </i> Move the cursor to the end of the line + \i <i> Control-F </i> Move the cursor one character rightwards + \i <i> Control-H </i> Delete the character to the left of the cursor + \i <i> Control-K </i> Delete to end of line + \i <i> Control-N </i> Move the cursor one line downwards + \i <i> Control-P </i> Move the cursor one line upwards + \i <i> Control-V </i> Paste the clipboard text into line edit + \i <i> Control-X </i> Cut the marked text, copy to clipboard + \i <i> Control-Z </i> Undo the last operation + \i <i> Control-Y </i> Redo the last operation + \i <i> Control - Left Arrow </i> Move the cursor one word leftwards + \i <i> Control - Right Arrow </i> Move the cursor one word rightwards + \i <i> Control - Up Arrow </i> Move the cursor one word upwards + \i <i> Control - Down Arrow </i> Move the cursor one word downwards + \i <i> Control - Home Arrow </i> Move the cursor to the beginning of the text + \i <i> Control - End Arrow </i> Move the cursor to the end of the text + \endlist + In addition, the following key bindings are used on Windows: + \list + \i <i> Shift - Delete </i> Cut the marked text, copy to clipboard + \i <i> Shift - Insert </i> Paste the clipboard text into line edit + \i <i> Control - Insert </i> Copy the marked text to the clipboard + \endlist + All other keys with valid ASCII codes insert themselves into the line. + + Here are the default key bindings when isReadOnly() is TRUE: + \list + \i <i> Left Arrow </i> Scrolls the table rightwards + \i <i> Right Arrow </i> Scrolls the table rightwards + \i <i> Up Arrow </i> Scrolls the table one line downwards + \i <i> Down Arrow </i> Scrolls the table one line upwards + \i <i> Page Up </i> Scrolls the table one page downwards + \i <i> Page Down </i> Scrolls the table one page upwards + \i <i> Control-C </i> Copy the marked text to the clipboard + \endlist + +*/ + +void TQtMultiLineEdit::keyPressEvent( TQKeyEvent *e ) +{ + textDirty = FALSE; + d->isHandlingEvent = TRUE; + int unknown = 0; + if ( readOnly ) { + int pageSize = viewHeight() / cellHeight(); + + switch ( e->key() ) { + case Key_Left: + setXOffset( xOffset() - viewWidth()/10 ); + break; + case Key_Right: + setXOffset( xOffset() + viewWidth()/10 ); + break; + case Key_Up: + setTopCell( topCell() - 1 ); + break; + case Key_Down: + setTopCell( topCell() + 1 ); + break; + case Key_Home: + setCursorPosition(0,0, e->state() & ShiftButton ); + break; + case Key_End: + setCursorPosition( numLines()-1, lineLength( numLines()-1 ), + e->state() & ShiftButton ); + break; + case Key_Next: + setTopCell( topCell() + pageSize ); + break; + case Key_Prior: + setTopCell( TQMAX( topCell() - pageSize, 0 ) ); + break; +#ifndef TQT_NO_CLIPBOARD + case Key_C: + if ( echoMode() == Normal && (e->state()&ControlButton) ) + copy(); + else + unknown++; + break; + case Key_F16: // Copy key on Sun keyboards + if ( echoMode() == Normal ) + copy(); + else + unknown++; + break; +#endif + default: + unknown++; + } + if ( unknown ) + e->ignore(); + d->isHandlingEvent = FALSE; + return; + } + if ( e->text().length() && + e->key() != Key_Return && + e->key() != Key_Enter && + e->key() != Key_Delete && + e->key() != Key_Backspace && + (!e->ascii() || e->ascii()>=32) + ) { + insert( e->text() ); + //TQApplication::sendPostedEvents( this, TQEvent::Paint ); + if ( textDirty ) + emit textChanged(); + d->isHandlingEvent = FALSE; + return; + } + if ( e->state() & ControlButton ) { + switch ( e->key() ) { + case Key_A: + home( e->state() & ShiftButton ); + break; + case Key_B: + cursorLeft( e->state() & ShiftButton ); + break; +#ifndef TQT_NO_CLIPBOARD + case Key_C: + if ( echoMode() == Normal ) + copy(); + break; +#endif + case Key_D: + del(); + break; + case Key_E: + end( e->state() & ShiftButton ); + break; + case Key_Left: + cursorWordBackward( e->state() & ShiftButton ); + break; + case Key_Right: + cursorWordForward( e->state() & ShiftButton ); + break; + case Key_Up: + cursorUp( e->state() & ShiftButton ); + break; + case Key_Down: + cursorDown( e->state() & ShiftButton ); + break; + case Key_Home: + setCursorPosition(0,0, e->state() & ShiftButton ); + break; + case Key_End: + setCursorPosition( numLines()-1, lineLength( numLines()-1 ), + e->state() & ShiftButton ); + break; + case Key_F: + cursorRight( e->state() & ShiftButton ); + break; + case Key_H: + backspace(); + break; + case Key_K: + killLine(); + break; + case Key_N: + cursorDown( e->state() & ShiftButton ); + break; + case Key_P: + cursorUp( e->state() & ShiftButton ); + break; +#ifndef TQT_NO_CLIPBOARD + case Key_V: + paste(); + break; + case Key_X: + cut(); + break; +#endif + case Key_Z: + undo(); + break; + case Key_Y: + redo(); + break; +#if defined (_WS_WIN_) + case Key_Insert: + copy(); +#endif + default: + unknown++; + } + } else { + switch ( e->key() ) { + case Key_Left: + cursorLeft( e->state() & ShiftButton ); + break; + case Key_Right: + cursorRight( e->state() & ShiftButton ); + break; + case Key_Up: + cursorUp( e->state() & ShiftButton ); + break; + case Key_Down: + cursorDown( e->state() & ShiftButton ); + break; + case Key_Backspace: + backspace(); + break; + case Key_Home: + home( e->state() & ShiftButton ); + break; + case Key_End: + end( e->state() & ShiftButton ); + break; + case Key_Delete: +#if defined (_WS_WIN_) + if ( e->state() & ShiftButton ) { + cut(); + break; + } +#endif + del(); + break; + case Key_Next: + pageDown( e->state() & ShiftButton ); + break; + case Key_Prior: + pageUp( e->state() & ShiftButton ); + break; + case Key_Enter: + case Key_Return: + newLine(); + emit returnPressed(); + break; + case Key_Tab: + insert( e->text() ); + break; +#if defined (_WS_WIN_) + case Key_Insert: + if ( e->state() & ShiftButton ) + paste(); + else + unknown++; + break; +#endif + case Key_F14: // Undo key on Sun keyboards + undo(); + break; +#ifndef TQT_NO_CLIPBOARD + case Key_F16: // Copy key on Sun keyboards + if ( echoMode() == Normal ) + copy(); + break; + case Key_F18: // Paste key on Sun keyboards + paste(); + break; + case Key_F20: // Paste key on Sun keyboards + cut(); + break; +#endif + default: + unknown++; + } + } + if ( textDirty ) + emit textChanged(); + + if ( unknown ) // unknown key + e->ignore(); + + d->isHandlingEvent = FALSE; +} + + +/* + Moves the cursor one page down. If \a mark is TRUE, the text + is marked. +*/ + +void TQtMultiLineEdit::pageDown( bool mark ) +{ + bool oldAuto = autoUpdate(); + if ( mark ) + setAutoUpdate( FALSE ); + + if ( partiallyInvisible( cursorY ) ) + cursorY = topCell(); + int delta = cursorY - topCell(); + int pageSize = viewHeight() / cellHeight(); + int newTopCell = TQMIN( topCell() + pageSize, numLines() - 1 - pageSize ); + + if ( pageSize >= numLines() ) { // quick fix to handle small texts + newTopCell = topCell(); + } + if ( !curXPos ) + curXPos = mapToView( cursorX, cursorY ); + int oldY = cursorY; + + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + if ( newTopCell != topCell() ) { + cursorY = newTopCell + delta; + cursorX = mapFromView( curXPos, cursorY ); + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + setTopCell( newTopCell ); + } else if ( cursorY != (int)contents->count() - 1) { // just move the cursor + cursorY = TQMIN( cursorY + pageSize, numLines() - 1); + cursorX = mapFromView( curXPos, cursorY ); + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + makeVisible(); + } + if ( oldAuto ) + if ( mark ) { + setAutoUpdate( TRUE ); + update(); + } else { + updateCell( oldY, 0, FALSE ); + } + if ( !mark ) + turnMark( FALSE ); +} + + +/* + Moves the cursor one page up. If \a mark is TRUE, the text + is marked. +*/ + +void TQtMultiLineEdit::pageUp( bool mark ) +{ + bool oldAuto = autoUpdate(); + if ( mark ) + setAutoUpdate( FALSE ); + if ( partiallyInvisible( cursorY ) ) + cursorY = topCell(); + int delta = cursorY - topCell(); + int pageSize = viewHeight() / cellHeight(); + bool partial = delta == pageSize && viewHeight() != pageSize * cellHeight(); + int newTopCell = TQMAX( topCell() - pageSize, 0 ); + if ( pageSize > numLines() ) { // quick fix to handle small texts + newTopCell = 0; + delta = 0; + } + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + if ( !curXPos ) + curXPos = mapToView( cursorX, cursorY ); + int oldY = cursorY; + if ( newTopCell != topCell() ) { + cursorY = TQMIN( newTopCell + delta, numLines() - 1 ); + if ( partial ) + cursorY--; + cursorX = mapFromView( curXPos, cursorY ); + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + setTopCell( newTopCell ); + } else { // just move the cursor + cursorY = TQMAX( cursorY - pageSize, 0 ); + cursorX = mapFromView( curXPos, cursorY ); + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + } + if ( oldAuto ) + if ( mark ) { + setAutoUpdate( TRUE ); + update(); + } else { + updateCell( oldY, 0, FALSE ); + } + if ( !mark ) + turnMark( FALSE ); +} + +// THE CORE INSERTION FUNCTION +void TQtMultiLineEdit::insertAtAux( const TQString &txt, int line, int col, bool mark ) +{ + dummy = FALSE; + d->blinkTimer->stop(); + cursorOn = TRUE; + int oldw = contentsRect().width(); + + line = TQMAX( TQMIN( line, numLines() - 1), 0 ); + col = TQMAX( TQMIN( col, lineLength( line )), 0 ); + + TQString itxt = txt; + TQtMultiLineEditRow *row = contents->at( line ); + if ( d->maxlen >= 0 && length() + int(txt.length()) > d->maxlen ) + itxt.truncate( d->maxlen - length() ); + + row->s.insert( uint(col), itxt ); + + if ( mark ) { + markAnchorX = col; + markAnchorY = line; + } + if ( cursorX == col && cursorY == line ) { + cursorX += itxt.length(); + } + TQFontMetrics fm( font() ); + if ( !WORD_WRAP || ( col == 0 && itxt.tqcontains('\n') == int(itxt.length())) ) + wrapLine( line, 0 ); + else if ( WORD_WRAP && itxt.tqfind('\n')<0 && itxt.tqfind('\t')<0 + && ( + ( DYNAMIC_WRAP && fm.width( itxt ) + row->w < contentsRect().width() - 2*d->lr_marg - d->marg_extra ) + || + ( FIXED_WIDTH_WRAP && ( d->wrapcol < 0 || fm.width( itxt ) + row->w < d->wrapcol ) ) + || + ( FIXED_COLUMN_WRAP && ( d->wrapcol < 0 || int(row->s.length()) < d->wrapcol ) ) + ) + && ( itxt.tqfind(' ') < 0 || row->s.tqfind(' ') >= 0 && row->s.tqfind(' ') < col ) ){ + row->w = textWidth( row->s ); + setWidth( TQMAX( maxLineWidth(), row->w) ); + updateCell( line, 0, FALSE ); + } + else { + if ( line > 0 && !contents->at( line-1)->newline ) + rebreakParagraph( line-1 ); + else + rebreakParagraph( line ); + } + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + + setNumRowsAndTruncate(); + + textDirty = TRUE; + d->edited = TRUE; + if ( autoUpdate() ) { + makeVisible(); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); + if ( DYNAMIC_WRAP && oldw != contentsRect().width() ) { + setAutoUpdate( FALSE ); + rebreakAll(); + setAutoUpdate( TRUE ); + update(); + } + } +} + + +/* + Inserts \a txt at line number \a line. If \a line is less than zero, + or larger than the number of rows, the new text is put at the end. + If \a txt tqcontains newline characters, several lines are inserted. + + The cursor position is not changed. +*/ + +void TQtMultiLineEdit::insertLine( const TQString &txt, int line ) +{ + TQString s = txt; + int oldXPos = cursorX; + int oldYPos = cursorY; + if ( line < 0 || line >= int( contents->count() ) ) { + if ( !dummy ) + contents->append( new TQtMultiLineEditRow(TQString::tqfromLatin1(""), 0) ); + insertAt( s, numLines()-1, 0 ); + } else { + s.append('\n'); + insertAt( s, line, 0 ); + } + cursorX = oldXPos; + cursorY = oldYPos; +} + +/* + Deletes the line at line number \a line. If \a + line is less than zero, or larger than the number of lines, + no line is deleted. +*/ + +void TQtMultiLineEdit::removeLine( int line ) +{ + CLEAR_UNDO + if ( line >= numLines() ) + return; + if ( cursorY >= line && cursorY > 0 ) + cursorY--; + bool updt = autoUpdate() && rowIsVisible( line ); + TQtMultiLineEditRow* r = contents->at( line ); + ASSERT( r ); + bool recalc = r->w == maxLineWidth(); + contents->remove( line ); + if ( contents->count() == 0 ) { + int w = textWidth( TQString::tqfromLatin1("") ); + contents->append( new TQtMultiLineEditRow(TQString::tqfromLatin1(""), w) ); + setWidth( w ); + dummy = TRUE; + } + if ( setNumRowsAndTruncate() ) + recalc = updt = FALSE; + if ( recalc ) + updateCellWidth(); + makeVisible(); + if (updt) + update(); + textDirty = TRUE; + d->edited = TRUE; +} + +/* + Inserts \a s at the current cursor position. +*/ +void TQtMultiLineEdit::insert( const TQString& s ) +{ + insert( s, FALSE ); +} + +/* + Inserts \a c at the current cursor position. + (this function is provided for backward compatibility - + it simply calls insert()). +*/ +void TQtMultiLineEdit::insertChar( TQChar c ) +{ + insert(c); +} + +/* + \overload + Inserts string \a str at the current cursor position. If \a mark is + TRUE the string is marked. +*/ + +void TQtMultiLineEdit::insert( const TQString& str, bool mark ) +{ + dummy = FALSE; + bool wasMarkedText = hasMarkedText(); + if ( wasMarkedText ) + addUndoCmd( new TQBeginCommand ); + if ( wasMarkedText ) + del(); // ## Will flicker + TQString *s = getString( cursorY ); + if ( cursorX > (int)s->length() ) + cursorX = s->length(); + else if ( overWrite && !wasMarkedText && cursorX < (int)s->length() ) + del(); // ## Will flicker + insertAt(str, cursorY, cursorX, mark ); + makeVisible(); + + if ( wasMarkedText ) + addUndoCmd( new TQEndCommand() ); +} + +/* + Makes a line break at the current cursor position. +*/ + +void TQtMultiLineEdit::newLine() +{ + insert("\n"); +} + +/* + Deletes text from the current cursor position to the end of the line. +*/ + +void TQtMultiLineEdit::killLineAux() +{ + deselect(); // -sanders Don't let del() delete marked region + TQtMultiLineEditRow* r = contents->at( cursorY ); + if ( cursorX == (int)r->s.length() ) { + // if (r->newline) // -sanders Only del newlines! + del(); + return; + } else { + bool recalc = r->w == maxLineWidth(); + r->s.remove( cursorX, r->s.length() ); + r->w = textWidth( r->s ); + updateCell( cursorY, 0, FALSE ); + if ( recalc ) + updateCellWidth(); + rebreakParagraph( cursorY ); // -sanders + textDirty = TRUE; + d->edited = TRUE; + } + curXPos = 0; + makeVisible(); + turnMark( FALSE ); +} + + +/* + Moves the cursor one character to the left. If \a mark is TRUE, the text + is marked. If \a wrap is TRUE, the cursor moves to the end of the + previous line if it is placed at the beginning of the current line. + + \sa cursorRight() cursorUp() cursorDown() +*/ + +void TQtMultiLineEdit::cursorLeft( bool mark, bool wrap ) +{ + cursorLeft(mark,!mark,wrap); +} +void TQtMultiLineEdit::cursorLeft( bool mark, bool clear_mark, bool wrap ) +{ + if ( cursorX != 0 || cursorY != 0 && wrap ) { + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + d->blinkTimer->stop(); + int ll = lineLength( cursorY ); + if ( cursorX > ll ) + cursorX = ll; + cursorOn = TRUE; + cursorX--; + if ( cursorX < 0 ) { + int oldY = cursorY; + if ( cursorY > 0 ) { + cursorY--; + cursorX = lineLength( cursorY ); + if ( cursorX > 1 && !isEndOfParagraph( cursorY ) ) + cursorX--; + } else { + cursorY = 0; //### ? + cursorX = 0; + } + updateCell( oldY, 0, FALSE ); + } + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); + updateCell( cursorY, 0, FALSE ); + } + curXPos = 0; + makeVisible(); + if ( clear_mark ) + turnMark( FALSE ); +} + +/* + Moves the cursor one character to the right. If \a mark is TRUE, the text + is marked. If \a wrap is TRUE, the cursor moves to the beginning of the next + line if it is placed at the end of the current line. + \sa cursorLeft() cursorUp() cursorDown() +*/ + +void TQtMultiLineEdit::cursorRight( bool mark, bool wrap ) +{ + cursorRight(mark,!mark,wrap); +} +void TQtMultiLineEdit::cursorRight( bool mark, bool clear_mark, bool wrap ) +{ + int strl = lineLength( cursorY ); + if ( strl > 1 && !isEndOfParagraph( cursorY ) ) + strl--; + if ( cursorX < strl || cursorY < (int)contents->count() - 1 && wrap ) { + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + d->blinkTimer->stop(); + cursorOn = TRUE; + cursorX++; + if ( cursorX > strl ) { + int oldY = cursorY; + if ( cursorY < (int) contents->count() - 1 ) { + cursorY++; + cursorX = 0; + } else { + cursorX = lineLength( cursorY ); + } + updateCell( oldY, 0, FALSE ); + } + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + updateCell( cursorY, 0, FALSE ); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); + } + curXPos = 0; + makeVisible(); + if ( clear_mark ) + turnMark( FALSE ); +} + +/* + Moves the cursor up one line. If \a mark is TRUE, the text + is marked. + \sa cursorDown() cursorLeft() cursorRight() +*/ + +void TQtMultiLineEdit::cursorUp( bool mark ) +{ + cursorUp(mark,!mark); +} +void TQtMultiLineEdit::cursorUp( bool mark, bool clear_mark ) +{ + if ( cursorY != 0 ) { + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + if ( !curXPos ) + curXPos = mapToView( cursorX, cursorY ); + int oldY = cursorY; + d->blinkTimer->stop(); + cursorOn = TRUE; + cursorY--; + if ( cursorY < 0 ) { + cursorY = 0; + } + cursorX = mapFromView( curXPos, cursorY ); + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + updateCell( oldY, 0, FALSE ); + updateCell( cursorY, 0, FALSE ); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); + } + makeVisible(); + if ( clear_mark ) + turnMark( FALSE ); +} + +/* + Moves the cursor one line down. If \a mark is TRUE, the text + is marked. + \sa cursorUp() cursorLeft() cursorRight() +*/ + +void TQtMultiLineEdit::cursorDown( bool mark ) +{ + cursorDown(mark,!mark); +} +void TQtMultiLineEdit::cursorDown( bool mark, bool clear_mark ) +{ + int lastLin = contents->count() - 1; + if ( cursorY != lastLin ) { + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + if ( !curXPos ) + curXPos = mapToView( cursorX, cursorY ); + int oldY = cursorY; + d->blinkTimer->stop(); + cursorOn = TRUE; + cursorY++; + if ( cursorY > lastLin ) { + cursorY = lastLin; + } + cursorX = mapFromView( curXPos, cursorY ); + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + updateCell( oldY, 0, FALSE ); + updateCell( cursorY, 0, FALSE ); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); + } + makeVisible(); + if ( clear_mark ) + turnMark( FALSE ); +} + +/* + Turns off marked text +*/ +void TQtMultiLineEdit::turnMark( bool on ) +{ + if ( on != markIsOn ) { + markIsOn = on; + if ( echoMode() == Normal ) + emit copyAvailable( on ); + update(); + } +} + + + + +/* + Deletes the character on the left side of the text cursor and moves + the cursor one position to the left. If a text has been marked by + the user (e.g. by clicking and dragging) the cursor is put at the + beginning of the marked text and the marked text is removed. + \sa del() +*/ + +void TQtMultiLineEdit::backspace() +{ + if ( hasMarkedText() ) { + del(); + } else { + if ( !atBeginning() ) { + cursorLeft( FALSE ); + del(); + } + } + makeVisible(); +} + +void TQtMultiLineEdit::delAux() +{ + int markBeginX, markBeginY; + int markEndX, markEndY; + TQRect oldContents = contentsRect(); + if ( getMarkedRegion( &markBeginY, &markBeginX, &markEndY, &markEndX ) ) { + turnMark( FALSE ); + textDirty = TRUE; + d->edited = TRUE; + if ( markBeginY == markEndY ) { //just one line + TQtMultiLineEditRow *r = contents->at( markBeginY ); + ASSERT(r); + bool recalc = r->w == maxLineWidth(); + r->s.remove( markBeginX, markEndX - markBeginX ); + r->w = textWidth( r->s ); + cursorX = markBeginX; + cursorY = markBeginY; + + if (autoUpdate() ) + updateCell( cursorY, 0, FALSE ); + if ( recalc ) + updateCellWidth(); + } else { //multiline + bool oldAuto = autoUpdate(); + setAutoUpdate( FALSE ); + ASSERT( markBeginY >= 0); + ASSERT( markEndY < (int)contents->count() ); + + TQtMultiLineEditRow *firstR, *lastR; + firstR = contents->at( markBeginY ); + lastR = contents->at( markEndY ); + ASSERT( firstR != lastR ); + firstR->s.remove( markBeginX, firstR->s.length() - markBeginX ); + lastR->s.remove( 0, markEndX ); + firstR->s.append( lastR->s ); // lastS will be removed in loop below + firstR->newline = lastR->newline; // Don't forget this -sanders + firstR->w = textWidth( firstR->s ); + + for( int i = markBeginY + 1 ; i <= markEndY ; i++ ) + contents->remove( markBeginY + 1 ); + + if ( contents->isEmpty() ) + insertLine( TQString::tqfromLatin1(""), -1 ); + + cursorX = markBeginX; + cursorY = markBeginY; + curXPos = 0; + + setNumRowsAndTruncate(); + updateCellWidth(); + setAutoUpdate( oldAuto ); + if ( autoUpdate() ) + update(); + } + markAnchorY = markDragY = cursorY; + markAnchorX = markDragX = cursorX; + } else { + if ( !atEnd() ) { + textDirty = TRUE; + d->edited = TRUE; + TQtMultiLineEditRow *r = contents->at( cursorY ); + if ( cursorX == (int) r->s.length() ) { // remove newline + TQtMultiLineEditRow* other = contents->at( cursorY + 1 ); + if ( ! r->newline && cursorX ) + r->s.truncate( r->s.length()-1 ); + + bool needBreak = !r->s.isEmpty(); + r->s += other->s; + r->newline = other->newline; + contents->remove( cursorY + 1 ); + if ( needBreak ) + rebreakParagraph( cursorY, 1 ); + else + wrapLine( cursorY, 1 ); + } else { + bool recalc = r->w == maxLineWidth(); + r->s.remove( cursorX, 1 ); + rebreakParagraph( cursorY ); + if ( recalc ) + updateCellWidth(); + } + } + } + if ( DYNAMIC_WRAP && oldContents != contentsRect() ) { + if ( oldContents.width() != contentsRect().width() ) { + bool oldAuto = autoUpdate(); + setAutoUpdate( FALSE ); + rebreakAll(); + setAutoUpdate( oldAuto ); + } + if ( autoUpdate() ) + update(); + } + curXPos = 0; + makeVisible(); +} + +/* + Moves the text cursor to the left end of the line. If \a mark is + TRUE, text is marked towards the first position. If it is FALSE and + the cursor is moved, all marked text is unmarked. + + \sa end() +*/ + +void TQtMultiLineEdit::home( bool mark ) +{ + if ( cursorX != 0 ) { + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + d->blinkTimer->stop(); + cursorX = 0; + cursorOn = TRUE; + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + updateCell( cursorY, 0, FALSE ); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); + } + curXPos = 0; + if ( !mark ) + turnMark( FALSE ); + makeVisible(); +} + +/* + Moves the text cursor to the right end of the line. If \a mark is TRUE + text is marked towards the last position. If it is FALSE and the + cursor is moved, all marked text is unmarked. + + \sa home() +*/ + +void TQtMultiLineEdit::end( bool mark ) +{ + int tlen = lineLength( cursorY ); + if ( cursorX != tlen ) { + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + d->blinkTimer->stop(); + cursorX = tlen; + cursorOn = TRUE; + if ( mark ) + newMark( cursorX, cursorY, FALSE ); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); + updateCell( cursorY, 0, FALSE ); + } + curXPos = 0; + makeVisible(); + if ( !mark ) + turnMark( FALSE ); +} + +/*\reimp +*/ +void TQtMultiLineEdit::mousePressEvent( TQMouseEvent *e ) +{ + stopAutoScroll(); + d->dnd_startpos = e->pos(); + + if ( e->button() == RightButton ) { + TQPopupMenu *popup = new TQPopupMenu( this ); + int id[ (int)IdCount ]; + id[ IdUndo ] = popup->insertItem( tr( "Undo" ) ); + id[ IdRedo ] = popup->insertItem( tr( "Redo" ) ); + popup->insertSeparator(); +#ifndef TQT_NO_CLIPBOARD + id[ IdCut ] = popup->insertItem( tr( "Cut" ) ); + id[ IdCopy ] = popup->insertItem( tr( "Copy" ) ); + id[ IdPaste ] = popup->insertItem( tr( "Paste" ) ); +#ifndef TQT_NO_MIMECLIPBOARD + id[ IdPasteSpecial ] = popup->insertItem( tr( "Paste special..." ) ); +#endif +#endif + id[ IdClear ] = popup->insertItem( tr( "Clear" ) ); + popup->insertSeparator(); + id[ IdSelectAll ] = popup->insertItem( tr( "Select All" ) ); + popup->setItemEnabled( id[ IdUndo ], + !this->d->undoList.isEmpty() ); + popup->setItemEnabled( id[ IdRedo ], + !this->d->redoList.isEmpty() ); +#ifndef TQT_NO_CLIPBOARD + popup->setItemEnabled( id[ IdCut ], + !isReadOnly() && hasMarkedText() ); + popup->setItemEnabled( id[ IdCopy ], hasMarkedText() ); + popup->setItemEnabled( id[ IdPaste ], + !isReadOnly() && (bool)TQApplication::clipboard()->text().length() ); +#ifndef TQT_NO_MIMECLIPBOARD + // Any non-plain types? + TQMimeSource* ms = TQApplication::clipboard()->data(); + bool ps = FALSE; + if ( ms ) { + if ( !isReadOnly() ) { + const char* fmt; + for (int i=0; !ps && (fmt=ms->format(i)); i++) { + ps = qstrnicmp(fmt,"text/",5)==0 + && qstrnicmp(fmt+5,"plain",5)!=0; + } + } + } + popup->setItemEnabled( id[ IdPasteSpecial ], ps ); +#endif +#endif + popup->setItemEnabled( id[ IdClear ], + !isReadOnly() && (bool)text().length() ); + int allSelected = markIsOn && markAnchorX == 0 && markAnchorY == 0 && + markDragY == numLines() - 1 && markDragX == lineLength( markDragY ); + popup->setItemEnabled( id[ IdSelectAll ], + (bool)text().length() && !allSelected ); + + int r = popup->exec( e->globalPos() ); + delete popup; + + if ( r == id[ IdUndo ] ) + undo(); + else if ( r == id[ IdRedo ] ) + redo(); +#ifndef TQT_NO_CLIPBOARD + else if ( r == id[ IdCut ] ) + cut(); + else if ( r == id[ IdCopy ] ) + copy(); + else if ( r == id[ IdPaste ] ) + paste(); +# ifndef TQT_NO_MIMECLIPBOARD + else if ( r == id[ IdPasteSpecial ] ) + pasteSpecial(TQCursor::pos()); +# endif +#endif + else if ( r == id[ IdClear ] ) + clear(); + else if ( r == id[ IdSelectAll ] ) + selectAll(); + return; + } + + if ( e->button() != MidButton && e->button() != LeftButton) + return; + + int newX, newY; + pixelPosToCursorPos( e->pos(), &newX, &newY ); + + if ( e->state() & ShiftButton ) { + wordMark = FALSE; + dragMarking = TRUE; + setCursorPosition( newY, newX, TRUE); + return; + } + +#ifndef TQT_NO_DRAGANDDROP + if ( + inMark(newX, newY) // Click on highlighted text + && echoMode() == Normal // No DnD of passwords, etc. + && e->pos().y() < totalHeight() // Click past the end is not dragging + ) + { + // The user might be trying to drag + d->dnd_primed = TRUE; + d->dnd_timer->start( TQApplication::startDragTime(), FALSE ); + } else +#endif + { + wordMark = FALSE; + dragMarking = TRUE; + setCursorPixelPosition(e->pos()); + } +} + +void TQtMultiLineEdit::pixelPosToCursorPos(TQPoint p, int* x, int* y) const +{ + *y = tqfindRow( p.y() ); + if ( *y < 0 ) { + if ( p.y() < lineWidth() ) { + *y = topCell(); + } else { + *y = lastRowVisible(); + p.setX(cellWidth()); + } + } + *y = TQMIN( (int)contents->count() - 1, *y ); + TQFontMetrics fm( font() ); + *x = xPosToCursorPos( stringShown( *y ), fm, + p.x() - d->lr_marg + xOffset(), + cellWidth() - 2 * d->lr_marg - d->marg_extra, + d->align ); + TQtMultiLineEditRow* r = contents->at( *y ); + if (r && !r->newline && ((unsigned int)*x == r->s.length()) && (*x > 0)) + --*x; +} + +void TQtMultiLineEdit::setCursorPixelPosition(TQPoint p, bool clear_mark) +{ + int newY; + pixelPosToCursorPos( p, &cursorX, &newY ); + curXPos = 0; + if ( clear_mark ) { + markAnchorX = cursorX; + markAnchorY = newY; + bool markWasOn = markIsOn; + turnMark( FALSE ); + if ( markWasOn ) { + cursorY = newY; + update(); + d->isHandlingEvent = FALSE; + return; + } + } + if ( cursorY != newY ) { + int oldY = cursorY; + cursorY = newY; + updateCell( oldY, 0, FALSE ); + } + updateCell( cursorY, 0, FALSE ); // ### +} + +void TQtMultiLineEdit::startAutoScroll() +{ + if ( !dragScrolling ) { + d->scrollTime = initialScrollTime; + d->scrollAccel = initialScrollAccel; + d->scrollTimer->start( d->scrollTime, FALSE ); + dragScrolling = TRUE; + } +} + +void TQtMultiLineEdit::stopAutoScroll() +{ + if ( dragScrolling ) { + d->scrollTimer->stop(); + dragScrolling = FALSE; + } +} + +/*\reimp +*/ +void TQtMultiLineEdit::mouseMoveEvent( TQMouseEvent *e ) +{ +#ifndef TQT_NO_DRAGANDDROP + d->dnd_timer->stop(); + if ( d->dnd_primed && + ( d->dnd_startpos - e->pos() ).manhattanLength() > TQApplication::startDragDistance() ) { + doDrag(); + return; + } +#endif + if ( !dragMarking ) + return; + if ( rect().tqcontains( e->pos() ) ) { + stopAutoScroll(); + } else if ( !dragScrolling ) { + startAutoScroll(); + } + + int newX, newY; + pixelPosToCursorPos(e->pos(), &newX, &newY); + + if ( wordMark ) { + extendSelectionWord( newX, newY); + } + + if ( markDragX == newX && markDragY == newY ) + return; + int oldY = markDragY; + newMark( newX, newY, FALSE ); + for ( int i = TQMIN(oldY,newY); i <= TQMAX(oldY,newY); i++ ) + updateCell( i, 0, FALSE ); +} + +void TQtMultiLineEdit::extendSelectionWord( int &newX, int&newY) +{ + TQString s = stringShown( newY ); + int lim = s.length(); + if ( newX >= 0 && newX < lim ) { + int i = newX; + int startclass = charClass(s.at(i)); + if ( markAnchorY < markDragY || + ( markAnchorY == markDragY && markAnchorX < markDragX ) ) { + // going right + while ( i < lim && charClass(s.at(i)) == startclass ) + i++; + } else { + // going left + while ( i >= 0 && charClass(s.at(i)) == startclass ) + i--; + i++; + } + newX = i; + } +} + + + + +/*\reimp +*/ +void TQtMultiLineEdit::mouseReleaseEvent( TQMouseEvent *e ) +{ + stopAutoScroll(); +#ifndef TQT_NO_DRAGANDDROP + if ( d->dnd_timer->isActive() ) { + d->dnd_timer->stop(); + d->dnd_primed = FALSE; + setCursorPixelPosition(e->pos()); + } +#endif + wordMark = FALSE; + dragMarking = FALSE; + textDirty = FALSE; + d->isHandlingEvent = TRUE; + if ( markAnchorY == markDragY && markAnchorX == markDragX ) + turnMark( FALSE ); + +#ifndef TQT_NO_CLIPBOARD +#if defined(_WS_X11_) + else if ( echoMode() == Normal ) + copy(); +#endif + + if ( e->button() == MidButton && !readOnly ) { +#if defined(_WS_X11_) + paste(); // Will tqrepaint the cursor line. +#else +#ifndef TQT_NO_COMPAT + if ( style().tqstyleHint(TQStyle::SH_GUIStyle) == TQt::MotifStyle ) + paste(); +#endif +#endif + } +#endif + + d->isHandlingEvent = FALSE; + + if ( !readOnly && textDirty ) + emit textChanged(); +} + + +/*\reimp +*/ +void TQtMultiLineEdit::mouseDoubleClickEvent( TQMouseEvent *m ) +{ + if ( m->button() == LeftButton ) { + if ( m->state() & ShiftButton ) { + int newX = cursorX; + int newY = cursorY; + extendSelectionWord( newX, newY); + newMark( newX, newY, FALSE ); + } else { + markWord( cursorX, cursorY ); + } + dragMarking = TRUE; + wordMark = TRUE; + updateCell( cursorY, 0, FALSE ); + + } +} + +#ifndef TQT_NO_DRAGANDDROP + +/* + \reimp +*/ + +void TQtMultiLineEdit::dragEnterEvent( TQDragEnterEvent * ) +{ + cursorOn = TRUE; + updateCell( cursorY, 0, FALSE ); +} + +/*\reimp +*/ +void TQtMultiLineEdit::dragMoveEvent( TQDragMoveEvent* event ) +{ + if ( readOnly ) return; + event->accept( TQTextDrag::canDecode(event) ); + d->dnd_forcecursor = TRUE; + setCursorPixelPosition(event->pos(), FALSE); + d->dnd_forcecursor = FALSE; + TQRect inside_margin(scroll_margin, scroll_margin, + width()-scroll_margin*2, height()-scroll_margin*2); + if ( !inside_margin.tqcontains(event->pos()) ) { + startAutoScroll(); + } + if ( event->source() == this && event->action() == TQDropEvent::Move ) + event->acceptAction(); +} + +/*\reimp +*/ +void TQtMultiLineEdit::dragLeaveEvent( TQDragLeaveEvent* ) +{ + if ( cursorOn ) { + cursorOn = FALSE; + updateCell( cursorY, 0, FALSE ); + } + stopAutoScroll(); +} + +/*\reimp +*/ +void TQtMultiLineEdit::dropEvent( TQDropEvent* event ) +{ + if ( readOnly ) return; + TQString text; + TQCString fmt = pickSpecial(event,FALSE,event->pos()); + if ( TQTextDrag::decode(event, text, fmt) ) { + int i = -1; + while ( ( i = text.tqfind( '\r' ) ) != -1 ) + text.tqreplace( i,1,"" ); + if ( event->source() == this && event->action() == TQDropEvent::Move ) { + event->acceptAction(); + // Careful not to tread on my own feet + int newX, newY; + pixelPosToCursorPos( event->pos(), &newX, &newY ); + if ( afterMark( newX, newY ) ) { + // The tricky case + int x1, y1, x2, y2; + getMarkedRegion( &y1, &x1, &y2, &x2 ); + if ( newY == y2 ) { + newY = y1; + newX = x1 + newX - x2; + } else { + newY -= y2 - y1; + } + addUndoCmd( new TQBeginCommand ); + del(); + setCursorPosition(newY, newX); + insert(text, TRUE); + addUndoCmd( new TQEndCommand ); + } else if ( beforeMark( newX, newY ) ) { + // Easy + addUndoCmd( new TQBeginCommand ); + del(); + setCursorPosition(newY, newX); + insert(text, TRUE); + addUndoCmd( new TQEndCommand ); + } else { + // Do nothing. + } + } else { + setCursorPixelPosition(event->pos()); + insert(text, TRUE); + } + update(); + emit textChanged(); + } +} + +#endif // TQT_NO_DRAGANDDROP + + +/* + Returns TRUE if line \a line is invisible or partially invisible. +*/ + +bool TQtMultiLineEdit::partiallyInvisible( int line ) +{ + int y; + if ( !rowYPos( line, &y ) ) + return TRUE; + if ( y < 0 ) + return TRUE; + else if ( y + cellHeight() - 2 > viewHeight() ) + return TRUE; + + return FALSE; +} + +/* + Scrolls such that the cursor is visible +*/ + +void TQtMultiLineEdit::makeVisible() +{ + if ( !autoUpdate() ) + return; + + if ( partiallyInvisible( cursorY ) ) { + if ( cursorY >= lastRowVisible() ) + setBottomCell( cursorY ); + else + setTopCell( cursorY ); + } + int xPos = mapToView( cursorX, cursorY ); + if ( xPos < xOffset() ) { + int of = xPos - 10; //### + setXOffset( of ); + } else if ( xPos > xOffset() + viewWidth() ) { + int of = xPos - viewWidth() + 10; //### + setXOffset( of ); + } +} + +/* + Computes the character position in line \a line which corresponds + to pixel \a xPos +*/ + +int TQtMultiLineEdit::mapFromView( int xPos, int line ) +{ + TQString s = stringShown( line ); + if ( !s ) + return 0; + TQFontMetrics fm( font() ); + int index = xPosToCursorPos( s, fm, + xPos - d->lr_marg, + cellWidth() - 2 * d->lr_marg - d->marg_extra, + d->align ); + TQtMultiLineEditRow* r = contents->at( line ); + if (r && !r->newline && ((unsigned int)index == r->s.length()) && (index > 0)) + --index; + return index; +} + +/* + Computes the pixel position in line \a line which corresponds to + character position \a xIndex +*/ + +int TQtMultiLineEdit::mapToView( int xIndex, int line ) +{ + TQString s = stringShown( line ); + xIndex = TQMIN( (int)s.length(), xIndex ); + TQFontMetrics fm( font() ); + int wcell = cellWidth() - 2 * d->lr_marg;// - d->marg_extra; + int wrow = contents->at( line )->w; + int w = textWidthWithTabs( fm, s, 0, xIndex, d->align ) - 1; + if ( d->align == TQt::AlignCenter || d->align == TQt::AlignHCenter ) + w += (wcell - wrow) / 2; + else if ( d->align == TQt::AlignRight ) + w += wcell - wrow; + return d->lr_marg + w; +} + +/* + Traverses the list and tqfinds an item with the maximum width, and + updates the internal list box structures accordingly. +*/ + +void TQtMultiLineEdit::updateCellWidth() +{ + TQtMultiLineEditRow* r = contents->first(); + int maxW = 0; + int w; + switch ( d->echomode ) { + case Normal: + while ( r ) { + w = r->w; + if ( w > maxW ) + maxW = w; + r = contents->next(); + } + break; + case Password: { + uint l = 0; + while ( r ) { + l = TQMAX(l, r->s.length() ); + r = contents->next(); + } + TQString t; + t.fill(TQChar('*'), l); + maxW = textWidth(t); + } + break; + case NoEcho: + maxW = textWidth(TQString::tqfromLatin1("")); + } + setWidth( maxW ); +} + + +/* + Sets the bottommost visible line to \a line. +*/ + +void TQtMultiLineEdit::setBottomCell( int line ) +{ + int rowY = cellHeight() * line; + int newYPos = rowY + cellHeight() - viewHeight(); + setYOffset( TQMAX( newYPos, 0 ) ); +} + +#ifndef TQT_NO_CLIPBOARD + +/* + Copies text in MIME subtype \a subtype from the clipboard onto the current + cursor position. + Any marked text is first deleted. +*/ +void TQtMultiLineEdit::pasteSubType(const TQCString& subtype) +{ + TQCString st = subtype; + addUndoCmd( new TQBeginCommand ); + + if ( hasMarkedText() ) + del(); + TQString t = TQApplication::clipboard()->text(st); + if ( !t.isEmpty() ) { + if ( hasMarkedText() ) + turnMark( FALSE ); + +#if defined(_OS_WIN32_) + // Need to convert CRLF to NL + t.tqreplace( "\r\n", "\n" ); +#endif + + for (int i=0; (uint)i<t.length(); i++) { + if ( t[i] < ' ' && t[i] != '\n' && t[i] != '\t' ) + t[i] = ' '; + } + insertAt( t, cursorY, cursorX ); + turnMark( FALSE ); + curXPos = 0; + makeVisible(); + } + if ( textDirty && !d->isHandlingEvent ) + emit textChanged(); + + addUndoCmd( new TQEndCommand ); +} + +/* + Copies plain text from the clipboard onto the current cursor position. + Any marked text is first deleted. +*/ +void TQtMultiLineEdit::paste() +{ + pasteSubType("plain"); +} + +#ifndef TQT_NO_MIMECLIPBOARD +/* + Prompts the user for a type from a list of text types available, + Then copies text from the clipboard onto the current cursor position. + Any marked text is first deleted. +*/ +void TQtMultiLineEdit::pasteSpecial(const TQPoint& pt) +{ + TQCString st = pickSpecial(TQApplication::clipboard()->data(),TRUE,pt); + if ( !st.isEmpty() ) + pasteSubType(st); +} +#endif +#ifndef TQT_NO_MIME +TQCString TQtMultiLineEdit::pickSpecial(TQMimeSource* ms, bool always_ask, const TQPoint& pt) +{ + if ( ms ) { + TQPopupMenu popup(this); + TQString fmt; + int n=0; + TQDict<void> done; + for (int i=0; !(fmt=ms->format(i)).isNull(); i++) { + int semi=fmt.tqfind(";"); + if ( semi >= 0 ) + fmt = fmt.left(semi); + if ( fmt.left(5) == "text/" ) { + fmt = fmt.mid(5); + if ( !done.tqfind(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(); + } + } + return TQCString(); +} +#endif // TQT_NO_MIME +#endif // TQT_NO_CLIPBOARD + + +/* + Removes all text. +*/ + +void TQtMultiLineEdit::clear() +{ + addUndoCmd( new TQDelTextCmd( 0, text() ) ); + setEdited( TRUE ); + contents->clear(); + cursorX = cursorY = 0; + int w = textWidth( TQString::tqfromLatin1("") ); + contents->append( new TQtMultiLineEditRow(TQString::tqfromLatin1(""), w) ); + setNumRowsAndTruncate(); + setWidth( w ); + dummy = TRUE; + turnMark( FALSE ); + if ( autoUpdate() ) + update(); + if ( !d->isHandlingEvent ) //# && not already empty + emit textChanged(); + update(); +} + + +/*\reimp +*/ + +void TQtMultiLineEdit::setFont( const TQFont &font ) +{ + TQWidget::setFont( font ); + d->clearChartable(); + TQFontMetrics fm( font ); + setCellHeight( fm.lineSpacing() ); + for ( TQtMultiLineEditRow* r = contents->first(); r; r = contents->next() ) + r->w = textWidth( r->s ); + rebreakAll(); + updateCellWidth(); +} + +/* + Sets a new marked text limit, does not tqrepaint the widget. +*/ + +void TQtMultiLineEdit::newMark( int posx, int posy, bool /*copy*/ ) +{ + if ( markIsOn && markDragX == posx && markDragY == posy && + cursorX == posx && cursorY == posy ) + return; + markDragX = posx; + markDragY = posy; + cursorX = posx; + cursorY = posy; + turnMark( markDragX != markAnchorX || markDragY != markAnchorY ); +} + +bool TQtMultiLineEdit::beforeMark( int posx, int posy ) const +{ + int x1, y1, x2, y2; + if ( !getMarkedRegion( &y1, &x1, &y2, &x2 ) ) + return FALSE; + return + (y1 > posy || y1 == posy && x1 > posx) + && (y2 > posy || y2 == posy && x2 > posx); +} + +bool TQtMultiLineEdit::afterMark( int posx, int posy ) const +{ + int x1, y1, x2, y2; + if ( !getMarkedRegion( &y1, &x1, &y2, &x2 ) ) + return FALSE; + return + (y1 < posy || y1 == posy && x1 < posx) + && (y2 < posy || y2 == posy && x2 < posx); +} + +bool TQtMultiLineEdit::inMark( int posx, int posy ) const +{ + int x1, y1, x2, y2; + if ( !getMarkedRegion( &y1, &x1, &y2, &x2 ) ) + return FALSE; + return + (y1 < posy || y1 == posy && x1 <= posx) + && (y2 > posy || y2 == posy && x2 >= posx); +} + +/* + Marks the word at character position \a posx, \a posy. + */ +void TQtMultiLineEdit::markWord( int posx, int posy ) +{ + TQString& s = contents->at( posy )->s; + + int i = posx - 1; + while ( i >= 0 && s[i].isPrint() && !s[i].isSpace() ) + i--; + i++; + markAnchorY = posy; + markAnchorX = i; + + while ( s[i].isPrint() && !s[i].isSpace() ) + i++; + markDragX = i; + markDragY = posy; + turnMark( markDragX != markAnchorX || markDragY != markAnchorY ); + +#ifndef TQT_NO_CLIPBOARD +#if defined(_WS_X11_) + if ( echoMode() == Normal ) + copy(); +#endif +#endif +} + +/* + This may become a protected virtual member in a future TQt. + This implementation is an example of a useful classification + that aids selection of common units like filenames and URLs. +*/ +int TQtMultiLineEdit::charClass( TQChar ch ) +{ + if ( !ch.isPrint() || ch.isSpace() ) return 1; + else if ( ch.isLetter() || ch=='-' || ch=='+' || ch==':' + || ch=='.' || ch=='/' || ch=='\\' + || ch=='@' || ch=='$' || ch=='~' ) return 2; + else return 3; +} + +#ifndef TQT_NO_CLIPBOARD +/* + Copies the marked text to the clipboard. Will copy only + if echoMode() is Normal. +*/ + +void TQtMultiLineEdit::copy() const +{ + TQString t = markedText(); + if ( !t.isEmpty() && echoMode() == Normal ) { +#if defined(_WS_X11_) + disconnect( TQApplication::clipboard(), TQT_SIGNAL(dataChanged()), this, 0); +#endif +#if defined(_OS_WIN32_) + // Need to convert NL to CRLF + t.tqreplace( "\n", "\r\n" ); +#endif + TQApplication::clipboard()->setText( t ); +#if defined(_WS_X11_) + connect( TQApplication::clipboard(), TQT_SIGNAL(dataChanged()), + this, TQT_SLOT(clipboardChanged()) ); +#endif + } +} + +/* \obsolete + + Backward compatibility. +*/ +void TQtMultiLineEdit::copyText() const +{ + copy(); +} + +/* + Copies the selected text to the clipboard and deletes the selected text. +*/ + +void TQtMultiLineEdit::cut() +{ + if ( hasMarkedText() ) { + if ( echoMode() == Normal ) + copy(); + del(); + if ( textDirty && !d->isHandlingEvent ) + emit textChanged(); + } +} + +#endif + +/* + This private slot is activated when this line edit owns the clipboard and + some other widget/application takes over the clipboard. (X11 only) +*/ + +void TQtMultiLineEdit::clipboardChanged() +{ +#if defined(_WS_X11_) + disconnect( TQApplication::clipboard(), TQT_SIGNAL(dataChanged()), + this, TQT_SLOT(clipboardChanged()) ); + turnMark( FALSE ); + update(); +#endif +} + + +/* + Sets maxLineWidth() and maybe cellWidth() to \a w without updating the entire widget. + */ + +void TQtMultiLineEdit::setWidth( int w ) +{ + if ( w ==d->maxLineWidth ) + return; + bool u = autoUpdate(); + setAutoUpdate( FALSE ); + d->maxLineWidth = w; + if ( d->align == AlignLeft ) + setCellWidth( w ); + else + setCellWidth( TQMAX( w, contentsRect().width() ) ); + setAutoUpdate( u ); + if ( autoUpdate() && d->align != AlignLeft ) + update(); +} + + +/* + Sets the cursor position to character number \a col in line number \a line. + The parameters are adjusted to lie within the legal range. + + If \a mark is FALSE, the selection is cleared. otherwise it is extended + + \sa cursorPosition() +*/ + +void TQtMultiLineEdit::setCursorPosition( int line, int col, bool mark ) +{ + if ( mark && !hasMarkedText() ) { + markAnchorX = cursorX; + markAnchorY = cursorY; + } + int oldY = cursorY; + cursorY = TQMAX( TQMIN( line, numLines() - 1), 0 ); + cursorX = TQMAX( TQMIN( col, lineLength( cursorY )), 0 ); + curXPos = 0; + makeVisible(); + if ( mark ) { + newMark( cursorX, cursorY, FALSE ); + for ( int i = TQMIN(oldY,cursorY); i <= TQMAX(oldY,cursorY); i++ ) + updateCell( i, 0, FALSE ); + } else { + updateCell( oldY, 0, FALSE ); + turnMark( FALSE ); + } +} + + + +/* \obsolete + + Use getCursorPosition() instead. +*/ + +void TQtMultiLineEdit::cursorPosition( int *line, int *col ) const +{ + getCursorPosition(line,col); +} + + +/* + Returns the current line and character + position within that line, in the variables pointed to + by \a line and \a col respectively. + + \sa setCursorPosition() +*/ + +void TQtMultiLineEdit::getCursorPosition( int *line, int *col ) const +{ + if ( line ) + *line = cursorY; + if ( col ) + *col = cursorX; +} + + +/* + \sa setAutoUpdate() +*/ + +bool TQtMultiLineEdit::autoUpdate() const +{ + return TQtTableView::autoUpdate(); +} + + +/* + Sets the auto-update option of multi-line editor to \a enable. + +*/ + +void TQtMultiLineEdit::setAutoUpdate( bool enable ) +{ + TQtTableView::setAutoUpdate( enable ); +} + +/* + Sets the fixed height of the TQtMultiLineEdit so that \a lines text lines + are visible given the current font. + + \sa setMaxLines(), setFixedHeight() + */ +void TQtMultiLineEdit::setFixedVisibleLines( int lines ) +{ + int ls = fontMetrics().lineSpacing(); + setFixedHeight( frameWidth()*2 + ls*lines ); + return; +} + + + +/* + Returns the top center point where the cursor is drawn +*/ + +TQPoint TQtMultiLineEdit::cursorPoint() const +{ + TQPoint cp( 0, 0 ); + + TQFontMetrics fm( font() ); + int col, row; + col = row = 0; + cursorPosition( &row, &col ); + TQString line = textLine( row ); + ASSERT( line ); + cp.setX( d->lr_marg + textWidthWithTabs( fm, line, 0, col, d->align ) - 1 ); + cp.setY( (row * cellHeight()) + viewRect().y() ); + return cp; +} + + +/* \reimp +*/ +TQSizePolicy TQtMultiLineEdit::sizePolicy() const +{ + //### removeme 3.0 + return TQWidget::sizePolicy(); +} + + +/*\reimp +*/ +TQSize TQtMultiLineEdit::tqsizeHint() const +{ + constPolish(); + int expected_lines; + if ( d->maxlines >= 0 && d->maxlines <= 6 ) { + expected_lines = d->maxlines; + } else { + expected_lines = 6; + } + TQFontMetrics fm( font() ); + int h = fm.lineSpacing()*(expected_lines-1)+fm.height() + frameWidth()*2; + int w = fm.width('x')*35; + + int maxh = tqmaximumSize().height(); + if ( maxh < TQWIDGETSIZE_MAX ) + h = maxh; + + return TQSize( w, h ).expandedTo( TQApplication::globalStrut() ); +} + + +/* + Returns a size sufficient for one character, and scroll bars. +*/ + +TQSize TQtMultiLineEdit::tqminimumSizeHint() const +{ + constPolish(); + TQFontMetrics fm( font() ); + int h = fm.lineSpacing() + frameWidth()*2; + int w = fm.maxWidth(); + h += frameWidth(); + w += frameWidth(); + if ( testTableFlags(Tbl_hScrollBar|Tbl_autoHScrollBar) ) + w += verticalScrollBar()->tqsizeHint().width(); + if ( testTableFlags(Tbl_vScrollBar|Tbl_autoVScrollBar) ) + h += horizontalScrollBar()->tqsizeHint().height(); + return TQSize(w,h); +} + + + +/*\reimp +*/ + +void TQtMultiLineEdit::resizeEvent( TQResizeEvent *e ) +{ + int oldw = contentsRect().width(); + TQtTableView::resizeEvent( e ); + if ( DYNAMIC_WRAP + && (e->oldSize().width() != width() + || oldw != contentsRect().width() ) ) { + bool oldAuto = autoUpdate(); + setAutoUpdate( FALSE ); + rebreakAll(); + if ( oldw != contentsRect().width() ) + rebreakAll(); + setAutoUpdate( oldAuto ); + if ( autoUpdate() ) + tqrepaint( FALSE ); + } else if ( d->align != AlignLeft ) { + d->maxLineWidth = 0; // trigger update + updateCellWidth(); + } + if ( isVisible() ) + deselect(); +} + +/* + Sets the tqalignment to \a flags. Possible values are \c AlignLeft, \c + Align(H)Center and \c AlignRight. + + \sa tqalignment(), TQt::AlignmentFlags +*/ +void TQtMultiLineEdit::tqsetAlignment( int flags ) +{ + if ( d->align != flags ) { + d->align = flags; + update(); + } +} + +/* + Returns the tqalignment. + +*/ +int TQtMultiLineEdit::tqalignment() const +{ + return d->align; +} + + +/* + Not supported at this time. + \a v is the validator to set. +*/ +void TQtMultiLineEdit::setValidator( const TQValidator *v ) +{ + d->val = v; + // #### validate text now +} + +/* + Not supported at this time. +*/ +const TQValidator * TQtMultiLineEdit::validator() const +{ + return d->val; +} + +/* \sa edited() +*/ +void TQtMultiLineEdit::setEdited( bool e ) +{ + d->edited = e; +} + +/* \sa setEdited() +*/ +bool TQtMultiLineEdit::edited() const +{ + return d->edited; +} + +/* \enum TQtMultiLineEdit::EchoMode + + This enum type describes the ways in which TQLineEdit can display its + contents. The currently defined values are: \list + + \i Normal - display characters as they are entered. This is + the default. + + \i NoEcho - do not display anything. + + \i Password - display asterisks instead of the characters + actually entered. + + \endlist + + \sa setEchoMode() echoMode() TQLineEdit::EchoMode +*/ + + +/* + Sets the echo mode to \a em. The default is \c Normal. + + The display is updated according. + + \sa setEchoMode() +*/ +void TQtMultiLineEdit::setEchoMode( EchoMode em ) +{ + if ( d->echomode != em ) { + d->echomode = em; + updateCellWidth(); + update(); + } +} + +/* + Returns the currently set echo mode. + + \sa setEchoMode() +*/ +TQtMultiLineEdit::EchoMode TQtMultiLineEdit::echoMode() const +{ + return d->echomode; +} + + +/* + Returns the string shown at line \a row, including + processing of the echoMode(). +*/ + +TQString TQtMultiLineEdit::stringShown(int row) const +{ + TQString* s = getString(row); + if ( !s ) return TQString::null; + switch ( d->echomode ) { + case Normal: + if (!*s) return TQString::tqfromLatin1(""); + return *s; + case Password: + { + TQString r; + r.fill(TQChar('*'), (int)s->length()); + if ( !r ) r = TQString::tqfromLatin1(""); + return r; + } + case NoEcho: + return TQString::tqfromLatin1(""); + } + return TQString::tqfromLatin1(""); +} + +/* + + \sa maxLength() +*/ +void TQtMultiLineEdit::setMaxLength(int m) +{ + d->maxlen = m; +} + +/* + \sa setMaxLength() +*/ +int TQtMultiLineEdit::maxLength() const +{ + return d->maxlen; +} + + +/* + Returns the length of the current text. + + \sa setMaxLength() + */ +int TQtMultiLineEdit::length() const +{ + int l = 0; + for ( TQtMultiLineEditRow* r = contents->first(); r; r = contents->next() ) { + l += r->s.length(); + if ( r->newline ) + ++l; + } + return l-1; +} + + +/* + Sets the maximum length of lines to \a m. Use -1 for unlimited + (the default). Existing long lines will be truncated. + + \sa maxLineLength() +*/ +void TQtMultiLineEdit::setMaxLineLength(int m) +{ + bool trunc = d->maxlinelen < 0 || m < d->maxlinelen; + d->maxlinelen = m; + if ( trunc ) { + TQtMultiLineEditRow* r = contents->first(); + while ( r ) { + r->s.truncate( m ); + r = contents->next(); + } + if ( cursorX > m ) cursorX = m; + if ( markAnchorX > m ) markAnchorX = m; + if ( markDragX > m ) markDragX = m; + update(); + updateCellWidth(); + } +} + +/* + Returns the currently set line length limit, or -1 if there is + no limit (this is the default). + + \sa setMaxLineLength() +*/ +int TQtMultiLineEdit::maxLineLength() const +{ + return d->maxlinelen; +} + +/* + Sets the maximum number of lines to \a m. Use -1 for unlimited + (the default). Existing excess lines will be deleted. + + \sa maxLines(), numLines() +*/ +void TQtMultiLineEdit::setMaxLines(int m) +{ + if ( m == 0 ) // bad value + m = -1; + d->maxlines = m; + if ( d->maxlines >= 0 && d->maxlines <= 6 ) { + tqsetSizePolicy( TQSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Fixed ) ); + } else { + tqsetSizePolicy( TQSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Expanding ) ); + } + if ( setNumRowsAndTruncate() ) { + updateCellWidth(); + update(); + } +} + +/* + \sa setMaxLines() +*/ +int TQtMultiLineEdit::maxLines() const +{ + return d->maxlines; +} + +/* + Sets the horizontal margin to \a m. + + \sa hMargin() +*/ +void TQtMultiLineEdit::setHMargin(int m) +{ + if ( m != d->lr_marg ) { + d->lr_marg = m; + updateCellWidth(); + update(); + } +} + +/* + + \sa setHMargin() +*/ +int TQtMultiLineEdit::hMargin() const +{ + return d->lr_marg; +} + +/* + Marks the text starting at \a row_from, \a col_from and ending + at \a row_to, \a col_to. +*/ +void TQtMultiLineEdit::setSelection( int row_from, int col_from, + int row_to, int col_to ) +{ + setCursorPosition( row_from, col_from, FALSE ); + setCursorPosition( row_to, col_to, TRUE ); +} + + +/* + Moves the cursor one word to the right. If \a mark is TRUE, the text + is marked. + \sa cursorWordBackward() +*/ +void TQtMultiLineEdit::cursorWordForward( bool mark ) +{ + int x = cursorX; + int y = cursorY; + + if ( x == lineLength( y ) || textLine(y).at(x).isSpace() ) { + while ( x < lineLength( y ) && textLine(y).at(x).isSpace() ) + ++x; + if ( x == lineLength( y ) ) { + if ( y < (int)contents->count() - 1) { + ++y; + x = 0; + while ( x < lineLength( y ) && textLine(y).at(x).isSpace() ) + ++x; + } + } + } + else { + while ( x < lineLength( y ) && !textLine(y).at(x).isSpace() ) + ++x; + int xspace = x; + while ( xspace < lineLength( y ) && textLine(y).at(xspace).isSpace() ) + ++xspace; + if ( xspace < lineLength( y ) ) + x = xspace; + } + cursorOn = TRUE; + int oldY = cursorY; + setCursorPosition( y, x, mark ); + if ( oldY != cursorY ) + updateCell( oldY, 0, FALSE ); + updateCell( cursorY, 0, FALSE ); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); +} + +/* + Moves the cursor one word to the left. If \a mark is TRUE, the text + is marked. + \sa cursorWordForward() +*/ +void TQtMultiLineEdit::cursorWordBackward( bool mark ) +{ + int x = cursorX; + int y = cursorY; + + while ( x > 0 && textLine(y).at(x-1).isSpace() ) + --x; + + if ( x == 0 ) { + if ( y > 0 ) { + --y; + x = lineLength( y ); + while ( x > 0 && textLine(y).at(x-1).isSpace() ) + --x; + } + } + else { + while ( x > 0 && !textLine(y).at(x-1).isSpace() ) + --x; + } + cursorOn = TRUE; + int oldY = cursorY; + setCursorPosition( y, x, mark ); + if ( oldY != cursorY ) + updateCell( oldY, 0, FALSE ); + updateCell( cursorY, 0, FALSE ); + d->blinkTimer->start( TQApplication::cursorFlashTime() / 2, FALSE ); +} + +#define DO_BREAK {doBreak = TRUE; if ( lastSpace > a ) { \ +i = lastSpace; \ +linew = lastw; \ +} \ +else \ +i = TQMAX( a, i-1 );} + +void TQtMultiLineEdit::wrapLine( int line, int removed ) +{ + TQtMultiLineEditRow* r = contents->at( line ); + int yPos; + (void) rowYPos( line, &yPos ); + TQFontMetrics fm( font() ); + int i = 0; + TQString s = r->s; + int a = 0; + int l = line; + int w = 0; + int nlines = 0; + int lastSpace = -1; + bool doBreak = FALSE; + int linew = 0; + int lastw = 0; + int tabDist = -1; // lazy eval + while ( i < int(s.length()) ) { + doBreak = FALSE; + if ( s[i] == '\t' && d->align == TQt::AlignLeft ) { + if ( tabDist<0 ) + tabDist = tabStopDist(fm); + linew = ( linew/tabDist + 1 ) * tabDist; + } else if ( s[i] != '\n' ) { + char c = s[i].latin1(); + if ( c > 0 ) { + if ( !d->chartable[c] ) + d->chartable[c] = fm.width( s[i] ); + linew += d->chartable[c]; + } else { + linew += fm.width( s[i] ); + } + } + if ( WORD_WRAP && + lastSpace >= a && s[i] != '\n' ) { + if ( DYNAMIC_WRAP ) { + if (linew >= contentsRect().width() - 2*d->lr_marg - d->marg_extra) { + DO_BREAK + } + } else if ( FIXED_COLUMN_WRAP ) { + if ( d->wrapcol >= 0 && i-a >= d->wrapcol ) { + DO_BREAK + } + } else if ( FIXED_WIDTH_WRAP ) { + if ( d->wrapcol >= 0 && linew > d->wrapcol - d->marg_extra ) { + DO_BREAK + } + } + } + if ( s[i] == '\n' || doBreak ) { + r->s = s.mid( a, i - a + (doBreak?1:0) ); + r->w = linew - fm.leftBearing(r->s[0]) + 2 * d->lr_marg + d->marg_extra; + if ( r->w > w ) + w = r->w; + if ( cursorY > l ) + ++cursorY; + else if ( cursorY == line && cursorX >=a && cursorX <= i + (doBreak?1:0)) { + cursorY = l; + cursorX -= a; + } + if ( markAnchorY > l ) + ++markAnchorY; + else if ( markAnchorY == line && markAnchorX >=a && markAnchorX <= i + (doBreak?1:0)) { + markAnchorY = l; + markAnchorX -= a; + } + a = i + 1; + lastSpace = a; + linew = 0; + bool oldnewline = r->newline; + r->newline = !doBreak; + r = new TQtMultiLineEditRow( TQString::null, 0, oldnewline ); + ++nlines; + contents->insert( l + 1, r ); + ++l; + } + if ( s[i].isSpace() || BREAK_WITHIN_WORDS ) { + lastSpace = i; + lastw = linew; + } + if ( lastSpace <= a ) + lastw = linew; + + ++i; + } + if ( a < int(s.length()) ){ + r->s = s.mid( a, i - a ); + r->w = linew - fm.leftBearing( r->s[0] ) + 2 * d->lr_marg + d->marg_extra; + } + if ( cursorY == line && cursorX >= a ) { + cursorY = l; + cursorX -= a; + } + if ( markAnchorY == line && markAnchorX >= a ) { + markAnchorY = l; + markAnchorX -= a; + } + if ( r->w > w ) + w = r->w; + + setWidth( TQMAX( maxLineWidth(), w ) ); + bool oldAuto = autoUpdate(); + setAutoUpdate( FALSE ); + (void)setNumRowsAndTruncate(); + setAutoUpdate( oldAuto ); + + yPos += (nlines+1) * cellHeight(); + int sh = (nlines-removed) * cellHeight(); + if ( autoUpdate() ) { + if ( sh && yPos >= contentsRect().top() && yPos < contentsRect().bottom() ) { + int h = contentsRect().bottom() - yPos + 1; + if ( d->maxlines >= 0 ) { + int maxy; + if ( rowYPos( d->maxlines-1, &maxy ) ) { + maxy += cellHeight(); + if ( maxy < contentsRect().bottom() && maxy > yPos ) + h = maxy - yPos + 1; + } + } + TQWidget::scroll( 0, sh, TQRect( contentsRect().left(), yPos, + contentsRect().width(), + h ) ); + } + for (int ul = 0; ul <= nlines; ++ul ) + updateCell( line + ul, 0, FALSE ); + } +} + +void TQtMultiLineEdit::rebreakParagraph( int line, int removed ) +{ + TQtMultiLineEditRow* r = contents->at( line ); + if ( WORD_WRAP ) { + TQtMultiLineEditRow* other = 0; + while (line < int(contents->count())-1 && !r->newline ) { + other = contents->at( line + 1 ); + if ( cursorY > line ) { + --cursorY; + if ( cursorY == line ) { + cursorX += r->s.length(); + } + } + if ( markAnchorY > line ) { + --markAnchorY; + if ( markAnchorY == line ) { + markAnchorX += r->s.length(); + } + } + r->s.append( other->s ); + r->newline = other->newline; + contents->remove( line + 1 ); + ++removed; + } + } + wrapLine( line, removed ); +} + +void TQtMultiLineEdit::rebreakAll() +{ + if ( !WORD_WRAP ) + return; + d->maxLineWidth = 0; + for (int i = 0; i < int(contents->count()); ++i ) { + if ( contents->at( i )->newline && + contents->at( i )->w < contentsRect().width() - 2*d->lr_marg - d->marg_extra ) { + setWidth( TQMAX( d->maxLineWidth, contents->at( i )->w ) ); + continue; + } + rebreakParagraph( i ); + while ( i < int(contents->count() ) + && !contents->at( i )->newline ) + ++i; + } +} + + +/* \enum TQtMultiLineEdit::WordWrap + + This enum describes the multiline edit's word wrap mode. + + The following values are valid: + \list + \i NoWrap - no word wrap at all. + \i WidgetWidth - word wrap depending on the current + width of the editor widget + \i FixedPixelWidth - wrap according to a fix amount + of pixels ( see wrapColumnOrWidth() ) + \i FixedColumnWidth - wrap according to a fix character + column. This is useful whenever you need formatted text that + can also be displayed gracefully on tqdevices with monospaced + fonts, for example a standard VT100 terminal. In that case + wrapColumnOrWidth() should typically be set to 80. + \endlist + + \sa setWordWrap() +*/ + +/* + Sets the word wrap mode to \a mode. + + */ +void TQtMultiLineEdit::setWordWrap( WordWrap mode ) +{ + if ( mode == d->wordwrap ) + return; + d->wordwrap = mode; + + if ( BREAK_WITHIN_WORDS ) { + d->arrow = TQPixmap( (const char **)arrow_xpm ); + d->marg_extra = 8; + if ( DYNAMIC_WRAP ) + clearTableFlags( Tbl_autoHScrollBar ); + else + setTableFlags( Tbl_autoHScrollBar ); + } else { + d->marg_extra = 0; + setTableFlags( Tbl_autoHScrollBar ); + } + if ( !text().isEmpty() ) + setText( text() ); +} + +/* + Returns the current word wrap mode. + + \sa setWordWrap() + */ +TQtMultiLineEdit::WordWrap TQtMultiLineEdit::wordWrap() const +{ + return d->wordwrap; +} + +/* + Sets the wrap column or wrap width to \a value, depending on the + word wrap mode. + + \sa setWordWrap() + */ +void TQtMultiLineEdit::setWrapColumnOrWidth( int value ) +{ + if ( value == d->wrapcol ) + return; + d->wrapcol = value; + if ( wordWrap() != NoWrap ) + setText( text() ); +} + +/* + */ +int TQtMultiLineEdit::wrapColumnOrWidth() const +{ + return d->wrapcol; +} + + +/* \enum TQtMultiLineEdit::WrapPolicy + + Defines where text can be wrapped in word wrap mode. + + The following values are valid: + \list + \i AtWhiteSpace - break only after whitespace + \i Anywhere - break anywhere + \endlist + + \sa setWrapPolicy() +*/ + +/* + Sets the wrap \a policy, i.e. where text can be wrapped in word wrap + mode. + + \sa setWordWrap(), wrapPolicy() + */ +void TQtMultiLineEdit::setWrapPolicy( WrapPolicy policy ) +{ + if ( d->wrappolicy == policy ) + return; + d->wrappolicy = policy; + WordWrap m = d->wordwrap; + if ( m != NoWrap ) { // trigger update + d->wordwrap = NoWrap; + setWordWrap( m ); + } +} + +/* + + Returns the current word wrap policy. + + \sa setWrapPolicy() + */ +TQtMultiLineEdit::WrapPolicy TQtMultiLineEdit::wrapPolicy() const +{ + return d->wrappolicy; +} + +/* + Returns wether \a row is the last row in a paragraph. + + This function is only interesting in word wrap mode, otherwise its + return value is always TRUE. + + \sa setWordWrap() + */ +bool TQtMultiLineEdit::isEndOfParagraph( int row ) const +{ + return contents->at( row )->newline; +} + +int TQtMultiLineEdit::positionToOffsetInternal( int row, int col ) const +{ + row = TQMAX( TQMIN( row, numLines() - 1), 0 ); // Sanity check + col = TQMAX( TQMIN( col, lineLength( row )), 0 ); // Sanity check + if ( row == 0 ) + return TQMIN( col, lineLength( 0 )); + else { + int lastI; + lastI = lineLength( row ); + int i, tmp = 0; + + for( i = 0; i < row ; i++ ) { + tmp += lineLength( i ); + if ( contents->at( i )->newline ) + ++tmp; + } + + tmp += TQMIN( lastI, col ); + + return tmp; + } + +} + +// if position is <0 = returns row 0, col 0, if position >= amount of text +// returns pointer to end of text. +void TQtMultiLineEdit::offsetToPositionInternal( int position, + int *row, int *col ) const +{ + if (position <= 0) { + *row = 0; + *col = 0; + return; + } + else { + int charsLeft = position; + int i; + + for( i = 0; contents->at( i ); ++i ) { + if (lineLength( i ) < charsLeft) + charsLeft -= lineLength( i ); + else { + *row = i; + *col = charsLeft; + return; + } + if ( contents->at( i )->newline ) + --charsLeft; + } + + if (contents->at( i - 1) && !contents->at( i - 1 )->newline) { + *row = i - 1; + *col = lineLength( i - 1 ); + } + else { + *row = i; + *col = 0; + } + return; + } +} + + +/* + Processes an undo/redo command \a cmd, depending on \a undo. + */ +void TQtMultiLineEdit::processCmd( TQtMultiLineEditCommand* cmd, bool undo) +{ + TQDelTextCmd* delcmd = (TQDelTextCmd*) cmd; + bool ins = TRUE; + if (cmd->type() == TQtMultiLineEditCommand::Delete ) + ins = undo; + else if (cmd->type() == TQtMultiLineEditCommand::Insert ) + ins = !undo; + else + return; + + if ( ins ) { + int row, col; + offsetToPositionInternal( delcmd->mOffset, &row, &col ); + setCursorPosition( row, col, FALSE ); + insertAt( delcmd->mStr, row, col, FALSE ); + offsetToPositionInternal( delcmd->mOffset+delcmd->mStr.length(), &row, &col ); + setCursorPosition( row, col, FALSE ); + } else { // del + int row, col, rowEnd, colEnd; + offsetToPositionInternal( delcmd->mOffset, &row, &col ); + offsetToPositionInternal( delcmd->mOffset + delcmd->mStr.length(), &rowEnd, &colEnd ); + markAnchorY = row; + markAnchorX = col; + setCursorPosition( rowEnd, colEnd, FALSE ); + markDragY = rowEnd; + markDragX = colEnd; + turnMark( TRUE ); + del(); + } +} + +/* + Undoes the last text operation. + */ +void TQtMultiLineEdit::undo() +{ + if ( d->undoList.isEmpty() || isReadOnly() ) + return; + textDirty = FALSE; + int macroLevel = 0; + bool before = d->undo; + d->undo = FALSE; + do { + TQtMultiLineEditCommand *command = d->undoList.take(); + if ( !command ) + break; + processCmd( command, TRUE ); + macroLevel += command->terminator(); + if ( d->undoList.isEmpty() ) + emit undoAvailable( FALSE ); + addRedoCmd( command ); + } while (macroLevel != 0); + d->undo = before; + if ( textDirty ) + emit textChanged(); + textDirty = FALSE; +} + +/* + Redoes the last text operation. + */ +void TQtMultiLineEdit::redo() +{ + if ( d->redoList.isEmpty() || isReadOnly() ) + return; + textDirty = FALSE; + int macroLevel = 0; + bool before = d->undo; + d->undo = FALSE; + do { + TQtMultiLineEditCommand *command = d->redoList.take(); + if ( !command ) + break; + processCmd( command, FALSE ); + macroLevel += command->terminator(); + if ( d->redoList.isEmpty() ) + emit redoAvailable( FALSE ); + if ( d->undoList.isEmpty() ) + emit undoAvailable(TRUE); + d->undoList.append( command ); + } while (macroLevel != 0); + d->undo = before; + if ( textDirty ) + emit textChanged(); + textDirty = FALSE; +} + +/* + Inserts \a s at line number \a line, after character number \a col + in the line. + If \a s tqcontains newline characters, new lines are inserted. + If \a mark is TRUE the inserted text is selected. + + The cursor position is adjusted. If the insertion position is equal to + the cursor position, the cursor is placed after the end of the new text. + + */ + +void TQtMultiLineEdit::insertAt( const TQString &s, int line, int col, bool mark ) +{ + if ( d->undo ) { + d->undo = FALSE; + TQString itxt = s; + int offset = positionToOffsetInternal( line, col ); + if ( d->maxlen >= 0 && length() + int(s.length()) > d->maxlen ) + itxt.truncate( d->maxlen - length() ); + addUndoCmd( new TQInsTextCmd( offset, itxt ) ); + insertAtAux( s, line, col, mark ); // may perform del op + d->undo = TRUE; + } + else + insertAtAux( s, line, col, mark ); // may perform del op +} + +void TQtMultiLineEdit::deleteNextChar( int offset, int row, int col ) +{ + int row2, col2; + setCursorPosition( row, col, FALSE ); + offsetToPositionInternal( offset + 1, &row2, &col2 ); + setCursorPosition( row2, col2, TRUE ); + + TQString str = markedText(); + addUndoCmd( new TQDelTextCmd( offset, str ) ); + + setCursorPosition( row, col, FALSE ); +} + +/* + Deletes text from the current cursor position to the end of the line. +*/ + +void TQtMultiLineEdit::killLine() +{ + if ( d->undo ) { + d->undo = FALSE; + int curY, curX; + cursorPosition( &curY, &curX ); + int offset = positionToOffsetInternal( curY, curX ); + TQtMultiLineEditRow* r = contents->at( curY ); + deselect(); + + addUndoCmd( new TQBeginCommand ); + if (curX == (int)r->s.length()) { + if ( ! atEnd() && r->newline ) + deleteNextChar( offset, curY, curX ); + } + else { + TQString str = r->s.mid( curX, r->s.length() ); + addUndoCmd( new TQDelTextCmd( offset, str ) ); + } + + addUndoCmd( new TQEndCommand ); + killLineAux(); + d->undo = TRUE; + } + else + killLineAux(); +} + +/* + Deletes the character on the right side of the text cursor. If a + text has been marked by the user (e.g. by clicking and dragging) the + cursor is put at the beginning of the marked text and the marked + text is removed. \sa backspace() +*/ + +void TQtMultiLineEdit::del() +{ + if (d->undo ) { + d->undo = FALSE; + bool oldAuto = autoUpdate(); + setAutoUpdate( FALSE ); + int markBeginX, markBeginY; + int markEndX, markEndY; + + if ( getMarkedRegion( &markBeginY, &markBeginX, &markEndY, &markEndX ) ) { + addUndoCmd( new TQBeginCommand ); + int offset = positionToOffsetInternal( markBeginY, markBeginX ); + TQString str = markedText(); + d->undoList.append( new TQDelTextCmd( offset, str ) ); + addUndoCmd( new TQEndCommand ); + } + else if ( ! atEnd() ) { + int crsorY, crsorX; + cursorPosition( &crsorY, &crsorX ); + int offset = positionToOffsetInternal( crsorY, crsorX ); + TQtMultiLineEditRow* r = contents->at( crsorY ); + if (r) { + if (crsorX != (int)r->s.length()) + deleteNextChar( offset, crsorY, crsorX ); + else if (r->newline) + deleteNextChar( offset, crsorY, crsorX ); + // else noop + } + } + setAutoUpdate( oldAuto ); + delAux(); + d->undo = TRUE; + } + else + delAux(); +} + +/* + Sets undo enabled to \a enable. + + \sa isUndoEnabled() +*/ +void TQtMultiLineEdit::setUndoEnabled( bool enable ) +{ + if ( d->undo == enable ) + return; + d->undo = enable; + if ( !enable ) { + CLEAR_UNDO + } +} + + +/* + Returns whether the multilineedit is currently undo enabled or not. + + \sa setUndoEnabled() + */ +bool TQtMultiLineEdit::isUndoEnabled() const +{ + return d->undo; +} + + +/* + Sets the maximum number of operations that can be stored on the undo + stack to \a depth. + + \sa undoDepth() + */ +void TQtMultiLineEdit::setUndoDepth( int depth ) +{ + d->undodepth = depth; +} + + +/* + */ +int TQtMultiLineEdit::undoDepth() const +{ + return d->undodepth; +} + +void TQtMultiLineEdit::blinkTimerTimeout() +{ + cursorOn = !cursorOn; + updateCell( cursorY, 0, FALSE ); +} + +void TQtMultiLineEdit::scrollTimerTimeout() +{ + TQPoint p = mapFromGlobal( TQCursor::pos() ); + if ( d->scrollAccel-- <= 0 && d->scrollTime ) { + d->scrollAccel = initialScrollAccel; + d->scrollTime--; + d->scrollTimer->stop(); + d->scrollTimer->start( d->scrollTime ); + } + int l = TQMAX(1,(initialScrollTime-d->scrollTime)/5); + + // auto scrolling is dual-use - for highlighting and DND + int margin = d->dnd_primed ? scroll_margin : 0; + bool mark = !d->dnd_primed; + bool clear_mark = d->dnd_primed ? FALSE : !mark; + + for (int i=0; i<l; i++) { + if ( p.y() < margin ) { + cursorUp( mark, clear_mark ); + } else if ( p.y() > height()-margin ) { + cursorDown( mark, clear_mark ); + } else if ( p.x() < margin ) { + cursorLeft( mark, clear_mark, FALSE ); + } else if ( p.x() > width()-margin ) { + cursorRight( mark, clear_mark, FALSE ); + } else { + stopAutoScroll(); + break; + } + } +} + +void TQtMultiLineEdit::dndTimeout() +{ +#ifndef TQT_NO_DRAGANDDROP + doDrag(); +#endif +} + +int TQtMultiLineEdit::setNumRowsAndTruncate() +{ + int n = contents->count(); + int r = 0; + while ( d->maxlines >= 0 && n > d->maxlines ) { + // truncate + contents->at(n-2)->newline = TRUE; + contents->removeLast(); + if ( markAnchorY == n-1 ) + markAnchorY--; + if ( markDragY == n-1 ) + markDragY--; + if ( cursorY == n-1 ) { + cursorY--; + cursorX = contents->at(cursorY)->s.length(); + } + n--; + r++; + } + setNumRows( n ); + return r; +} + +/* \reimp +*/ +bool TQtMultiLineEdit::event( TQEvent * e ) +{ + if ( e->type() == TQEvent::AccelOverride && !isReadOnly() ) { + TQKeyEvent* ke = (TQKeyEvent*) e; + if ( ke->state() & ControlButton ) { + switch ( ke->key() ) { + case Key_A: + case Key_E: +#if defined (_WS_WIN_) + case Key_Insert: +#endif + case Key_X: + case Key_V: + case Key_C: + case Key_Left: + case Key_Right: + case Key_Up: + case Key_Down: + case Key_Home: + case Key_End: + ke->accept(); + default: + break; + } + } else { + switch ( ke->key() ) { + case Key_Delete: + case Key_Home: + case Key_End: + case Key_Backspace: + ke->accept(); + default: + break; + } + } + } + return TQWidget::event( e ); +} + +/* \reimp +*/ + +bool TQtMultiLineEdit::focusNextPrevChild( bool ) +{ + return FALSE; +} + +#endif |