octave-lyh: gui/src/terminal/TerminalDisplay.cpp comparison

comparison gui/src/terminal/TerminalDisplay.cpp @ 13506:c70511cf64ee

Reformatted to GNU Style.

author	Jacob Dawid <jacob.dawid@googlemail.com>
date	Sun, 17 Jul 2011 22:59:28 +0200
parents	86d6c3b90ad7
children	7eb8cd35454c

comparison

equal deleted inserted replaced

-:3a26a0ad2df9
+:c70511cf64ee
 const ColorEntry base_color_table[TABLE_COLORS] =
 // The following are almost IBM standard color codes, with some slight
 // gamma correction for the dim colors to compensate for bright X screens.
 // It contains the 8 ansiterm/xterm colors in 2 intensities.
 {
 // Fixme: could add faint colors here, also.
 // normal
-ColorEntry(QColor(0x00,0x00,0x00), 0), ColorEntry( QColor(0xB2,0xB2,0xB2), 1), // Dfore, Dback
+ColorEntry (QColor (0x00, 0x00, 0x00), 0), ColorEntry (QColor (0xB2, 0xB2, 0xB2), 1),	// Dfore, Dback
-ColorEntry(QColor(0x00,0x00,0x00), 0), ColorEntry( QColor(0xB2,0x18,0x18), 0), // Black, Red
+ColorEntry (QColor (0x00, 0x00, 0x00), 0), ColorEntry (QColor (0xB2, 0x18, 0x18), 0),	// Black, Red
-ColorEntry(QColor(0x18,0xB2,0x18), 0), ColorEntry( QColor(0xB2,0x68,0x18), 0), // Green, Yellow
+ColorEntry (QColor (0x18, 0xB2, 0x18), 0), ColorEntry (QColor (0xB2, 0x68, 0x18), 0),	// Green, Yellow
-ColorEntry(QColor(0x18,0x18,0xB2), 0), ColorEntry( QColor(0xB2,0x18,0xB2), 0), // Blue, Magenta
+ColorEntry (QColor (0x18, 0x18, 0xB2), 0), ColorEntry (QColor (0xB2, 0x18, 0xB2), 0),	// Blue, Magenta
-ColorEntry(QColor(0x18,0xB2,0xB2), 0), ColorEntry( QColor(0xB2,0xB2,0xB2), 0), // Cyan, White
+ColorEntry (QColor (0x18, 0xB2, 0xB2), 0), ColorEntry (QColor (0xB2, 0xB2, 0xB2), 0),	// Cyan, White
 // intensiv
-ColorEntry(QColor(0x00,0x00,0x00), 0), ColorEntry( QColor(0xFF,0xFF,0xFF), 1),
+ColorEntry (QColor (0x00, 0x00, 0x00), 0),
-ColorEntry(QColor(0x68,0x68,0x68), 0), ColorEntry( QColor(0xFF,0x54,0x54), 0),
+ColorEntry (QColor (0xFF, 0xFF, 0xFF), 1),
-ColorEntry(QColor(0x54,0xFF,0x54), 0), ColorEntry( QColor(0xFF,0xFF,0x54), 0),
+ColorEntry (QColor (0x68, 0x68, 0x68), 0),
-ColorEntry(QColor(0x54,0x54,0xFF), 0), ColorEntry( QColor(0xFF,0x54,0xFF), 0),
+ColorEntry (QColor (0xFF, 0x54, 0x54), 0),
-ColorEntry(QColor(0x54,0xFF,0xFF), 0), ColorEntry( QColor(0xFF,0xFF,0xFF), 0)
+ColorEntry (QColor (0x54, 0xFF, 0x54), 0),
+ColorEntry (QColor (0xFF, 0xFF, 0x54), 0),
+ColorEntry (QColor (0x54, 0x54, 0xFF), 0),
+ColorEntry (QColor (0xFF, 0x54, 0xFF), 0),
+ColorEntry (QColor (0x54, 0xFF, 0xFF), 0),
+ColorEntry (QColor (0xFF, 0xFF, 0xFF), 0)
 };
 // scroll increment used when dragging selection at top/bottom of window.
 // static
-bool TerminalDisplay::_antialiasText = true;
+bool
-bool TerminalDisplay::HAVE_TRANSPARENCY = false;
+TerminalDisplay::_antialiasText = true;
+bool
+TerminalDisplay::HAVE_TRANSPARENCY = false;
 // we use this to force QPainter to display text in LTR mode
 // more information can be found in: http://unicode.org/reports/tr9/
-const QChar LTR_OVERRIDE_CHAR( 0x202D );
+const QChar
+LTR_OVERRIDE_CHAR (0x202D);
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Colors                                     */
 /*                                                                           */
 ----------- ------- ------- ------- ------- ------- ------- ------- -------
 ANSI  (bgr) Black   Red     Green   Yellow  Blue    Magenta Cyan    White
 IBMPC (rgb) Black   Blue    Green   Cyan    Red     Magenta Yellow  White
 */
-ScreenWindow* TerminalDisplay::screenWindow() const
+ScreenWindow *
-{
+TerminalDisplay::screenWindow () const
-return _screenWindow;
+{
-}
+return _screenWindow;
-void TerminalDisplay::setScreenWindow(ScreenWindow* window)
+}
-{
-// disconnect existing screen window if any
+void
-if ( _screenWindow )
+TerminalDisplay::setScreenWindow (ScreenWindow * window)
 {
-disconnect( _screenWindow , 0 , this , 0 );
+// disconnect existing screen window if any
-}
+if (_screenWindow)
+{
-_screenWindow = window;
+disconnect (_screenWindow, 0, this, 0);
+}
-if ( window )
-{
+_screenWindow = window;
-// TODO: Determine if this is an issue.
+if (window)
-//#warning "The order here is not specified - does it matter whether updateImage or updateLineProperties comes first?"
+{
-connect( _screenWindow , SIGNAL(outputChanged()) , this , SLOT(updateLineProperties()) );
-connect( _screenWindow , SIGNAL(outputChanged()) , this , SLOT(updateImage()) );
+// TODO: Determine if this is an issue.
-window->setWindowLines(_lines);
+//#warning "The order here is not specified - does it matter whether updateImage or updateLineProperties comes first?"
-}
+connect (_screenWindow, SIGNAL (outputChanged ()), this,
-}
+	       SLOT (updateLineProperties ()));
+connect (_screenWindow, SIGNAL (outputChanged ()), this,
-const ColorEntry* TerminalDisplay::colorTable() const
+	       SLOT (updateImage ()));
-{
+window->setWindowLines (_lines);
-return _colorTable;
+}
 }
-void TerminalDisplay::setBackgroundColor(const QColor& color)
-{
+const ColorEntry *
-_colorTable[DEFAULT_BACK_COLOR].color = color;
+TerminalDisplay::colorTable () const
-QPalette p = palette();
+{
-p.setColor( backgroundRole(), color );
+return _colorTable;
-setPalette( p );
+}
-// Avoid propagating the palette change to the scroll bar
+void
-_scrollBar->setPalette( QApplication::palette() );
+TerminalDisplay::setBackgroundColor (const QColor & color)
+{
-update();
+_colorTable[DEFAULT_BACK_COLOR].color = color;
-}
+QPalette p = palette ();
-void TerminalDisplay::setForegroundColor(const QColor& color)
+p.setColor (backgroundRole (), color);
-{
+setPalette (p);
-_colorTable[DEFAULT_FORE_COLOR].color = color;
+// Avoid propagating the palette change to the scroll bar
-update();
+_scrollBar->setPalette (QApplication::palette ());
-}
-void TerminalDisplay::setColorTable(const ColorEntry table[])
+update ();
-{
+}
-for (int i = 0; i < TABLE_COLORS; i++)
-_colorTable[i] = table[i];
+void
+TerminalDisplay::setForegroundColor (const QColor & color)
-setBackgroundColor(_colorTable[DEFAULT_BACK_COLOR].color);
+{
+_colorTable[DEFAULT_FORE_COLOR].color = color;
+update ();
+}
+void
+TerminalDisplay::setColorTable (const ColorEntry table[])
+{
+for (int i = 0; i < TABLE_COLORS; i++)
+_colorTable[i] = table[i];
+setBackgroundColor (_colorTable[DEFAULT_BACK_COLOR].color);
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                   Font                                    */
 We treat non-iso10646 fonts as VT100 extended and do the requiered mapping
 from unicode to 0x00..0x1f. The remaining translation is then left to the
 QCodec.
 */
-static inline bool isLineChar(quint16 c) { return ((c & 0xFF80) == 0x2500);}
+static inline bool
-static inline bool isLineCharString(const QString& string)
+isLineChar (quint16 c)
 {
-return (string.length() > 0) && (isLineChar(string.at(0).unicode()));
+return ((c & 0xFF80) == 0x2500);
+}
+static inline bool
+isLineCharString (const QString & string)
+{
+return (string.length () > 0) && (isLineChar (string.at (0).unicode ()));
 }
 // assert for i in [0..31] : vt100extended(vt100_graphics[i]) == i.
-unsigned short vt100_graphics[32] =
+unsigned short vt100_graphics[32] = {	// 0/8     1/9    2/10    3/11    4/12    5/13    6/14    7/15
-{ // 0/8     1/9    2/10    3/11    4/12    5/13    6/14    7/15
 0x0020, 0x25C6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0,
 0x00b1, 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c,
 0xF800, 0xF801, 0x2500, 0xF803, 0xF804, 0x251c, 0x2524, 0x2534,
 0x252c, 0x2502, 0x2264, 0x2265, 0x03C0, 0x2260, 0x00A3, 0x00b7
 };
-void TerminalDisplay::fontChange(const QFont&)
+void
-{
+TerminalDisplay::fontChange (const QFont &)
-QFontMetrics fm(font());
+{
-_fontHeight = fm.height() + _lineSpacing;
+QFontMetrics fm (font ());
+_fontHeight = fm.height () + _lineSpacing;
-// waba TerminalDisplay 1.123:
-// "Base character width on widest ASCII character. This prevents too wide
+// waba TerminalDisplay 1.123:
-//  characters in the presence of double wide (e.g. Japanese) characters."
+// "Base character width on widest ASCII character. This prevents too wide
-// Get the width from representative normal width characters
+//  characters in the presence of double wide (e.g. Japanese) characters."
-_fontWidth = qRound((double)fm.width(REPCHAR)/(double)strlen(REPCHAR));
+// Get the width from representative normal width characters
+_fontWidth =
-_fixedFont = true;
+qRound ((double) fm.width (REPCHAR) / (double) strlen (REPCHAR));
-int fw = fm.width(REPCHAR[0]);
+_fixedFont = true;
-for(unsigned int i=1; i< strlen(REPCHAR); i++)
-{
+int fw = fm.width (REPCHAR[0]);
-if (fw != fm.width(REPCHAR[i]))
+for (unsigned int i = 1; i < strlen (REPCHAR); i++)
 {
-_fixedFont = false;
+if (fw != fm.width (REPCHAR[i]))
-break;
+	{
-}
+	  _fixedFont = false;
-}
+	  break;
+	}
-if (_fontWidth < 1)
+}
-_fontWidth=1;
+if (_fontWidth < 1)
-_fontAscent = fm.ascent();
+_fontWidth = 1;
-emit changedFontMetricSignal( _fontHeight, _fontWidth );
+_fontAscent = fm.ascent ();
-propagateSize();
-update();
+emit changedFontMetricSignal (_fontHeight, _fontWidth);
-}
+propagateSize ();
+update ();
-void TerminalDisplay::setVTFont(const QFont& f)
+}
-{
-QFont font = f;
+void
+TerminalDisplay::setVTFont (const QFont & f)
-QFontMetrics metrics(font);
+{
+QFont font = f;
-if ( !QFontInfo(font).fixedPitch() )
-{
+QFontMetrics metrics (font);
-//kWarning() << "Using an unsupported variable-width font in the terminal.  This may produce display errors.";
-}
+if (!QFontInfo (font).fixedPitch ())
+{
-if ( metrics.height() < height() && metrics.maxWidth() < width() )
+//kWarning() << "Using an unsupported variable-width font in the terminal.  This may produce display errors.";
-{
+}
-// hint that text should be drawn without anti-aliasing.
-// depending on the user's font configuration, this may not be respected
+if (metrics.height () < height () && metrics.maxWidth () < width ())
-if (!_antialiasText)
+{
-font.setStyleStrategy( QFont::NoAntialias );
+// hint that text should be drawn without anti-aliasing.
+// depending on the user's font configuration, this may not be respected
-// experimental optimization.  Konsole assumes that the terminal is using a
+if (!_antialiasText)
-// mono-spaced font, in which case kerning information should have an effect.
+	font.setStyleStrategy (QFont::NoAntialias);
-// Disabling kerning saves some computation when rendering text.
-font.setKerning(false);
+// experimental optimization.  Konsole assumes that the terminal is using a
+// mono-spaced font, in which case kerning information should have an effect.
-QWidget::setFont(font);
+// Disabling kerning saves some computation when rendering text.
-fontChange(font);
+font.setKerning (false);
-}
-}
+QWidget::setFont (font);
+fontChange (font);
-void TerminalDisplay::setFont(const QFont &)
+}
-{
+}
-// ignore font change request if not coming from konsole itself
+void
+TerminalDisplay::setFont (const QFont &)
+{
+// ignore font change request if not coming from konsole itself
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                         Constructor / Destructor                          */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
-TerminalDisplay::TerminalDisplay(QWidget *parent)
+TerminalDisplay::TerminalDisplay (QWidget * parent):QWidget (parent), _screenWindow (0), _allowBell (true), _gridLayout (0),
-:QWidget(parent)
+_fontHeight (1), _fontWidth (1), _fontAscent (1), _boldIntense (true),
-,_screenWindow(0)
+_lines (1), _columns (1), _usedLines (1), _usedColumns (1),
-,_allowBell(true)
+_contentHeight (1), _contentWidth (1), _image (0), _randomSeed (0),
-,_gridLayout(0)
+_resizing (false), _terminalSizeHint (false), _terminalSizeStartup (true),
-,_fontHeight(1)
+_bidiEnabled (false), _actSel (0), _wordSelectionMode (false),
-,_fontWidth(1)
+_lineSelectionMode (false), _preserveLineBreaks (false),
-,_fontAscent(1)
+_columnSelectionMode (false), _scrollbarLocation (NoScrollBar),
-,_boldIntense(true)
+_wordCharacters (":@-./_~"), _bellMode (SystemBeepBell), _blinking (false),
-,_lines(1)
+_hasBlinker (false), _cursorBlinking (false), _hasBlinkingCursor (false),
-,_columns(1)
+_allowBlinkingText (true), _ctrlDrag (true),
-,_usedLines(1)
+_tripleClickMode (SelectWholeLine), _isFixedSize (false),
-,_usedColumns(1)
+_possibleTripleClick (false), _resizeWidget (0), _resizeTimer (0),
-,_contentHeight(1)
+_flowControlWarningEnabled (false), _outputSuspendedLabel (0),
-,_contentWidth(1)
+_lineSpacing (0), _colorsInverted (false),
-,_image(0)
+_blendColor (qRgba (0, 0, 0, 0xff)),
-,_randomSeed(0)
+_filterChain (new TerminalImageFilterChain ()), _cursorShape (BlockCursor)
-,_resizing(false)
+{
-,_terminalSizeHint(false)
+// terminal applications are not designed with Right-To-Left in mind,
-,_terminalSizeStartup(true)
+// so the layout is forced to Left-To-Right
-,_bidiEnabled(false)
+setLayoutDirection (Qt::LeftToRight);
-,_actSel(0)
-,_wordSelectionMode(false)
+// The offsets are not yet calculated.
-,_lineSelectionMode(false)
+// Do not calculate these too often to be more smoothly when resizing
-,_preserveLineBreaks(false)
+// konsole in opaque mode.
-,_columnSelectionMode(false)
+_topMargin = DEFAULT_TOP_MARGIN;
-,_scrollbarLocation(NoScrollBar)
+_leftMargin = DEFAULT_LEFT_MARGIN;
-,_wordCharacters(":@-./_~")
-,_bellMode(SystemBeepBell)
+// create scroll bar for scrolling output up and down
-,_blinking(false)
+// set the scroll bar's slider to occupy the whole area of the scroll bar initially
-,_hasBlinker(false)
+_scrollBar = new QScrollBar (this);
-,_cursorBlinking(false)
+setScroll (0, 0);
-,_hasBlinkingCursor(false)
+_scrollBar->setCursor (Qt::ArrowCursor);
-,_allowBlinkingText(true)
+connect (_scrollBar, SIGNAL (valueChanged (int)), this,
-,_ctrlDrag(true)
+	   SLOT (scrollBarPositionChanged (int)));
-,_tripleClickMode(SelectWholeLine)
-,_isFixedSize(false)
+// setup timers for blinking cursor and text
-,_possibleTripleClick(false)
+_blinkTimer = new QTimer (this);
-,_resizeWidget(0)
+connect (_blinkTimer, SIGNAL (timeout ()), this, SLOT (blinkEvent ()));
-,_resizeTimer(0)
+_blinkCursorTimer = new QTimer (this);
-,_flowControlWarningEnabled(false)
+connect (_blinkCursorTimer, SIGNAL (timeout ()), this,
-,_outputSuspendedLabel(0)
+	   SLOT (blinkCursorEvent ()));
-,_lineSpacing(0)
-,_colorsInverted(false)
+//KCursor::setAutoHideCursor( this, true );
-,_blendColor(qRgba(0,0,0,0xff))
-,_filterChain(new TerminalImageFilterChain())
+setUsesMouse (true);
-,_cursorShape(BlockCursor)
+setColorTable (base_color_table);
-{
+setMouseTracking (true);
-// terminal applications are not designed with Right-To-Left in mind,
-// so the layout is forced to Left-To-Right
+// Enable drag and drop
-setLayoutDirection(Qt::LeftToRight);
+setAcceptDrops (true);	// attempt
+dragInfo.state = diNone;
-// The offsets are not yet calculated.
-// Do not calculate these too often to be more smoothly when resizing
+setFocusPolicy (Qt::WheelFocus);
-// konsole in opaque mode.
-_topMargin = DEFAULT_TOP_MARGIN;
+// enable input method support
-_leftMargin = DEFAULT_LEFT_MARGIN;
+setAttribute (Qt::WA_InputMethodEnabled, true);
-// create scroll bar for scrolling output up and down
+// this is an important optimization, it tells Qt
-// set the scroll bar's slider to occupy the whole area of the scroll bar initially
+// that TerminalDisplay will handle repainting its entire area.
-_scrollBar = new QScrollBar(this);
+setAttribute (Qt::WA_OpaquePaintEvent);
-setScroll(0,0);
-_scrollBar->setCursor( Qt::ArrowCursor );
+_gridLayout = new QGridLayout (this);
-connect(_scrollBar, SIGNAL(valueChanged(int)), this,
+_gridLayout->setContentsMargins (0, 0, 0, 0);
-SLOT(scrollBarPositionChanged(int)));
+setLayout (_gridLayout);
-// setup timers for blinking cursor and text
-_blinkTimer   = new QTimer(this);
+new
-connect(_blinkTimer, SIGNAL(timeout()), this, SLOT(blinkEvent()));
+AutoScrollHandler (this);
-_blinkCursorTimer   = new QTimer(this);
+}
-connect(_blinkCursorTimer, SIGNAL(timeout()), this, SLOT(blinkCursorEvent()));
+TerminalDisplay::~TerminalDisplay ()
-//KCursor::setAutoHideCursor( this, true );
+{
+disconnect (_blinkTimer);
-setUsesMouse(true);
+disconnect (_blinkCursorTimer);
-setColorTable(base_color_table);
+qApp->removeEventFilter (this);
-setMouseTracking(true);
+delete[]_image;
-// Enable drag and drop
-setAcceptDrops(true); // attempt
+delete _gridLayout;
-dragInfo.state = diNone;
+delete _outputSuspendedLabel;
+delete _filterChain;
-setFocusPolicy( Qt::WheelFocus );
-// enable input method support
-setAttribute(Qt::WA_InputMethodEnabled, true);
-// this is an important optimization, it tells Qt
-// that TerminalDisplay will handle repainting its entire area.
-setAttribute(Qt::WA_OpaquePaintEvent);
-_gridLayout = new QGridLayout(this);
-_gridLayout->setContentsMargins(0, 0, 0, 0);
-setLayout( _gridLayout );
-new AutoScrollHandler(this);
-}
-TerminalDisplay::~TerminalDisplay()
-{
-disconnect(_blinkTimer);
-disconnect(_blinkCursorTimer);
-qApp->removeEventFilter( this );
-delete[] _image;
-delete _gridLayout;
-delete _outputSuspendedLabel;
-delete _filterChain;
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                             Display Operations                            */
 */
 enum LineEncode
 {
-TopL  = (1<<1),
+TopL = (1 << 1),
-TopC  = (1<<2),
+TopC = (1 << 2),
-TopR  = (1<<3),
+TopR = (1 << 3),
-LeftT = (1<<5),
+LeftT = (1 << 5),
-Int11 = (1<<6),
+Int11 = (1 << 6),
-Int12 = (1<<7),
+Int12 = (1 << 7),
-Int13 = (1<<8),
+Int13 = (1 << 8),
-RightT = (1<<9),
+RightT = (1 << 9),
-LeftC = (1<<10),
+LeftC = (1 << 10),
-Int21 = (1<<11),
+Int21 = (1 << 11),
-Int22 = (1<<12),
+Int22 = (1 << 12),
-Int23 = (1<<13),
+Int23 = (1 << 13),
-RightC = (1<<14),
+RightC = (1 << 14),
-LeftB = (1<<15),
+LeftB = (1 << 15),
-Int31 = (1<<16),
+Int31 = (1 << 16),
-Int32 = (1<<17),
+Int32 = (1 << 17),
-Int33 = (1<<18),
+Int33 = (1 << 18),
-RightB = (1<<19),
+RightB = (1 << 19),
-BotL  = (1<<21),
+BotL = (1 << 21),
-BotC  = (1<<22),
+BotC = (1 << 22),
-BotR  = (1<<23)
+BotR = (1 << 23)
 };
 #include "LineFont.h"
-static void drawLineChar(QPainter& paint, int x, int y, int w, int h, uchar code)
+static void
-{
+drawLineChar (QPainter & paint, int x, int y, int w, int h, uchar code)
-//Calculate cell midpoints, end points.
+{
-int cx = x + w/2;
+//Calculate cell midpoints, end points.
-int cy = y + h/2;
+int cx = x + w / 2;
-int ex = x + w - 1;
+int cy = y + h / 2;
-int ey = y + h - 1;
+int ex = x + w - 1;
+int ey = y + h - 1;
-quint32 toDraw = LineChars[code];
+quint32 toDraw = LineChars[code];
-//Top _lines:
-if (toDraw & TopL)
+//Top _lines:
-paint.drawLine(cx-1, y, cx-1, cy-2);
+if (toDraw & TopL)
-if (toDraw & TopC)
+paint.drawLine (cx - 1, y, cx - 1, cy - 2);
-paint.drawLine(cx, y, cx, cy-2);
+if (toDraw & TopC)
-if (toDraw & TopR)
+paint.drawLine (cx, y, cx, cy - 2);
-paint.drawLine(cx+1, y, cx+1, cy-2);
+if (toDraw & TopR)
+paint.drawLine (cx + 1, y, cx + 1, cy - 2);
-//Bot _lines:
-if (toDraw & BotL)
+//Bot _lines:
-paint.drawLine(cx-1, cy+2, cx-1, ey);
+if (toDraw & BotL)
-if (toDraw & BotC)
+paint.drawLine (cx - 1, cy + 2, cx - 1, ey);
-paint.drawLine(cx, cy+2, cx, ey);
+if (toDraw & BotC)
-if (toDraw & BotR)
+paint.drawLine (cx, cy + 2, cx, ey);
-paint.drawLine(cx+1, cy+2, cx+1, ey);
+if (toDraw & BotR)
+paint.drawLine (cx + 1, cy + 2, cx + 1, ey);
-//Left _lines:
-if (toDraw & LeftT)
+//Left _lines:
-paint.drawLine(x, cy-1, cx-2, cy-1);
+if (toDraw & LeftT)
-if (toDraw & LeftC)
+paint.drawLine (x, cy - 1, cx - 2, cy - 1);
-paint.drawLine(x, cy, cx-2, cy);
+if (toDraw & LeftC)
-if (toDraw & LeftB)
+paint.drawLine (x, cy, cx - 2, cy);
-paint.drawLine(x, cy+1, cx-2, cy+1);
+if (toDraw & LeftB)
+paint.drawLine (x, cy + 1, cx - 2, cy + 1);
-//Right _lines:
-if (toDraw & RightT)
+//Right _lines:
-paint.drawLine(cx+2, cy-1, ex, cy-1);
+if (toDraw & RightT)
-if (toDraw & RightC)
+paint.drawLine (cx + 2, cy - 1, ex, cy - 1);
-paint.drawLine(cx+2, cy, ex, cy);
+if (toDraw & RightC)
-if (toDraw & RightB)
+paint.drawLine (cx + 2, cy, ex, cy);
-paint.drawLine(cx+2, cy+1, ex, cy+1);
+if (toDraw & RightB)
+paint.drawLine (cx + 2, cy + 1, ex, cy + 1);
-//Intersection points.
-if (toDraw & Int11)
+//Intersection points.
-paint.drawPoint(cx-1, cy-1);
+if (toDraw & Int11)
-if (toDraw & Int12)
+paint.drawPoint (cx - 1, cy - 1);
-paint.drawPoint(cx, cy-1);
+if (toDraw & Int12)
-if (toDraw & Int13)
+paint.drawPoint (cx, cy - 1);
-paint.drawPoint(cx+1, cy-1);
+if (toDraw & Int13)
+paint.drawPoint (cx + 1, cy - 1);
-if (toDraw & Int21)
-paint.drawPoint(cx-1, cy);
+if (toDraw & Int21)
-if (toDraw & Int22)
+paint.drawPoint (cx - 1, cy);
-paint.drawPoint(cx, cy);
+if (toDraw & Int22)
-if (toDraw & Int23)
+paint.drawPoint (cx, cy);
-paint.drawPoint(cx+1, cy);
+if (toDraw & Int23)
+paint.drawPoint (cx + 1, cy);
-if (toDraw & Int31)
-paint.drawPoint(cx-1, cy+1);
+if (toDraw & Int31)
-if (toDraw & Int32)
+paint.drawPoint (cx - 1, cy + 1);
-paint.drawPoint(cx, cy+1);
+if (toDraw & Int32)
-if (toDraw & Int33)
+paint.drawPoint (cx, cy + 1);
-paint.drawPoint(cx+1, cy+1);
+if (toDraw & Int33)
+paint.drawPoint (cx + 1, cy + 1);
-}
+}
-void TerminalDisplay::drawLineCharString(    QPainter& painter, int x, int y, const QString& str,
-const Character* attributes)
+void
-{
+TerminalDisplay::drawLineCharString (QPainter & painter, int x, int y,
-const QPen& currentPen = painter.pen();
+				     const QString & str,
+				     const Character * attributes)
-if ( (attributes->rendition & RE_BOLD) && _boldIntense )
+{
-{
+const QPen & currentPen = painter.pen ();
-QPen boldPen(currentPen);
-boldPen.setWidth(3);
+if ((attributes->rendition & RE_BOLD) && _boldIntense)
-painter.setPen( boldPen );
+{
-}
+QPen boldPen (currentPen);
+boldPen.setWidth (3);
-for (int i=0 ; i < str.length(); i++)
+painter.setPen (boldPen);
-{
+}
-uchar code = str[i].cell();
-if (LineChars[code])
+for (int i = 0; i < str.length (); i++)
-drawLineChar(painter, x + (_fontWidth*i), y, _fontWidth, _fontHeight, code);
+{
-}
+uchar code = str[i].cell ();
+if (LineChars[code])
-painter.setPen( currentPen );
+	drawLineChar (painter, x + (_fontWidth * i), y, _fontWidth,
-}
+		      _fontHeight, code);
+}
-void TerminalDisplay::setKeyboardCursorShape(KeyboardCursorShape shape)
-{
+painter.setPen (currentPen);
-_cursorShape = shape;
+}
-}
-TerminalDisplay::KeyboardCursorShape TerminalDisplay::keyboardCursorShape() const
+void
-{
+TerminalDisplay::setKeyboardCursorShape (KeyboardCursorShape shape)
-return _cursorShape;
+{
-}
+_cursorShape = shape;
-void TerminalDisplay::setKeyboardCursorColor(bool useForegroundColor, const QColor& color)
+}
-{
-if (useForegroundColor)
+TerminalDisplay::KeyboardCursorShape TerminalDisplay::keyboardCursorShape () const
-_cursorColor = QColor(); // an invalid color means that
+{
-// the foreground color of the
+return _cursorShape;
-// current character should
+}
-// be used
+void
-else
+TerminalDisplay::setKeyboardCursorColor (bool useForegroundColor,
-_cursorColor = color;
+					 const QColor & color)
-}
+{
-QColor TerminalDisplay::keyboardCursorColor() const
+if (useForegroundColor)
-{
+_cursorColor = QColor ();	// an invalid color means that
-return _cursorColor;
+// the foreground color of the
-}
+// current character should
+// be used
-void TerminalDisplay::setOpacity(qreal opacity)
-{
+else
-QColor color(_blendColor);
+_cursorColor = color;
-color.setAlphaF(opacity);
+}
-// enable automatic background filling to prevent the display
+QColor
-// flickering if there is no transparency
+TerminalDisplay::keyboardCursorColor () const
-/*if ( color.alpha() == 255 )
+{
-{
+return _cursorColor;
-setAutoFillBackground(true);
+}
-}
-else
+void
-{
+TerminalDisplay::setOpacity (qreal opacity)
-setAutoFillBackground(false);
+{
-}*/
+QColor color (_blendColor);
+color.setAlphaF (opacity);
-_blendColor = color.rgba();
-}
+// enable automatic background filling to prevent the display
+// flickering if there is no transparency
-void TerminalDisplay::drawBackground(QPainter& painter, const QRect& rect, const QColor& backgroundColor, bool useOpacitySetting )
+/*if ( color.alpha() == 255 )
 {
-// the area of the widget showing the contents of the terminal display is drawn
+setAutoFillBackground(true);
-// using the background color from the color scheme set with setColorTable()
+}
-//
+else
-// the area of the widget behind the scroll-bar is drawn using the background
+{
-// brush from the scroll-bar's palette, to give the effect of the scroll-bar
+setAutoFillBackground(false);
-// being outside of the terminal display and visual consistency with other KDE
+} */
-// applications.
-//
+_blendColor = color.rgba ();
-QRect scrollBarArea = _scrollBar->isVisible() ?
+}
-rect.intersected(_scrollBar->geometry()) :
-QRect();
+void
-QRegion contentsRegion = QRegion(rect).subtracted(scrollBarArea);
+TerminalDisplay::drawBackground (QPainter & painter, const QRect & rect,
-QRect contentsRect = contentsRegion.boundingRect();
+				 const QColor & backgroundColor,
+				 bool useOpacitySetting)
-if ( HAVE_TRANSPARENCY && qAlpha(_blendColor) < 0xff && useOpacitySetting )
+{
-{
+// the area of the widget showing the contents of the terminal display is drawn
-QColor color(backgroundColor);
+// using the background color from the color scheme set with setColorTable()
-color.setAlpha(qAlpha(_blendColor));
+//
+// the area of the widget behind the scroll-bar is drawn using the background
-painter.save();
+// brush from the scroll-bar's palette, to give the effect of the scroll-bar
-painter.setCompositionMode(QPainter::CompositionMode_Source);
+// being outside of the terminal display and visual consistency with other KDE
-painter.fillRect(contentsRect, color);
+// applications.
-painter.restore();
+//
-}
+QRect scrollBarArea = _scrollBar->isVisible ()?
-else
+rect.intersected (_scrollBar->geometry ()) : QRect ();
-painter.fillRect(contentsRect, backgroundColor);
+QRegion contentsRegion = QRegion (rect).subtracted (scrollBarArea);
+QRect contentsRect = contentsRegion.boundingRect ();
-painter.fillRect(scrollBarArea,_scrollBar->palette().background());
-}
+if (HAVE_TRANSPARENCY && qAlpha (_blendColor) < 0xff && useOpacitySetting)
+{
-void TerminalDisplay::drawCursor(QPainter& painter,
+QColor color (backgroundColor);
-const QRect& rect,
+color.setAlpha (qAlpha (_blendColor));
-const QColor& foregroundColor,
-const QColor& /*backgroundColor*/,
+painter.save ();
-bool& invertCharacterColor)
+painter.setCompositionMode (QPainter::CompositionMode_Source);
-{
+painter.fillRect (contentsRect, color);
-QRect cursorRect = rect;
+painter.restore ();
-cursorRect.setHeight(_fontHeight - _lineSpacing - 1);
+}
+else
-if (!_cursorBlinking)
+painter.fillRect (contentsRect, backgroundColor);
-{
-if ( _cursorColor.isValid() )
+painter.fillRect (scrollBarArea, _scrollBar->palette ().background ());
-painter.setPen(_cursorColor);
+}
-else
-painter.setPen(foregroundColor);
+void
+TerminalDisplay::drawCursor (QPainter & painter,
-if ( _cursorShape == BlockCursor )
+			     const QRect & rect,
-{
+			     const QColor & foregroundColor,
-// draw the cursor outline, adjusting the area so that
+			     const QColor & /*backgroundColor */ ,
-// it is draw entirely inside 'rect'
+			     bool & invertCharacterColor)
-int penWidth = qMax(1,painter.pen().width());
+{
+QRect cursorRect = rect;
-painter.drawRect(cursorRect.adjusted(penWidth/2,
+cursorRect.setHeight (_fontHeight - _lineSpacing - 1);
-penWidth/2,
-- penWidth/2 - penWidth%2,
+if (!_cursorBlinking)
-- penWidth/2 - penWidth%2));
+{
-if ( hasFocus() )
+if (_cursorColor.isValid ())
-{
+	painter.setPen (_cursorColor);
-painter.fillRect(cursorRect, _cursorColor.isValid() ? _cursorColor : foregroundColor);
+else
+	painter.setPen (foregroundColor);
-if ( !_cursorColor.isValid() )
-{
+if (_cursorShape == BlockCursor)
-// invert the colour used to draw the text to ensure that the character at
+	{
-// the cursor position is readable
+	  // draw the cursor outline, adjusting the area so that
-invertCharacterColor = true;
+	  // it is draw entirely inside 'rect'
-}
+	  int penWidth = qMax (1, painter.pen ().width ());
-}
-}
+	  painter.drawRect (cursorRect.adjusted (penWidth / 2,
-else if ( _cursorShape == UnderlineCursor )
+						 penWidth / 2,
-painter.drawLine(cursorRect.left(),
+						 -penWidth / 2 - penWidth % 2,
-cursorRect.bottom(),
+						 -penWidth / 2 -
-cursorRect.right(),
+						 penWidth % 2));
-cursorRect.bottom());
+	  if (hasFocus ())
-else if ( _cursorShape == IBeamCursor )
+	    {
-painter.drawLine(cursorRect.left(),
+	      painter.fillRect (cursorRect,
-cursorRect.top(),
+				_cursorColor.
-cursorRect.left(),
+				isValid ()? _cursorColor : foregroundColor);
-cursorRect.bottom());
+	      if (!_cursorColor.isValid ())
-}
+		{
-}
+		  // invert the colour used to draw the text to ensure that the character at
+		  // the cursor position is readable
-void TerminalDisplay::drawCharacters(QPainter& painter,
+		  invertCharacterColor = true;
-const QRect& rect,
+		}
-const QString& text,
+	    }
-const Character* style,
+	}
-bool invertCharacterColor)
+else if (_cursorShape == UnderlineCursor)
-{
+	painter.drawLine (cursorRect.left (),
-// don't draw text which is currently blinking
+			  cursorRect.bottom (),
-if ( _blinking && (style->rendition & RE_BLINK) )
+			  cursorRect.right (), cursorRect.bottom ());
-return;
+else if (_cursorShape == IBeamCursor)
+	painter.drawLine (cursorRect.left (),
-// setup bold and underline
+			  cursorRect.top (),
-bool useBold;
+			  cursorRect.left (), cursorRect.bottom ());
-ColorEntry::FontWeight weight = style->fontWeight(_colorTable);
-if (weight == ColorEntry::UseCurrentFormat)
+}
-useBold = ((style->rendition & RE_BOLD) && _boldIntense) || font().bold();
+}
-else
-useBold = (weight == ColorEntry::Bold) ? true : false;
+void
-bool useUnderline = style->rendition & RE_UNDERLINE || font().underline();
+TerminalDisplay::drawCharacters (QPainter & painter,
+				 const QRect & rect,
-QFont font = painter.font();
+				 const QString & text,
-if (    font.bold() != useBold
+				 const Character * style,
-|| font.underline() != useUnderline )
+				 bool invertCharacterColor)
 {
-font.setBold(useBold);
+// don't draw text which is currently blinking
-font.setUnderline(useUnderline);
+if (_blinking && (style->rendition & RE_BLINK))
-painter.setFont(font);
+return;
-}
+// setup bold and underline
-// setup pen
+bool useBold;
-const CharacterColor& textColor = ( invertCharacterColor ? style->backgroundColor : style->foregroundColor );
+ColorEntry::FontWeight weight = style->fontWeight (_colorTable);
-const QColor color = textColor.color(_colorTable);
+if (weight == ColorEntry::UseCurrentFormat)
-QPen pen = painter.pen();
+useBold = ((style->rendition & RE_BOLD) && _boldIntense)
-if ( pen.color() != color )
+|| font ().bold ();
-{
+else
-pen.setColor(color);
+useBold = (weight == ColorEntry::Bold) ? true : false;
-painter.setPen(color);
+bool useUnderline = style->rendition & RE_UNDERLINE || font ().underline ();
-}
+QFont font = painter.font ();
-// draw text
+if (font.bold () != useBold || font.underline () != useUnderline)
-if ( isLineCharString(text) )
+{
-drawLineCharString(painter,rect.x(),rect.y(),text,style);
+font.setBold (useBold);
-else
+font.setUnderline (useUnderline);
-{
+painter.setFont (font);
-// the drawText(rect,flags,string) overload is used here with null flags
+}
-// instead of drawText(rect,string) because the (rect,string) overload causes
-// the application's default layout direction to be used instead of
+// setup pen
-// the widget-specific layout direction, which should always be
+const CharacterColor & textColor =
-// Qt::LeftToRight for this widget
+(invertCharacterColor ? style->backgroundColor : style->foregroundColor);
-// This was discussed in: http://lists.kde.org/?t=120552223600002&r=1&w=2
+const QColor color = textColor.color (_colorTable);
-if (_bidiEnabled)
+QPen pen = painter.pen ();
-painter.drawText(rect,0,text);
+if (pen.color () != color)
-else
+{
-painter.drawText(rect,0,LTR_OVERRIDE_CHAR+text);
+pen.setColor (color);
-}
+painter.setPen (color);
 }
-void TerminalDisplay::drawTextFragment(QPainter& painter ,
+// draw text
-const QRect& rect,
+if (isLineCharString (text))
-const QString& text,
+drawLineCharString (painter, rect.x (), rect.y (), text, style);
-const Character* style)
+else
 {
-painter.save();
+// the drawText(rect,flags,string) overload is used here with null flags
+// instead of drawText(rect,string) because the (rect,string) overload causes
-// setup painter
+// the application's default layout direction to be used instead of
-const QColor foregroundColor = style->foregroundColor.color(_colorTable);
+// the widget-specific layout direction, which should always be
-const QColor backgroundColor = style->backgroundColor.color(_colorTable);
+// Qt::LeftToRight for this widget
+// This was discussed in: http://lists.kde.org/?t=120552223600002&r=1&w=2
-// draw background if different from the display's background color
+if (_bidiEnabled)
-if ( backgroundColor != palette().background().color() )
+	painter.drawText (rect, 0, text);
-drawBackground(painter,rect,backgroundColor,
+else
-false /* do not use transparency */);
+	painter.drawText (rect, 0, LTR_OVERRIDE_CHAR + text);
+}
-// draw cursor shape if the current character is the cursor
+}
-// this may alter the foreground and background colors
-bool invertCharacterColor = false;
+void
-if ( style->rendition & RE_CURSOR )
+TerminalDisplay::drawTextFragment (QPainter & painter,
-drawCursor(painter,rect,foregroundColor,backgroundColor,invertCharacterColor);
+				   const QRect & rect,
+				   const QString & text,
-// draw text
+				   const Character * style)
-drawCharacters(painter,rect,text,style,invertCharacterColor);
+{
+painter.save ();
-painter.restore();
-}
+// setup painter
+const QColor foregroundColor = style->foregroundColor.color (_colorTable);
-void TerminalDisplay::setRandomSeed(uint randomSeed) { _randomSeed = randomSeed; }
+const QColor backgroundColor = style->backgroundColor.color (_colorTable);
-uint TerminalDisplay::randomSeed() const { return _randomSeed; }
+// draw background if different from the display's background color
+if (backgroundColor != palette ().background ().color ())
+drawBackground (painter, rect, backgroundColor,
+		    false /* do not use transparency */ );
+// draw cursor shape if the current character is the cursor
+// this may alter the foreground and background colors
+bool invertCharacterColor = false;
+if (style->rendition & RE_CURSOR)
+drawCursor (painter, rect, foregroundColor, backgroundColor,
+		invertCharacterColor);
+// draw text
+drawCharacters (painter, rect, text, style, invertCharacterColor);
+painter.restore ();
+}
+void
+TerminalDisplay::setRandomSeed (uint randomSeed)
+{
+_randomSeed = randomSeed;
+}
+uint
+TerminalDisplay::randomSeed () const
+{
+return _randomSeed;
+}
 #if 0
 /*!
 Set XIM Position
 */
-void TerminalDisplay::setCursorPos(const int curx, const int cury)
+void
-{
+TerminalDisplay::setCursorPos (const int curx, const int cury)
-QPoint tL  = contentsRect().topLeft();
+{
-int    tLx = tL.x();
+QPoint tL = contentsRect ().topLeft ();
-int    tLy = tL.y();
+int tLx = tL.x ();
+int tLy = tL.y ();
-int xpos, ypos;
-ypos = _topMargin + tLy + _fontHeight*(cury-1) + _fontAscent;
+int xpos, ypos;
-xpos = _leftMargin + tLx + _fontWidth*curx;
+ypos = _topMargin + tLy + _fontHeight * (cury - 1) + _fontAscent;
-_cursorLine = cury;
+xpos = _leftMargin + tLx + _fontWidth * curx;
-_cursorCol = curx;
+_cursorLine = cury;
+_cursorCol = curx;
 }
 #endif
 // scrolls the image by 'lines', down if lines > 0 or up otherwise.
 //
 // image as it receives input, and when the view is updated, it calls scrollImage()
 // with the final scroll amount.  this improves performance because scrolling the
 // display is much cheaper than re-rendering all the text for the
 // part of the image which has moved up or down.
 // Instead only new lines have to be drawn
-void TerminalDisplay::scrollImage(int lines , const QRect& screenWindowRegion)
+void
-{
+TerminalDisplay::scrollImage (int lines, const QRect & screenWindowRegion)
-// if the flow control warning is enabled this will interfere with the
+{
-// scrolling optimizations and cause artifacts.  the simple solution here
+// if the flow control warning is enabled this will interfere with the
-// is to just disable the optimization whilst it is visible
+// scrolling optimizations and cause artifacts.  the simple solution here
-if ( _outputSuspendedLabel && _outputSuspendedLabel->isVisible() )
+// is to just disable the optimization whilst it is visible
-return;
+if (_outputSuspendedLabel && _outputSuspendedLabel->isVisible ())
+return;
-// constrain the region to the display
-// the bottom of the region is capped to the number of lines in the display's
+// constrain the region to the display
-// internal image - 2, so that the height of 'region' is strictly less
+// the bottom of the region is capped to the number of lines in the display's
-// than the height of the internal image.
+// internal image - 2, so that the height of 'region' is strictly less
-QRect region = screenWindowRegion;
+// than the height of the internal image.
-region.setBottom( qMin(region.bottom(),this->_lines-2) );
+QRect region = screenWindowRegion;
+region.setBottom (qMin (region.bottom (), this->_lines - 2));
-// return if there is nothing to do
-if (    lines == 0
+// return if there is nothing to do
-|| _image == 0
+if (lines == 0
-|| !region.isValid()
+|| _image == 0
-|| (region.top() + abs(lines)) >= region.bottom()
+|| !region.isValid ()
-|| this->_lines <= region.height() ) return;
+|| (region.top () + abs (lines)) >= region.bottom ()
+|| this->_lines <= region.height ())
-// hide terminal size label to prevent it being scrolled
+return;
-if (_resizeWidget && _resizeWidget->isVisible())
-_resizeWidget->hide();
+// hide terminal size label to prevent it being scrolled
+if (_resizeWidget && _resizeWidget->isVisible ())
-// Note:  With Qt 4.4 the left edge of the scrolled area must be at 0
+_resizeWidget->hide ();
-// to get the correct (newly exposed) part of the widget repainted.
-//
+// Note:  With Qt 4.4 the left edge of the scrolled area must be at 0
-// The right edge must be before the left edge of the scroll bar to
+// to get the correct (newly exposed) part of the widget repainted.
-// avoid triggering a repaint of the entire widget, the distance is
+//
-// given by SCROLLBAR_CONTENT_GAP
+// The right edge must be before the left edge of the scroll bar to
-//
+// avoid triggering a repaint of the entire widget, the distance is
-// Set the QT_FLUSH_PAINT environment variable to '1' before starting the
+// given by SCROLLBAR_CONTENT_GAP
-// application to monitor repainting.
+//
-//
+// Set the QT_FLUSH_PAINT environment variable to '1' before starting the
-int scrollBarWidth = _scrollBar->isHidden() ? 0 : _scrollBar->width();
+// application to monitor repainting.
-const int SCROLLBAR_CONTENT_GAP = 1;
+//
-QRect scrollRect;
+int scrollBarWidth = _scrollBar->isHidden ()? 0 : _scrollBar->width ();
-if ( _scrollbarLocation == ScrollBarLeft )
+const int SCROLLBAR_CONTENT_GAP = 1;
-{
+QRect scrollRect;
-scrollRect.setLeft(scrollBarWidth+SCROLLBAR_CONTENT_GAP);
+if (_scrollbarLocation == ScrollBarLeft)
-scrollRect.setRight(width());
+{
-}
+scrollRect.setLeft (scrollBarWidth + SCROLLBAR_CONTENT_GAP);
+scrollRect.setRight (width ());
+}
+else
+{
+scrollRect.setLeft (0);
+scrollRect.setRight (width () - scrollBarWidth - SCROLLBAR_CONTENT_GAP);
+}
+void *firstCharPos = &_image[region.top () * this->_columns];
+void *lastCharPos = &_image[(region.top () + abs (lines)) * this->_columns];
+int top = _topMargin + (region.top () * _fontHeight);
+int linesToMove = region.height () - abs (lines);
+int bytesToMove = linesToMove * this->_columns * sizeof (Character);
+Q_ASSERT (linesToMove > 0);
+Q_ASSERT (bytesToMove > 0);
+//scroll internal image
+if (lines > 0)
+{
+// check that the memory areas that we are going to move are valid
+Q_ASSERT ((char *) lastCharPos + bytesToMove <
+		(char *) (_image + (this->_lines * this->_columns)));
+Q_ASSERT ((lines * this->_columns) < _imageSize);
+//scroll internal image down
+memmove (firstCharPos, lastCharPos, bytesToMove);
+//set region of display to scroll
+scrollRect.setTop (top);
+}
+else
+{
+// check that the memory areas that we are going to move are valid
+Q_ASSERT ((char *) firstCharPos + bytesToMove <
+		(char *) (_image + (this->_lines * this->_columns)));
+//scroll internal image up
+memmove (lastCharPos, firstCharPos, bytesToMove);
+//set region of the display to scroll
+scrollRect.setTop (top + abs (lines) * _fontHeight);
+}
+scrollRect.setHeight (linesToMove * _fontHeight);
+Q_ASSERT (scrollRect.isValid () && !scrollRect.isEmpty ());
+//scroll the display vertically to match internal _image
+scroll (0, _fontHeight * (-lines), scrollRect);
+}
+QRegion
+TerminalDisplay::hotSpotRegion () const
+{
+QRegion region;
+foreach (Filter::HotSpot * hotSpot, _filterChain->hotSpots ())
+{
+QRect r;
+if (hotSpot->startLine () == hotSpot->endLine ())
+{
+	r.setLeft (hotSpot->startColumn ());
+	r.setTop (hotSpot->startLine ());
+	r.setRight (hotSpot->endColumn ());
+	r.setBottom (hotSpot->endLine ());
+	region |= imageToWidget (r);;
+}
 else
 {
-scrollRect.setLeft(0);
+	r.setLeft (hotSpot->startColumn ());
-scrollRect.setRight(width() - scrollBarWidth - SCROLLBAR_CONTENT_GAP);
+	r.setTop (hotSpot->startLine ());
-}
+	r.setRight (_columns);
-void* firstCharPos = &_image[ region.top() * this->_columns ];
+	r.setBottom (hotSpot->startLine ());
-void* lastCharPos = &_image[ (region.top() + abs(lines)) * this->_columns ];
+	region |= imageToWidget (r);;
+	for (int line = hotSpot->startLine () + 1; line < hotSpot->endLine ();
-int top = _topMargin + (region.top() * _fontHeight);
+	     line++)
-int linesToMove = region.height() - abs(lines);
+	  {
-int bytesToMove = linesToMove *
+	    r.setLeft (0);
-this->_columns *
+	    r.setTop (line);
-sizeof(Character);
+	    r.setRight (_columns);
+	    r.setBottom (line);
-Q_ASSERT( linesToMove > 0 );
+	    region |= imageToWidget (r);;
-Q_ASSERT( bytesToMove > 0 );
+	  }
+	r.setLeft (0);
-//scroll internal image
+	r.setTop (hotSpot->endLine ());
-if ( lines > 0 )
+	r.setRight (hotSpot->endColumn ());
-{
+	r.setBottom (hotSpot->endLine ());
-// check that the memory areas that we are going to move are valid
+	region |= imageToWidget (r);;
-Q_ASSERT( (char*)lastCharPos + bytesToMove <
+}
-(char*)(_image + (this->_lines * this->_columns)) );
+}
+return region;
-Q_ASSERT( (lines*this->_columns) < _imageSize );
+}
-//scroll internal image down
+void
-memmove( firstCharPos , lastCharPos , bytesToMove );
+TerminalDisplay::processFilters ()
+{
-//set region of display to scroll
+if (!_screenWindow)
-scrollRect.setTop(top);
+return;
-}
-else
+QRegion preUpdateHotSpots = hotSpotRegion ();
-{
-// check that the memory areas that we are going to move are valid
+// use _screenWindow->getImage() here rather than _image because
-Q_ASSERT( (char*)firstCharPos + bytesToMove <
+// other classes may call processFilters() when this display's
-(char*)(_image + (this->_lines * this->_columns)) );
+// ScreenWindow emits a scrolled() signal - which will happen before
+// updateImage() is called on the display and therefore _image is
-//scroll internal image up
+// out of date at this point
-memmove( lastCharPos , firstCharPos , bytesToMove );
+_filterChain->setImage (_screenWindow->getImage (),
+			  _screenWindow->windowLines (),
-//set region of the display to scroll
+			  _screenWindow->windowColumns (),
-scrollRect.setTop(top + abs(lines) * _fontHeight);
+			  _screenWindow->getLineProperties ());
-}
+_filterChain->process ();
-scrollRect.setHeight(linesToMove * _fontHeight );
+QRegion postUpdateHotSpots = hotSpotRegion ();
-Q_ASSERT(scrollRect.isValid() && !scrollRect.isEmpty());
+update (preUpdateHotSpots | postUpdateHotSpots);
-//scroll the display vertically to match internal _image
+}
-scroll( 0 , _fontHeight * (-lines) , scrollRect );
-}
+void
+TerminalDisplay::updateImage ()
-QRegion TerminalDisplay::hotSpotRegion() const
+{
-{
+if (!_screenWindow)
-QRegion region;
+return;
-foreach( Filter::HotSpot* hotSpot , _filterChain->hotSpots() )
-{
+// optimization - scroll the existing image where possible and
-QRect r;
+// avoid expensive text drawing for parts of the image that
-if (hotSpot->startLine()==hotSpot->endLine()) {
+// can simply be moved up or down
-r.setLeft(hotSpot->startColumn());
+scrollImage (_screenWindow->scrollCount (), _screenWindow->scrollRegion ());
-r.setTop(hotSpot->startLine());
+_screenWindow->resetScrollCount ();
-r.setRight(hotSpot->endColumn());
-r.setBottom(hotSpot->endLine());
+if (!_image)
-region |= imageToWidget(r);;
+{
-} else {
+// Create _image.
-r.setLeft(hotSpot->startColumn());
+// The emitted changedContentSizeSignal also leads to getImage being recreated, so do this first.
-r.setTop(hotSpot->startLine());
+updateImageSize ();
-r.setRight(_columns);
+}
-r.setBottom(hotSpot->startLine());
-region |= imageToWidget(r);;
+Character *const newimg = _screenWindow->getImage ();
-for ( int line = hotSpot->startLine()+1 ; line < hotSpot->endLine() ; line++ ) {
+int lines = _screenWindow->windowLines ();
-r.setLeft(0);
+int columns = _screenWindow->windowColumns ();
-r.setTop(line);
-r.setRight(_columns);
+setScroll (_screenWindow->currentLine (), _screenWindow->lineCount ());
-r.setBottom(line);
-region |= imageToWidget(r);;
+Q_ASSERT (this->_usedLines <= this->_lines);
-}
+Q_ASSERT (this->_usedColumns <= this->_columns);
-r.setLeft(0);
-r.setTop(hotSpot->endLine());
+int y, x, len;
-r.setRight(hotSpot->endColumn());
-r.setBottom(hotSpot->endLine());
+QPoint tL = contentsRect ().topLeft ();
-region |= imageToWidget(r);;
+int tLx = tL.x ();
-}
+int tLy = tL.y ();
-}
+_hasBlinker = false;
-return region;
-}
+CharacterColor cf;		// undefined
+CharacterColor _clipboard;	// undefined
-void TerminalDisplay::processFilters()
+int cr = -1;			// undefined
-{
-if (!_screenWindow)
+const int linesToUpdate = qMin (this->_lines, qMax (0, lines));
-return;
+const int columnsToUpdate = qMin (this->_columns, qMax (0, columns));
-QRegion preUpdateHotSpots = hotSpotRegion();
+QChar *disstrU = new QChar[columnsToUpdate];
+char *dirtyMask = new char[columnsToUpdate + 2];
-// use _screenWindow->getImage() here rather than _image because
+QRegion dirtyRegion;
-// other classes may call processFilters() when this display's
-// ScreenWindow emits a scrolled() signal - which will happen before
+// debugging variable, this records the number of lines that are found to
-// updateImage() is called on the display and therefore _image is
+// be 'dirty' ( ie. have changed from the old _image to the new _image ) and
-// out of date at this point
+// which therefore need to be repainted
-_filterChain->setImage( _screenWindow->getImage(),
+int dirtyLineCount = 0;
-_screenWindow->windowLines(),
-_screenWindow->windowColumns(),
+for (y = 0; y < linesToUpdate; ++y)
-_screenWindow->getLineProperties() );
+{
-_filterChain->process();
+const Character *currentLine = &_image[y * this->_columns];
+const Character *const newLine = &newimg[y * columns];
-QRegion postUpdateHotSpots = hotSpotRegion();
+bool updateLine = false;
-update( preUpdateHotSpots | postUpdateHotSpots );
-}
+// The dirty mask indicates which characters need repainting. We also
+// mark surrounding neighbours dirty, in case the character exceeds
-void TerminalDisplay::updateImage()
+// its cell boundaries
-{
+memset (dirtyMask, 0, columnsToUpdate + 2);
-if ( !_screenWindow )
-return;
+for (x = 0; x < columnsToUpdate; ++x)
+	{
-// optimization - scroll the existing image where possible and
+	  if (newLine[x] != currentLine[x])
-// avoid expensive text drawing for parts of the image that
+	    {
-// can simply be moved up or down
+	      dirtyMask[x] = true;
-scrollImage( _screenWindow->scrollCount() ,
+	    }
-_screenWindow->scrollRegion() );
+	}
-_screenWindow->resetScrollCount();
+if (!_resizing)		// not while _resizing, we're expecting a paintEvent
-if (!_image) {
+	for (x = 0; x < columnsToUpdate; ++x)
-// Create _image.
+	  {
-// The emitted changedContentSizeSignal also leads to getImage being recreated, so do this first.
+	    _hasBlinker |= (newLine[x].rendition & RE_BLINK);
-updateImageSize();
-}
+	    // Start drawing if this character or the next one differs.
+	    // We also take the next one into account to handle the situation
-Character* const newimg = _screenWindow->getImage();
+	    // where characters exceed their cell width.
-int lines = _screenWindow->windowLines();
+	    if (dirtyMask[x])
-int columns = _screenWindow->windowColumns();
+	      {
+		quint16 c = newLine[x + 0].character;
-setScroll( _screenWindow->currentLine() , _screenWindow->lineCount() );
+		if (!c)
+		  continue;
-Q_ASSERT( this->_usedLines <= this->_lines );
+		int p = 0;
-Q_ASSERT( this->_usedColumns <= this->_columns );
+		disstrU[p++] = c;	//fontMap(c);
+		bool lineDraw = isLineChar (c);
-int y,x,len;
+		bool doubleWidth =
+		  (x + 1 ==
-QPoint tL  = contentsRect().topLeft();
+		   columnsToUpdate) ? false : (newLine[x + 1].character == 0);
-int    tLx = tL.x();
+		cr = newLine[x].rendition;
-int    tLy = tL.y();
+		_clipboard = newLine[x].backgroundColor;
-_hasBlinker = false;
+		if (newLine[x].foregroundColor != cf)
+		  cf = newLine[x].foregroundColor;
-CharacterColor cf;       // undefined
+		int lln = columnsToUpdate - x;
-CharacterColor _clipboard;       // undefined
+		for (len = 1; len < lln; ++len)
-int cr  = -1;   // undefined
+		  {
+		    const Character & ch = newLine[x + len];
-const int linesToUpdate = qMin(this->_lines, qMax(0,lines  ));
-const int columnsToUpdate = qMin(this->_columns,qMax(0,columns));
+		    if (!ch.character)
+		      continue;	// Skip trailing part of multi-col chars.
-QChar *disstrU = new QChar[columnsToUpdate];
-char *dirtyMask = new char[columnsToUpdate+2];
+		    bool nextIsDoubleWidth =
-QRegion dirtyRegion;
+		      (x + len + 1 ==
+		       columnsToUpdate) ? false : (newLine[x + len +
-// debugging variable, this records the number of lines that are found to
+							   1].character == 0);
-// be 'dirty' ( ie. have changed from the old _image to the new _image ) and
-// which therefore need to be repainted
+		    if (ch.foregroundColor != cf ||
-int dirtyLineCount = 0;
+			ch.backgroundColor != _clipboard ||
+			ch.rendition != cr ||
-for (y = 0; y < linesToUpdate; ++y)
+			!dirtyMask[x + len] ||
-{
+			isLineChar (c) != lineDraw ||
-const Character*       currentLine = &_image[y*this->_columns];
+			nextIsDoubleWidth != doubleWidth)
-const Character* const newLine = &newimg[y*columns];
+		      break;
-bool updateLine = false;
+		    disstrU[p++] = c;	//fontMap(c);
+		  }
-// The dirty mask indicates which characters need repainting. We also
-// mark surrounding neighbours dirty, in case the character exceeds
+		QString unistr (disstrU, p);
-// its cell boundaries
-memset(dirtyMask, 0, columnsToUpdate+2);
+		bool saveFixedFont = _fixedFont;
+		if (lineDraw)
-for( x = 0 ; x < columnsToUpdate ; ++x)
+		  _fixedFont = false;
-{
+		if (doubleWidth)
-if ( newLine[x] != currentLine[x] )
+		  _fixedFont = false;
-{
-dirtyMask[x] = true;
+		updateLine = true;
-}
-}
+		_fixedFont = saveFixedFont;
+		x += len - 1;
-if (!_resizing) // not while _resizing, we're expecting a paintEvent
+	      }
-for (x = 0; x < columnsToUpdate; ++x)
-{
+	  }
-_hasBlinker |= (newLine[x].rendition & RE_BLINK);
+//both the top and bottom halves of double height _lines must always be redrawn
-// Start drawing if this character or the next one differs.
+//although both top and bottom halves contain the same characters, only
-// We also take the next one into account to handle the situation
+//the top one is actually
-// where characters exceed their cell width.
+//drawn.
-if (dirtyMask[x])
+if (_lineProperties.count () > y)
-{
+	updateLine |= (_lineProperties[y] & LINE_DOUBLEHEIGHT);
-quint16 c = newLine[x+0].character;
-if ( !c )
+// if the characters on the line are different in the old and the new _image
-continue;
+// then this line must be repainted.
-int p = 0;
+if (updateLine)
-disstrU[p++] = c; //fontMap(c);
+	{
-bool lineDraw = isLineChar(c);
+	  dirtyLineCount++;
-bool doubleWidth = (x+1 == columnsToUpdate) ? false : (newLine[x+1].character == 0);
-cr = newLine[x].rendition;
+	  // add the area occupied by this line to the region which needs to be
-_clipboard = newLine[x].backgroundColor;
+	  // repainted
-if (newLine[x].foregroundColor != cf) cf = newLine[x].foregroundColor;
+	  QRect dirtyRect = QRect (_leftMargin + tLx,
-int lln = columnsToUpdate - x;
+				   _topMargin + tLy + _fontHeight * y,
-for (len = 1; len < lln; ++len)
+				   _fontWidth * columnsToUpdate,
-{
+				   _fontHeight);
-const Character& ch = newLine[x+len];
+	  dirtyRegion |= dirtyRect;
-if (!ch.character)
+	}
-continue; // Skip trailing part of multi-col chars.
+// replace the line of characters in the old _image with the
-bool nextIsDoubleWidth = (x+len+1 == columnsToUpdate) ? false : (newLine[x+len+1].character == 0);
+// current line of the new _image
+memcpy ((void *) currentLine, (const void *) newLine,
-if (  ch.foregroundColor != cf ||
+	      columnsToUpdate * sizeof (Character));
-ch.backgroundColor != _clipboard ||
+}
-ch.rendition != cr ||
-!dirtyMask[x+len] ||
+// if the new _image is smaller than the previous _image, then ensure that the area
-isLineChar(c) != lineDraw ||
+// outside the new _image is cleared
-nextIsDoubleWidth != doubleWidth )
+if (linesToUpdate < _usedLines)
-break;
+{
+dirtyRegion |= QRect (_leftMargin + tLx,
-disstrU[p++] = c; //fontMap(c);
+			    _topMargin + tLy + _fontHeight * linesToUpdate,
-}
+			    _fontWidth * this->_columns,
+			    _fontHeight * (_usedLines - linesToUpdate));
-QString unistr(disstrU, p);
+}
+_usedLines = linesToUpdate;
-bool saveFixedFont = _fixedFont;
-if (lineDraw)
+if (columnsToUpdate < _usedColumns)
-_fixedFont = false;
+{
-if (doubleWidth)
+dirtyRegion |= QRect (_leftMargin + tLx + columnsToUpdate * _fontWidth,
-_fixedFont = false;
+			    _topMargin + tLy,
+			    _fontWidth * (_usedColumns - columnsToUpdate),
-updateLine = true;
+			    _fontHeight * this->_lines);
+}
-_fixedFont = saveFixedFont;
+_usedColumns = columnsToUpdate;
-x += len - 1;
-}
+dirtyRegion |= _inputMethodData.previousPreeditRect;
-}
+// update the parts of the display which have changed
+update (dirtyRegion);
-//both the top and bottom halves of double height _lines must always be redrawn
-//although both top and bottom halves contain the same characters, only
+if (_hasBlinker && !_blinkTimer->isActive ())
-//the top one is actually
+_blinkTimer->start (TEXT_BLINK_DELAY);
-//drawn.
+if (!_hasBlinker && _blinkTimer->isActive ())
-if (_lineProperties.count() > y)
+{
-updateLine |= (_lineProperties[y] & LINE_DOUBLEHEIGHT);
+_blinkTimer->stop ();
+_blinking = false;
-// if the characters on the line are different in the old and the new _image
+}
-// then this line must be repainted.
+delete[]dirtyMask;
-if (updateLine)
+delete[]disstrU;
-{
-dirtyLineCount++;
+}
-// add the area occupied by this line to the region which needs to be
+void
-// repainted
+TerminalDisplay::showResizeNotification ()
-QRect dirtyRect = QRect( _leftMargin+tLx ,
+{
-_topMargin+tLy+_fontHeight*y ,
+if (_terminalSizeHint && isVisible ())
-_fontWidth * columnsToUpdate ,
+{
-_fontHeight );
+if (_terminalSizeStartup)
+	{
-dirtyRegion |= dirtyRect;
+	  _terminalSizeStartup = false;
-}
+	  return;
+	}
-// replace the line of characters in the old _image with the
+if (!_resizeWidget)
-// current line of the new _image
+	{
-memcpy((void*)currentLine,(const void*)newLine,columnsToUpdate*sizeof(Character));
+	  _resizeWidget = new QLabel (QString ("Size: XXX x XXX"), this);
-}
+	  _resizeWidget->setMinimumWidth (_resizeWidget->fontMetrics ().
+					  width (QString
-// if the new _image is smaller than the previous _image, then ensure that the area
+						 ("Size: XXX x XXX")));
-// outside the new _image is cleared
+	  _resizeWidget->setMinimumHeight (_resizeWidget->sizeHint ().
-if ( linesToUpdate < _usedLines )
+					   height ());
-{
+	  _resizeWidget->setAlignment (Qt::AlignCenter);
-dirtyRegion |= QRect(   _leftMargin+tLx ,
-_topMargin+tLy+_fontHeight*linesToUpdate ,
+	  _resizeWidget->
-_fontWidth * this->_columns ,
+	    setStyleSheet
-_fontHeight * (_usedLines-linesToUpdate) );
+	    ("background-color:palette(window);border-style:solid;border-width:1px;border-color:palette(dark)");
-}
-_usedLines = linesToUpdate;
+	  _resizeTimer = new QTimer (this);
+	  _resizeTimer->setSingleShot (true);
-if ( columnsToUpdate < _usedColumns )
+	  connect (_resizeTimer, SIGNAL (timeout ()), _resizeWidget,
-{
+		   SLOT (hide ()));
-dirtyRegion |= QRect(   _leftMargin+tLx+columnsToUpdate*_fontWidth ,
+	}
-_topMargin+tLy ,
+QString sizeStr = QString ("Size: %1 x %2").arg (_columns).arg (_lines);
-_fontWidth * (_usedColumns-columnsToUpdate) ,
+_resizeWidget->setText (sizeStr);
-_fontHeight * this->_lines );
+_resizeWidget->move ((width () - _resizeWidget->width ()) / 2,
-}
+			   (height () - _resizeWidget->height ()) / 2 + 20);
-_usedColumns = columnsToUpdate;
+_resizeWidget->show ();
+_resizeTimer->start (1000);
-dirtyRegion |= _inputMethodData.previousPreeditRect;
+}
+}
-// update the parts of the display which have changed
-update(dirtyRegion);
+void
+TerminalDisplay::setBlinkingCursor (bool blink)
-if ( _hasBlinker && !_blinkTimer->isActive()) _blinkTimer->start( TEXT_BLINK_DELAY );
+{
-if (!_hasBlinker && _blinkTimer->isActive()) { _blinkTimer->stop(); _blinking = false; }
+_hasBlinkingCursor = blink;
-delete[] dirtyMask;
-delete[] disstrU;
+if (blink && !_blinkCursorTimer->isActive ())
+_blinkCursorTimer->start (QApplication::cursorFlashTime () / 2);
-}
+if (!blink && _blinkCursorTimer->isActive ())
-void TerminalDisplay::showResizeNotification()
+{
-{
+_blinkCursorTimer->stop ();
-if (_terminalSizeHint && isVisible())
+if (_cursorBlinking)
-{
+	blinkCursorEvent ();
-if (_terminalSizeStartup) {
+else
-_terminalSizeStartup=false;
+	_cursorBlinking = false;
-return;
+}
 }
-if (!_resizeWidget)
-{
+void
-_resizeWidget = new QLabel(QString("Size: XXX x XXX"), this);
+TerminalDisplay::setBlinkingTextEnabled (bool blink)
-_resizeWidget->setMinimumWidth(_resizeWidget->fontMetrics().width(QString("Size: XXX x XXX")));
+{
-_resizeWidget->setMinimumHeight(_resizeWidget->sizeHint().height());
+_allowBlinkingText = blink;
-_resizeWidget->setAlignment(Qt::AlignCenter);
+if (blink && !_blinkTimer->isActive ())
-_resizeWidget->setStyleSheet("background-color:palette(window);border-style:solid;border-width:1px;border-color:palette(dark)");
+_blinkTimer->start (TEXT_BLINK_DELAY);
-_resizeTimer = new QTimer(this);
+if (!blink && _blinkTimer->isActive ())
-_resizeTimer->setSingleShot(true);
+{
-connect(_resizeTimer, SIGNAL(timeout()), _resizeWidget, SLOT(hide()));
+_blinkTimer->stop ();
-}
+_blinking = false;
-QString sizeStr = QString("Size: %1 x %2").arg(_columns).arg(_lines);
+}
-_resizeWidget->setText(sizeStr);
+}
-_resizeWidget->move((width()-_resizeWidget->width())/2,
-(height()-_resizeWidget->height())/2+20);
+void
-_resizeWidget->show();
+TerminalDisplay::focusOutEvent (QFocusEvent *)
-_resizeTimer->start(1000);
+{
-}
+// trigger a repaint of the cursor so that it is both visible (in case
-}
+// it was hidden during blinking)
+// and drawn in a focused out state
-void TerminalDisplay::setBlinkingCursor(bool blink)
+_cursorBlinking = false;
-{
+updateCursor ();
-_hasBlinkingCursor=blink;
+_blinkCursorTimer->stop ();
-if (blink && !_blinkCursorTimer->isActive())
+if (_blinking)
-_blinkCursorTimer->start(QApplication::cursorFlashTime() / 2);
+blinkEvent ();
-if (!blink && _blinkCursorTimer->isActive())
+_blinkTimer->stop ();
-{
+}
-_blinkCursorTimer->stop();
-if (_cursorBlinking)
+void
-blinkCursorEvent();
+TerminalDisplay::focusInEvent (QFocusEvent *)
-else
+{
-_cursorBlinking = false;
+if (_hasBlinkingCursor)
-}
+{
-}
+_blinkCursorTimer->start ();
+}
-void TerminalDisplay::setBlinkingTextEnabled(bool blink)
+updateCursor ();
-{
-_allowBlinkingText = blink;
+if (_hasBlinker)
+_blinkTimer->start ();
-if (blink && !_blinkTimer->isActive())
+}
-_blinkTimer->start(TEXT_BLINK_DELAY);
+void
-if (!blink && _blinkTimer->isActive())
+TerminalDisplay::paintEvent (QPaintEvent * pe)
 {
-_blinkTimer->stop();
+QPainter paint (this);
-_blinking = false;
-}
+foreach (const QRect & rect, (pe->region () & contentsRect ()).rects ())
-}
+{
+drawBackground (paint, rect, palette ().background ().color (),
-void TerminalDisplay::focusOutEvent(QFocusEvent*)
+		    true /* use opacity setting */ );
-{
+drawContents (paint, rect);
-// trigger a repaint of the cursor so that it is both visible (in case
+}
-// it was hidden during blinking)
+drawInputMethodPreeditString (paint, preeditRect ());
-// and drawn in a focused out state
+paintFilters (paint);
-_cursorBlinking = false;
+}
-updateCursor();
+QPoint
-_blinkCursorTimer->stop();
+TerminalDisplay::cursorPosition () const
-if (_blinking)
+{
-blinkEvent();
+if (_screenWindow)
+return _screenWindow->cursorPosition ();
-_blinkTimer->stop();
+else
-}
+return QPoint (0, 0);
-void TerminalDisplay::focusInEvent(QFocusEvent*)
+}
-{
-if (_hasBlinkingCursor)
+QRect
-{
+TerminalDisplay::preeditRect () const
-_blinkCursorTimer->start();
+{
-}
+const int preeditLength = string_width (_inputMethodData.preeditString);
-updateCursor();
+if (preeditLength == 0)
-if (_hasBlinker)
+return QRect ();
-_blinkTimer->start();
-}
+return QRect (_leftMargin + _fontWidth * cursorPosition ().x (),
+		_topMargin + _fontHeight * cursorPosition ().y (),
-void TerminalDisplay::paintEvent( QPaintEvent* pe )
+		_fontWidth * preeditLength, _fontHeight);
-{
+}
-QPainter paint(this);
+void
-foreach (const QRect &rect, (pe->region() & contentsRect()).rects())
+TerminalDisplay::drawInputMethodPreeditString (QPainter & painter,
-{
+					       const QRect & rect)
-drawBackground(paint,rect,palette().background().color(),
+{
-true /* use opacity setting */);
+if (_inputMethodData.preeditString.isEmpty ())
-drawContents(paint, rect);
+return;
-}
-drawInputMethodPreeditString(paint,preeditRect());
+const QPoint cursorPos = cursorPosition ();
-paintFilters(paint);
-}
+bool invertColors = false;
+const QColor background = _colorTable[DEFAULT_BACK_COLOR].color;
-QPoint TerminalDisplay::cursorPosition() const
+const QColor foreground = _colorTable[DEFAULT_FORE_COLOR].color;
-{
+const Character *style = &_image[loc (cursorPos.x (), cursorPos.y ())];
-if (_screenWindow)
-return _screenWindow->cursorPosition();
+drawBackground (painter, rect, background, true);
-else
+drawCursor (painter, rect, foreground, background, invertColors);
-return QPoint(0,0);
+drawCharacters (painter, rect, _inputMethodData.preeditString, style,
-}
+		  invertColors);
-QRect TerminalDisplay::preeditRect() const
+_inputMethodData.previousPreeditRect = rect;
-{
+}
-const int preeditLength = string_width(_inputMethodData.preeditString);
+FilterChain *
-if ( preeditLength == 0 )
+TerminalDisplay::filterChain () const
-return QRect();
+{
+return _filterChain;
-return QRect(_leftMargin + _fontWidth*cursorPosition().x(),
+}
-_topMargin + _fontHeight*cursorPosition().y(),
-_fontWidth*preeditLength,
+void
-_fontHeight);
+TerminalDisplay::paintFilters (QPainter & painter)
-}
+{
+// get color of character under mouse and use it to draw
-void TerminalDisplay::drawInputMethodPreeditString(QPainter& painter , const QRect& rect)
+// lines for filters
-{
+QPoint cursorPos = mapFromGlobal (QCursor::pos ());
-if ( _inputMethodData.preeditString.isEmpty() )
+int cursorLine;
-return;
+int cursorColumn;
+int scrollBarWidth =
-const QPoint cursorPos = cursorPosition();
+(_scrollbarLocation == ScrollBarLeft) ? _scrollBar->width () : 0;
-bool invertColors = false;
+getCharacterPosition (cursorPos, cursorLine, cursorColumn);
-const QColor background = _colorTable[DEFAULT_BACK_COLOR].color;
+Character cursorCharacter = _image[loc (cursorColumn, cursorLine)];
-const QColor foreground = _colorTable[DEFAULT_FORE_COLOR].color;
-const Character* style = &_image[loc(cursorPos.x(),cursorPos.y())];
+painter.
+setPen (QPen (cursorCharacter.foregroundColor.color (colorTable ())));
-drawBackground(painter,rect,background,true);
-drawCursor(painter,rect,foreground,background,invertColors);
+// iterate over hotspots identified by the display's currently active filters
-drawCharacters(painter,rect,_inputMethodData.preeditString,style,invertColors);
+// and draw appropriate visuals to indicate the presence of the hotspot
-_inputMethodData.previousPreeditRect = rect;
+QList < Filter::HotSpot * >spots = _filterChain->hotSpots ();
-}
+QListIterator < Filter::HotSpot * >iter (spots);
+while (iter.hasNext ())
-FilterChain* TerminalDisplay::filterChain() const
+{
-{
+Filter::HotSpot * spot = iter.next ();
-return _filterChain;
-}
+QRegion region;
+if (spot->type () == Filter::HotSpot::Link)
-void TerminalDisplay::paintFilters(QPainter& painter)
+	{
-{
+	  QRect r;
-// get color of character under mouse and use it to draw
+	  if (spot->startLine () == spot->endLine ())
-// lines for filters
+	    {
-QPoint cursorPos = mapFromGlobal(QCursor::pos());
+	      r.setCoords (spot->startColumn () * _fontWidth + 1 +
-int cursorLine;
+			   scrollBarWidth,
-int cursorColumn;
+			   spot->startLine () * _fontHeight + 1,
-int scrollBarWidth = (_scrollbarLocation == ScrollBarLeft) ? _scrollBar->width() : 0;
+			   (spot->endColumn () - 1) * _fontWidth - 1 +
+			   scrollBarWidth,
-getCharacterPosition( cursorPos , cursorLine , cursorColumn );
+			   (spot->endLine () + 1) * _fontHeight - 1);
-Character cursorCharacter = _image[loc(cursorColumn,cursorLine)];
+	      region |= r;
+	    }
-painter.setPen( QPen(cursorCharacter.foregroundColor.color(colorTable())) );
+	  else
+	    {
-// iterate over hotspots identified by the display's currently active filters
+	      r.setCoords (spot->startColumn () * _fontWidth + 1 +
-// and draw appropriate visuals to indicate the presence of the hotspot
+			   scrollBarWidth,
+			   spot->startLine () * _fontHeight + 1,
-QList<Filter::HotSpot*> spots = _filterChain->hotSpots();
+			   (_columns - 1) * _fontWidth - 1 + scrollBarWidth,
-QListIterator<Filter::HotSpot*> iter(spots);
+			   (spot->startLine () + 1) * _fontHeight - 1);
-while (iter.hasNext())
+	      region |= r;
-{
+	      for (int line = spot->startLine () + 1; line < spot->endLine ();
-Filter::HotSpot* spot = iter.next();
+		   line++)
+		{
-QRegion region;
+		  r.setCoords (0 * _fontWidth + 1 + scrollBarWidth,
-if ( spot->type() == Filter::HotSpot::Link ) {
+			       line * _fontHeight + 1,
-QRect r;
+			       (_columns - 1) * _fontWidth - 1 +
-if (spot->startLine()==spot->endLine()) {
+			       scrollBarWidth, (line + 1) * _fontHeight - 1);
-r.setCoords( spot->startColumn()*_fontWidth + 1 + scrollBarWidth,
+		  region |= r;
-spot->startLine()*_fontHeight + 1,
+		}
-(spot->endColumn()-1)*_fontWidth - 1 + scrollBarWidth,
+	      r.setCoords (0 * _fontWidth + 1 + scrollBarWidth,
-(spot->endLine()+1)*_fontHeight - 1 );
+			   spot->endLine () * _fontHeight + 1,
-region |= r;
+			   (spot->endColumn () - 1) * _fontWidth - 1 +
-} else {
+			   scrollBarWidth,
-r.setCoords( spot->startColumn()*_fontWidth + 1 + scrollBarWidth,
+			   (spot->endLine () + 1) * _fontHeight - 1);
-spot->startLine()*_fontHeight + 1,
+	      region |= r;
-(_columns-1)*_fontWidth - 1 + scrollBarWidth,
+	    }
-(spot->startLine()+1)*_fontHeight - 1 );
+	}
-region |= r;
-for ( int line = spot->startLine()+1 ; line < spot->endLine() ; line++ ) {
+for (int line = spot->startLine (); line <= spot->endLine (); line++)
-r.setCoords( 0*_fontWidth + 1 + scrollBarWidth,
+	{
-line*_fontHeight + 1,
+	  int startColumn = 0;
-(_columns-1)*_fontWidth - 1 + scrollBarWidth,
+	  int endColumn = _columns - 1;	// TODO use number of _columns which are actually
-(line+1)*_fontHeight - 1 );
+	  // occupied on this line rather than the width of the
-region |= r;
+	  // display in _columns
-}
-r.setCoords( 0*_fontWidth + 1 + scrollBarWidth,
+	  // ignore whitespace at the end of the lines
-spot->endLine()*_fontHeight + 1,
+	  while (QChar (_image[loc (endColumn, line)].character).isSpace ()
-(spot->endColumn()-1)*_fontWidth - 1 + scrollBarWidth,
+		 && endColumn > 0)
-(spot->endLine()+1)*_fontHeight - 1 );
+	    endColumn--;
-region |= r;
-}
+	  // increment here because the column which we want to set 'endColumn' to
-}
+	  // is the first whitespace character at the end of the line
+	  endColumn++;
-for ( int line = spot->startLine() ; line <= spot->endLine() ; line++ )
-{
+	  if (line == spot->startLine ())
-int startColumn = 0;
+	    startColumn = spot->startColumn ();
-int endColumn = _columns-1; // TODO use number of _columns which are actually
+	  if (line == spot->endLine ())
-// occupied on this line rather than the width of the
+	    endColumn = spot->endColumn ();
-// display in _columns
+	  // subtract one pixel from
-// ignore whitespace at the end of the lines
+	  // the right and bottom so that
-while ( QChar(_image[loc(endColumn,line)].character).isSpace() && endColumn > 0 )
+	  // we do not overdraw adjacent
-endColumn--;
+	  // hotspots
+	  //
-// increment here because the column which we want to set 'endColumn' to
+	  // subtracting one pixel from all sides also prevents an edge case where
-// is the first whitespace character at the end of the line
+	  // moving the mouse outside a link could still leave it underlined
-endColumn++;
+	  // because the check below for the position of the cursor
+	  // finds it on the border of the target area
-if ( line == spot->startLine() )
+	  QRect r;
-startColumn = spot->startColumn();
+	  r.setCoords (startColumn * _fontWidth + 1 + scrollBarWidth,
-if ( line == spot->endLine() )
+		       line * _fontHeight + 1,
-endColumn = spot->endColumn();
+		       endColumn * _fontWidth - 1 + scrollBarWidth,
+		       (line + 1) * _fontHeight - 1);
-// subtract one pixel from
+	  // Underline link hotspots
-// the right and bottom so that
+	  if (spot->type () == Filter::HotSpot::Link)
-// we do not overdraw adjacent
+	    {
-// hotspots
+	      QFontMetrics metrics (font ());
-//
-// subtracting one pixel from all sides also prevents an edge case where
+	      // find the baseline (which is the invisible line that the characters in the font sit on,
-// moving the mouse outside a link could still leave it underlined
+	      // with some having tails dangling below)
-// because the check below for the position of the cursor
+	      int baseline = r.bottom () - metrics.descent ();
-// finds it on the border of the target area
+	      // find the position of the underline below that
-QRect r;
+	      int underlinePos = baseline + metrics.underlinePos ();
-r.setCoords( startColumn*_fontWidth + 1 + scrollBarWidth,
+	      if (region.contains (mapFromGlobal (QCursor::pos ())))
-line*_fontHeight + 1,
+		{
-endColumn*_fontWidth - 1 + scrollBarWidth,
+		  painter.drawLine (r.left (), underlinePos,
-(line+1)*_fontHeight - 1 );
+				    r.right (), underlinePos);
-// Underline link hotspots
+		}
-if ( spot->type() == Filter::HotSpot::Link )
+	    }
-{
+	  // Marker hotspots simply have a transparent rectanglular shape
-QFontMetrics metrics(font());
+	  // drawn on top of them
+	  else if (spot->type () == Filter::HotSpot::Marker)
-// find the baseline (which is the invisible line that the characters in the font sit on,
+	    {
-// with some having tails dangling below)
+	      //TODO - Do not use a hardcoded colour for this
-int baseline = r.bottom() - metrics.descent();
+	      painter.fillRect (r, QBrush (QColor (255, 0, 0, 120)));
-// find the position of the underline below that
+	    }
-int underlinePos = baseline + metrics.underlinePos();
+	}
-if ( region.contains( mapFromGlobal(QCursor::pos()) ) ){
+}
-painter.drawLine( r.left() , underlinePos ,
+}
-r.right() , underlinePos );
-}
+void
-}
+TerminalDisplay::drawContents (QPainter & paint, const QRect & rect)
-// Marker hotspots simply have a transparent rectanglular shape
+{
-// drawn on top of them
+QPoint tL = contentsRect ().topLeft ();
-else if ( spot->type() == Filter::HotSpot::Marker )
+int tLx = tL.x ();
-{
+int tLy = tL.y ();
-//TODO - Do not use a hardcoded colour for this
-painter.fillRect(r,QBrush(QColor(255,0,0,120)));
+int lux =
-}
+qMin (_usedColumns - 1,
-}
+	  qMax (0, (rect.left () - tLx - _leftMargin) / _fontWidth));
-}
+int luy =
-}
+qMin (_usedLines - 1,
-void TerminalDisplay::drawContents(QPainter &paint, const QRect &rect)
+	  qMax (0, (rect.top () - tLy - _topMargin) / _fontHeight));
-{
+int rlx =
-QPoint tL  = contentsRect().topLeft();
+qMin (_usedColumns - 1,
-int    tLx = tL.x();
+	  qMax (0, (rect.right () - tLx - _leftMargin) / _fontWidth));
-int    tLy = tL.y();
+int rly =
+qMin (_usedLines - 1,
-int lux = qMin(_usedColumns-1, qMax(0,(rect.left()   - tLx - _leftMargin ) / _fontWidth));
+	  qMax (0, (rect.bottom () - tLy - _topMargin) / _fontHeight));
-int luy = qMin(_usedLines-1,  qMax(0,(rect.top()    - tLy - _topMargin  ) / _fontHeight));
-int rlx = qMin(_usedColumns-1, qMax(0,(rect.right()  - tLx - _leftMargin ) / _fontWidth));
+const int bufferSize = _usedColumns;
-int rly = qMin(_usedLines-1,  qMax(0,(rect.bottom() - tLy - _topMargin  ) / _fontHeight));
+QString unistr;
+unistr.reserve (bufferSize);
-const int bufferSize = _usedColumns;
+for (int y = luy; y <= rly; y++)
-QString unistr;
+{
-unistr.reserve(bufferSize);
+quint16 c = _image[loc (lux, y)].character;
-for (int y = luy; y <= rly; y++)
+int x = lux;
-{
+if (!c && x)
-quint16 c = _image[loc(lux,y)].character;
+	x--;			// Search for start of multi-column character
-int x = lux;
+for (; x <= rlx; x++)
-if(!c && x)
+	{
-x--; // Search for start of multi-column character
+	  int len = 1;
-for (; x <= rlx; x++)
+	  int p = 0;
-{
-int len = 1;
+	  // reset our buffer to the maximal size
-int p = 0;
+	  unistr.resize (bufferSize);
+	  QChar *disstrU = unistr.data ();
-// reset our buffer to the maximal size
-unistr.resize(bufferSize);
+	  // is this a single character or a sequence of characters ?
-QChar *disstrU = unistr.data();
+	  if (_image[loc (x, y)].rendition & RE_EXTENDED_CHAR)
+	    {
-// is this a single character or a sequence of characters ?
+	      // sequence of characters
-if ( _image[loc(x,y)].rendition & RE_EXTENDED_CHAR )
+	      ushort extendedCharLength = 0;
-{
+	      ushort *chars =
-// sequence of characters
+		ExtendedCharTable::instance.
-ushort extendedCharLength = 0;
+		lookupExtendedChar (_image[loc (x, y)].charSequence,
-ushort* chars = ExtendedCharTable::instance
+				    extendedCharLength);
-.lookupExtendedChar(_image[loc(x,y)].charSequence,extendedCharLength);
+	      for (int index = 0; index < extendedCharLength; index++)
-for ( int index = 0 ; index < extendedCharLength ; index++ )
+		{
-{
+		  Q_ASSERT (p < bufferSize);
-Q_ASSERT( p < bufferSize );
+		  disstrU[p++] = chars[index];
-disstrU[p++] = chars[index];
+		}
-}
+	    }
-}
+	  else
-else
+	    {
-{
+	      // single character
-// single character
+	      c = _image[loc (x, y)].character;
-c = _image[loc(x,y)].character;
+	      if (c)
-if (c)
+		{
-{
+		  Q_ASSERT (p < bufferSize);
-Q_ASSERT( p < bufferSize );
+		  disstrU[p++] = c;	//fontMap(c);
-disstrU[p++] = c; //fontMap(c);
+		}
-}
+	    }
-}
+	  bool lineDraw = isLineChar (c);
-bool lineDraw = isLineChar(c);
+	  bool doubleWidth =
-bool doubleWidth = (_image[ qMin(loc(x,y)+1,_imageSize) ].character == 0);
+	    (_image[qMin (loc (x, y) + 1, _imageSize)].character == 0);
-CharacterColor currentForeground = _image[loc(x,y)].foregroundColor;
+	  CharacterColor currentForeground =
-CharacterColor currentBackground = _image[loc(x,y)].backgroundColor;
+	    _image[loc (x, y)].foregroundColor;
-quint8 currentRendition = _image[loc(x,y)].rendition;
+	  CharacterColor currentBackground =
+	    _image[loc (x, y)].backgroundColor;
-while (x+len <= rlx &&
+	  quint8 currentRendition = _image[loc (x, y)].rendition;
-_image[loc(x+len,y)].foregroundColor == currentForeground &&
-_image[loc(x+len,y)].backgroundColor == currentBackground &&
+	  while (x + len <= rlx && _image[loc (x + len, y)].foregroundColor == currentForeground && _image[loc (x + len, y)].backgroundColor == currentBackground && _image[loc (x + len, y)].rendition == currentRendition && (_image[qMin (loc (x + len, y) + 1, _imageSize)].character == 0) == doubleWidth && isLineChar (c = _image[loc (x + len, y)].character) == lineDraw)	// Assignment!
-_image[loc(x+len,y)].rendition == currentRendition &&
+	    {
-(_image[ qMin(loc(x+len,y)+1,_imageSize) ].character == 0) == doubleWidth &&
+	      if (c)
-isLineChar( c = _image[loc(x+len,y)].character) == lineDraw) // Assignment!
+		disstrU[p++] = c;	//fontMap(c);
-{
+	      if (doubleWidth)	// assert((_image[loc(x+len,y)+1].character == 0)), see above if condition
-if (c)
+		len++;		// Skip trailing part of multi-column character
-disstrU[p++] = c; //fontMap(c);
+	      len++;
-if (doubleWidth) // assert((_image[loc(x+len,y)+1].character == 0)), see above if condition
+	    }
-len++; // Skip trailing part of multi-column character
+	  if ((x + len < _usedColumns)
-len++;
+	      && (!_image[loc (x + len, y)].character))
-}
+	    len++;		// Adjust for trailing part of multi-column character
-if ((x+len < _usedColumns) && (!_image[loc(x+len,y)].character))
-len++; // Adjust for trailing part of multi-column character
+	  bool save__fixedFont = _fixedFont;
+	  if (lineDraw)
-bool save__fixedFont = _fixedFont;
+	    _fixedFont = false;
-if (lineDraw)
+	  if (doubleWidth)
-_fixedFont = false;
+	    _fixedFont = false;
-if (doubleWidth)
+	  unistr.resize (p);
-_fixedFont = false;
-unistr.resize(p);
+	  // Create a text scaling matrix for double width and double height lines.
+	  QMatrix textScale;
-// Create a text scaling matrix for double width and double height lines.
-QMatrix textScale;
+	  if (y < _lineProperties.size ())
+	    {
-if (y < _lineProperties.size())
+	      if (_lineProperties[y] & LINE_DOUBLEWIDTH)
-{
+		textScale.scale (2, 1);
-if (_lineProperties[y] & LINE_DOUBLEWIDTH)
-textScale.scale(2,1);
+	      if (_lineProperties[y] & LINE_DOUBLEHEIGHT)
+		textScale.scale (1, 2);
-if (_lineProperties[y] & LINE_DOUBLEHEIGHT)
+	    }
-textScale.scale(1,2);
-}
+	  //Apply text scaling matrix.
+	  paint.setWorldMatrix (textScale, true);
-//Apply text scaling matrix.
-paint.setWorldMatrix(textScale, true);
+	  //calculate the area in which the text will be drawn
+	  QRect textArea =
-//calculate the area in which the text will be drawn
+	    QRect (_leftMargin + tLx + _fontWidth * x,
-QRect textArea = QRect( _leftMargin+tLx+_fontWidth*x , _topMargin+tLy+_fontHeight*y , _fontWidth*len , _fontHeight);
+		   _topMargin + tLy + _fontHeight * y, _fontWidth * len,
+		   _fontHeight);
-//move the calculated area to take account of scaling applied to the painter.
-//the position of the area from the origin (0,0) is scaled
+	  //move the calculated area to take account of scaling applied to the painter.
-//by the opposite of whatever
+	  //the position of the area from the origin (0,0) is scaled
-//transformation has been applied to the painter.  this ensures that
+	  //by the opposite of whatever
-//painting does actually start from textArea.topLeft()
+	  //transformation has been applied to the painter.  this ensures that
-//(instead of textArea.topLeft() * painter-scale)
+	  //painting does actually start from textArea.topLeft()
-textArea.moveTopLeft( textScale.inverted().map(textArea.topLeft()) );
+	  //(instead of textArea.topLeft() * painter-scale)
+	  textArea.moveTopLeft (textScale.inverted ().
-//paint text fragment
+				map (textArea.topLeft ()));
-drawTextFragment(    paint,
-textArea,
+	  //paint text fragment
-unistr,
+	  drawTextFragment (paint, textArea, unistr, &_image[loc (x, y)]);	//,
-&_image[loc(x,y)] ); //,
+	  //0,
-//0,
+	  //!_isPrinting );
-//!_isPrinting );
+	  _fixedFont = save__fixedFont;
-_fixedFont = save__fixedFont;
+	  //reset back to single-width, single-height _lines
-//reset back to single-width, single-height _lines
+	  paint.setWorldMatrix (textScale.inverted (), true);
-paint.setWorldMatrix(textScale.inverted(), true);
+	  if (y < _lineProperties.size () - 1)
-if (y < _lineProperties.size()-1)
+	    {
-{
+	      //double-height _lines are represented by two adjacent _lines
-//double-height _lines are represented by two adjacent _lines
+	      //containing the same characters
-//containing the same characters
+	      //both _lines will have the LINE_DOUBLEHEIGHT attribute.
-//both _lines will have the LINE_DOUBLEHEIGHT attribute.
+	      //If the current line has the LINE_DOUBLEHEIGHT attribute,
-//If the current line has the LINE_DOUBLEHEIGHT attribute,
+	      //we can therefore skip the next line
-//we can therefore skip the next line
+	      if (_lineProperties[y] & LINE_DOUBLEHEIGHT)
-if (_lineProperties[y] & LINE_DOUBLEHEIGHT)
+		y++;
-y++;
+	    }
-}
+	  x += len - 1;
-x += len - 1;
+	}
 }
 }
-}
+void
-void TerminalDisplay::blinkEvent()
+TerminalDisplay::blinkEvent ()
 {
-if (!_allowBlinkingText) return;
+if (!_allowBlinkingText)
+return;
-_blinking = !_blinking;
+_blinking = !_blinking;
-//TODO:  Optimize to only repaint the areas of the widget
-// where there is blinking text
+//TODO:  Optimize to only repaint the areas of the widget
-// rather than repainting the whole widget.
+// where there is blinking text
-update();
+// rather than repainting the whole widget.
-}
+update ();
+}
-QRect TerminalDisplay::imageToWidget(const QRect& imageArea) const
-{
+QRect
-QRect result;
+TerminalDisplay::imageToWidget (const QRect & imageArea) const
-result.setLeft( _leftMargin + _fontWidth * imageArea.left() );
+{
-result.setTop( _topMargin + _fontHeight * imageArea.top() );
+QRect result;
-result.setWidth( _fontWidth * imageArea.width() );
+result.setLeft (_leftMargin + _fontWidth * imageArea.left ());
-result.setHeight( _fontHeight * imageArea.height() );
+result.setTop (_topMargin + _fontHeight * imageArea.top ());
+result.setWidth (_fontWidth * imageArea.width ());
-return result;
+result.setHeight (_fontHeight * imageArea.height ());
-}
+return result;
-void TerminalDisplay::updateCursor()
+}
-{
-QRect cursorRect = imageToWidget( QRect(cursorPosition(),QSize(1,1)) );
+void
-update(cursorRect);
+TerminalDisplay::updateCursor ()
-}
+{
+QRect cursorRect = imageToWidget (QRect (cursorPosition (), QSize (1, 1)));
-void TerminalDisplay::blinkCursorEvent()
+update (cursorRect);
-{
+}
-_cursorBlinking = !_cursorBlinking;
-updateCursor();
+void
+TerminalDisplay::blinkCursorEvent ()
+{
+_cursorBlinking = !_cursorBlinking;
+updateCursor ();
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                  Resizing                                 */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
-void TerminalDisplay::resizeEvent(QResizeEvent*)
+void
-{
+TerminalDisplay::resizeEvent (QResizeEvent *)
-updateImageSize();
+{
-}
+updateImageSize ();
+}
-void TerminalDisplay::propagateSize()
-{
+void
-if (_isFixedSize)
+TerminalDisplay::propagateSize ()
 {
-setSize(_columns, _lines);
+if (_isFixedSize)
-QWidget::setFixedSize(sizeHint());
+{
-parentWidget()->adjustSize();
+setSize (_columns, _lines);
-parentWidget()->setFixedSize(parentWidget()->sizeHint());
+QWidget::setFixedSize (sizeHint ());
-return;
+parentWidget ()->adjustSize ();
-}
+parentWidget ()->setFixedSize (parentWidget ()->sizeHint ());
-if (_image)
+return;
-updateImageSize();
+}
-}
+if (_image)
+updateImageSize ();
-void TerminalDisplay::updateImageSize()
+}
-{
-Character* oldimg = _image;
+void
-int oldlin = _lines;
+TerminalDisplay::updateImageSize ()
-int oldcol = _columns;
+{
+Character *oldimg = _image;
-makeImage();
+int oldlin = _lines;
+int oldcol = _columns;
-// copy the old image to reduce flicker
-int lines = qMin(oldlin,_lines);
+makeImage ();
-int columns = qMin(oldcol,_columns);
+// copy the old image to reduce flicker
-if (oldimg)
+int lines = qMin (oldlin, _lines);
-{
+int columns = qMin (oldcol, _columns);
-for (int line = 0; line < lines; line++)
-{
+if (oldimg)
-memcpy((void*)&_image[_columns*line],
+{
-(void*)&oldimg[oldcol*line],columns*sizeof(Character));
+for (int line = 0; line < lines; line++)
-}
+	{
-delete[] oldimg;
+	  memcpy ((void *) &_image[_columns * line],
-}
+		  (void *) &oldimg[oldcol * line],
+		  columns * sizeof (Character));
-if (_screenWindow)
+	}
-_screenWindow->setWindowLines(_lines);
+delete[]oldimg;
+}
-_resizing = (oldlin!=_lines) || (oldcol!=_columns);
+if (_screenWindow)
-if ( _resizing )
+_screenWindow->setWindowLines (_lines);
-{
-showResizeNotification();
+_resizing = (oldlin != _lines) || (oldcol != _columns);
-emit changedContentSizeSignal(_contentHeight, _contentWidth); // expose resizeEvent
-}
+if (_resizing)
+{
-_resizing = false;
+showResizeNotification ();
+emit changedContentSizeSignal (_contentHeight, _contentWidth);	// expose resizeEvent
+}
+_resizing = false;
 }
 //showEvent and hideEvent are reimplemented here so that it appears to other classes that the
 //display has been resized when the display is hidden or shown.
 //
 //TODO: Perhaps it would be better to have separate signals for show and hide instead of using
 //the same signal as the one for a content size change
-void TerminalDisplay::showEvent(QShowEvent*)
+void
-{
+TerminalDisplay::showEvent (QShowEvent *)
-emit changedContentSizeSignal(_contentHeight,_contentWidth);
+{
-}
+emit changedContentSizeSignal (_contentHeight, _contentWidth);
-void TerminalDisplay::hideEvent(QHideEvent*)
+}
-{
-emit changedContentSizeSignal(_contentHeight,_contentWidth);
+void
+TerminalDisplay::hideEvent (QHideEvent *)
+{
+emit changedContentSizeSignal (_contentHeight, _contentWidth);
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Scrollbar                                  */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
-void TerminalDisplay::scrollBarPositionChanged(int)
+void
-{
+TerminalDisplay::scrollBarPositionChanged (int)
-if ( !_screenWindow )
+{
-return;
+if (!_screenWindow)
+return;
-_screenWindow->scrollTo( _scrollBar->value() );
+_screenWindow->scrollTo (_scrollBar->value ());
-// if the thumb has been moved to the bottom of the _scrollBar then set
-// the display to automatically track new output,
+// if the thumb has been moved to the bottom of the _scrollBar then set
-// that is, scroll down automatically
+// the display to automatically track new output,
-// to how new _lines as they are added
+// that is, scroll down automatically
-const bool atEndOfOutput = (_scrollBar->value() == _scrollBar->maximum());
+// to how new _lines as they are added
-_screenWindow->setTrackOutput( atEndOfOutput );
+const bool atEndOfOutput = (_scrollBar->value () == _scrollBar->maximum ());
+_screenWindow->setTrackOutput (atEndOfOutput);
-updateImage();
-}
+updateImage ();
+}
-void TerminalDisplay::setScroll(int cursor, int slines)
-{
+void
-// update _scrollBar if the range or value has changed,
+TerminalDisplay::setScroll (int cursor, int slines)
-// otherwise return
+{
-//
+// update _scrollBar if the range or value has changed,
-// setting the range or value of a _scrollBar will always trigger
+// otherwise return
-// a repaint, so it should be avoided if it is not necessary
+//
-if ( _scrollBar->minimum() == 0                 &&
+// setting the range or value of a _scrollBar will always trigger
-_scrollBar->maximum() == (slines - _lines) &&
+// a repaint, so it should be avoided if it is not necessary
-_scrollBar->value()   == cursor )
+if (_scrollBar->minimum () == 0 &&
-{
+_scrollBar->maximum () == (slines - _lines) &&
-return;
+_scrollBar->value () == cursor)
-}
+{
+return;
-disconnect(_scrollBar, SIGNAL(valueChanged(int)), this, SLOT(scrollBarPositionChanged(int)));
+}
-_scrollBar->setRange(0,slines - _lines);
-_scrollBar->setSingleStep(1);
+disconnect (_scrollBar, SIGNAL (valueChanged (int)), this,
-_scrollBar->setPageStep(_lines);
+	      SLOT (scrollBarPositionChanged (int)));
-_scrollBar->setValue(cursor);
+_scrollBar->setRange (0, slines - _lines);
-connect(_scrollBar, SIGNAL(valueChanged(int)), this, SLOT(scrollBarPositionChanged(int)));
+_scrollBar->setSingleStep (1);
-}
+_scrollBar->setPageStep (_lines);
+_scrollBar->setValue (cursor);
-void TerminalDisplay::setScrollBarPosition(ScrollBarPosition position)
+connect (_scrollBar, SIGNAL (valueChanged (int)), this,
-{
+	   SLOT (scrollBarPositionChanged (int)));
-if (_scrollbarLocation == position)
+}
-return;
+void
-if ( position == NoScrollBar )
+TerminalDisplay::setScrollBarPosition (ScrollBarPosition position)
-_scrollBar->hide();
+{
-else
+if (_scrollbarLocation == position)
-_scrollBar->show();
+return;
-_topMargin = _leftMargin = 1;
+if (position == NoScrollBar)
-_scrollbarLocation = position;
+_scrollBar->hide ();
+else
-propagateSize();
+_scrollBar->show ();
-update();
-}
+_topMargin = _leftMargin = 1;
+_scrollbarLocation = position;
-void TerminalDisplay::mousePressEvent(QMouseEvent* ev)
-{
+propagateSize ();
-if ( _possibleTripleClick && (ev->button()==Qt::LeftButton) ) {
+update ();
-mouseTripleClickEvent(ev);
+}
-return;
-}
+void
+TerminalDisplay::mousePressEvent (QMouseEvent * ev)
-if ( !contentsRect().contains(ev->pos()) ) return;
+{
+if (_possibleTripleClick && (ev->button () == Qt::LeftButton))
-if ( !_screenWindow ) return;
+{
+mouseTripleClickEvent (ev);
-int charLine;
+return;
-int charColumn;
+}
-getCharacterPosition(ev->pos(),charLine,charColumn);
-QPoint pos = QPoint(charColumn,charLine);
+if (!contentsRect ().contains (ev->pos ()))
+return;
-if ( ev->button() == Qt::LeftButton)
-{
+if (!_screenWindow)
-_lineSelectionMode = false;
+return;
-_wordSelectionMode = false;
+int charLine;
-emit isBusySelecting(true); // Keep it steady...
+int charColumn;
-// Drag only when the Control key is hold
+getCharacterPosition (ev->pos (), charLine, charColumn);
-bool selected = false;
+QPoint pos = QPoint (charColumn, charLine);
-// The receiver of the testIsSelected() signal will adjust
+if (ev->button () == Qt::LeftButton)
-// 'selected' accordingly.
+{
-//emit testIsSelected(pos.x(), pos.y(), selected);
+_lineSelectionMode = false;
+_wordSelectionMode = false;
-selected =  _screenWindow->isSelected(pos.x(),pos.y());
+emit isBusySelecting (true);	// Keep it steady...
-if ((!_ctrlDrag || ev->modifiers() & Qt::ControlModifier) && selected ) {
+// Drag only when the Control key is hold
-// The user clicked inside selected text
+bool selected = false;
-dragInfo.state = diPending;
-dragInfo.start = ev->pos();
+// The receiver of the testIsSelected() signal will adjust
-}
+// 'selected' accordingly.
-else {
+//emit testIsSelected(pos.x(), pos.y(), selected);
-// No reason to ever start a drag event
-dragInfo.state = diNone;
+selected = _screenWindow->isSelected (pos.x (), pos.y ());
-_preserveLineBreaks = !( ( ev->modifiers() & Qt::ControlModifier ) && !(ev->modifiers() & Qt::AltModifier) );
+if ((!_ctrlDrag || ev->modifiers () & Qt::ControlModifier) && selected)
-_columnSelectionMode = (ev->modifiers() & Qt::AltModifier) && (ev->modifiers() & Qt::ControlModifier);
+	{
+	  // The user clicked inside selected text
-if (_mouseMarks || (ev->modifiers() & Qt::ShiftModifier))
+	  dragInfo.state = diPending;
-{
+	  dragInfo.start = ev->pos ();
-_screenWindow->clearSelection();
+	}
+else
-//emit clearSelectionSignal();
+	{
-pos.ry() += _scrollBar->value();
+	  // No reason to ever start a drag event
-_iPntSel = _pntSel = pos;
+	  dragInfo.state = diNone;
-_actSel = 1; // left mouse button pressed but nothing selected yet.
+	  _preserveLineBreaks = !((ev->modifiers () & Qt::ControlModifier)
-}
+				  && !(ev->modifiers () & Qt::AltModifier));
-else
+	  _columnSelectionMode = (ev->modifiers () & Qt::AltModifier)
-{
+	    && (ev->modifiers () & Qt::ControlModifier);
-emit mouseSignal( 0, charColumn + 1, charLine + 1 +_scrollBar->value() -_scrollBar->maximum() , 0);
-}
+	  if (_mouseMarks || (ev->modifiers () & Qt::ShiftModifier))
-}
+	    {
-}
+	      _screenWindow->clearSelection ();
-else if ( ev->button() == Qt::MidButton )
-{
+	      //emit clearSelectionSignal();
-if ( _mouseMarks || (!_mouseMarks && (ev->modifiers() & Qt::ShiftModifier)) )
+	      pos.ry () += _scrollBar->value ();
-emitSelection(true,ev->modifiers() & Qt::ControlModifier);
+	      _iPntSel = _pntSel = pos;
-else
+	      _actSel = 1;	// left mouse button pressed but nothing selected yet.
-emit mouseSignal( 1, charColumn +1, charLine +1 +_scrollBar->value() -_scrollBar->maximum() , 0);
-}
+	    }
-else if ( ev->button() == Qt::RightButton )
+	  else
-{
+	    {
-if (_mouseMarks || (ev->modifiers() & Qt::ShiftModifier))
+	      emit mouseSignal (0, charColumn + 1,
-emit configureRequest(ev->pos());
+				charLine + 1 + _scrollBar->value () -
-else
+				_scrollBar->maximum (), 0);
-emit mouseSignal( 2, charColumn +1, charLine +1 +_scrollBar->value() -_scrollBar->maximum() , 0);
+	    }
-}
+	}
 }
+else if (ev->button () == Qt::MidButton)
-QList<QAction*> TerminalDisplay::filterActions(const QPoint& position)
+{
-{
+if (_mouseMarks
-int charLine, charColumn;
+	  || (!_mouseMarks && (ev->modifiers () & Qt::ShiftModifier)))
-getCharacterPosition(position,charLine,charColumn);
+	emitSelection (true, ev->modifiers () & Qt::ControlModifier);
+else
-Filter::HotSpot* spot = _filterChain->hotSpotAt(charLine,charColumn);
+	emit mouseSignal (1, charColumn + 1,
+			  charLine + 1 + _scrollBar->value () -
-return spot ? spot->actions() : QList<QAction*>();
+			  _scrollBar->maximum (), 0);
 }
+else if (ev->button () == Qt::RightButton)
-void TerminalDisplay::mouseMoveEvent(QMouseEvent* ev)
+{
-{
+if (_mouseMarks || (ev->modifiers () & Qt::ShiftModifier))
-int charLine = 0;
+	emit configureRequest (ev->pos ());
-int charColumn = 0;
+else
-int scrollBarWidth = (_scrollbarLocation == ScrollBarLeft) ? _scrollBar->width() : 0;
+emit mouseSignal (2, charColumn + 1,
+			charLine + 1 + _scrollBar->value () -
-getCharacterPosition(ev->pos(),charLine,charColumn);
+			_scrollBar->maximum (), 0);
+}
-// handle filters
+}
-// change link hot-spot appearance on mouse-over
-Filter::HotSpot* spot = _filterChain->hotSpotAt(charLine,charColumn);
+QList < QAction * >TerminalDisplay::filterActions (const QPoint & position)
-if ( spot && spot->type() == Filter::HotSpot::Link)
+{
-{
+int
-QRegion previousHotspotArea = _mouseOverHotspotArea;
+charLine,
-_mouseOverHotspotArea = QRegion();
+charColumn;
-QRect r;
+getCharacterPosition (position, charLine, charColumn);
-if (spot->startLine()==spot->endLine()) {
-r.setCoords( spot->startColumn()*_fontWidth + scrollBarWidth,
+Filter::HotSpot * spot = _filterChain->hotSpotAt (charLine, charColumn);
-spot->startLine()*_fontHeight,
-spot->endColumn()*_fontWidth + scrollBarWidth,
+return spot ? spot->actions () : QList < QAction * >();
-(spot->endLine()+1)*_fontHeight - 1 );
+}
-_mouseOverHotspotArea |= r;
-} else {
+void
-r.setCoords( spot->startColumn()*_fontWidth + scrollBarWidth,
+TerminalDisplay::mouseMoveEvent (QMouseEvent * ev)
-spot->startLine()*_fontHeight,
+{
-_columns*_fontWidth - 1 + scrollBarWidth,
+int charLine = 0;
-(spot->startLine()+1)*_fontHeight );
+int charColumn = 0;
-_mouseOverHotspotArea |= r;
+int scrollBarWidth =
-for ( int line = spot->startLine()+1 ; line < spot->endLine() ; line++ ) {
+(_scrollbarLocation == ScrollBarLeft) ? _scrollBar->width () : 0;
-r.setCoords( 0*_fontWidth + scrollBarWidth,
-line*_fontHeight,
+getCharacterPosition (ev->pos (), charLine, charColumn);
-_columns*_fontWidth + scrollBarWidth,
-(line+1)*_fontHeight );
+// handle filters
-_mouseOverHotspotArea |= r;
+// change link hot-spot appearance on mouse-over
-}
+Filter::HotSpot * spot = _filterChain->hotSpotAt (charLine, charColumn);
-r.setCoords( 0*_fontWidth + scrollBarWidth,
+if (spot && spot->type () == Filter::HotSpot::Link)
-spot->endLine()*_fontHeight,
+{
-spot->endColumn()*_fontWidth + scrollBarWidth,
+QRegion previousHotspotArea = _mouseOverHotspotArea;
-(spot->endLine()+1)*_fontHeight );
+_mouseOverHotspotArea = QRegion ();
-_mouseOverHotspotArea |= r;
+QRect r;
-}
+if (spot->startLine () == spot->endLine ())
-// display tooltips when mousing over links
+	{
-// TODO: Extend this to work with filter types other than links
+	  r.setCoords (spot->startColumn () * _fontWidth + scrollBarWidth,
-const QString& tooltip = spot->tooltip();
+		       spot->startLine () * _fontHeight,
-if ( !tooltip.isEmpty() )
+		       spot->endColumn () * _fontWidth + scrollBarWidth,
-{
+		       (spot->endLine () + 1) * _fontHeight - 1);
-QToolTip::showText( mapToGlobal(ev->pos()) , tooltip , this , _mouseOverHotspotArea.boundingRect() );
+	  _mouseOverHotspotArea |= r;
-}
+	}
+else
-update( _mouseOverHotspotArea | previousHotspotArea );
+	{
-}
+	  r.setCoords (spot->startColumn () * _fontWidth + scrollBarWidth,
-else if ( !_mouseOverHotspotArea.isEmpty() )
+		       spot->startLine () * _fontHeight,
-{
+		       _columns * _fontWidth - 1 + scrollBarWidth,
-update( _mouseOverHotspotArea );
+		       (spot->startLine () + 1) * _fontHeight);
-// set hotspot area to an invalid rectangle
+	  _mouseOverHotspotArea |= r;
-_mouseOverHotspotArea = QRegion();
+	  for (int line = spot->startLine () + 1; line < spot->endLine ();
-}
+	       line++)
+	    {
-// for auto-hiding the cursor, we need mouseTracking
+	      r.setCoords (0 * _fontWidth + scrollBarWidth,
-if (ev->buttons() == Qt::NoButton ) return;
+			   line * _fontHeight,
+			   _columns * _fontWidth + scrollBarWidth,
-// if the terminal is interested in mouse movements
+			   (line + 1) * _fontHeight);
-// then emit a mouse movement signal, unless the shift
+	      _mouseOverHotspotArea |= r;
-// key is being held down, which overrides this.
+	    }
-if (!_mouseMarks && !(ev->modifiers() & Qt::ShiftModifier))
+	  r.setCoords (0 * _fontWidth + scrollBarWidth,
-{
+		       spot->endLine () * _fontHeight,
-int button = 3;
+		       spot->endColumn () * _fontWidth + scrollBarWidth,
-if (ev->buttons() & Qt::LeftButton)
+		       (spot->endLine () + 1) * _fontHeight);
-button = 0;
+	  _mouseOverHotspotArea |= r;
-if (ev->buttons() & Qt::MidButton)
+	}
-button = 1;
+// display tooltips when mousing over links
-if (ev->buttons() & Qt::RightButton)
+// TODO: Extend this to work with filter types other than links
-button = 2;
+const QString & tooltip = spot->tooltip ();
+if (!tooltip.isEmpty ())
+	{
-emit mouseSignal( button,
+	  QToolTip::showText (mapToGlobal (ev->pos ()), tooltip, this,
-charColumn + 1,
+			      _mouseOverHotspotArea.boundingRect ());
-charLine + 1 +_scrollBar->value() -_scrollBar->maximum(),
+	}
-1 );
+update (_mouseOverHotspotArea | previousHotspotArea);
-return;
+}
-}
+else if (!_mouseOverHotspotArea.isEmpty ())
+{
-if (dragInfo.state == diPending)
+update (_mouseOverHotspotArea);
-{
+// set hotspot area to an invalid rectangle
-// we had a mouse down, but haven't confirmed a drag yet
+_mouseOverHotspotArea = QRegion ();
-// if the mouse has moved sufficiently, we will confirm
+}
-int distance = 10; //KGlobalSettings::dndEventDelay();
+// for auto-hiding the cursor, we need mouseTracking
-if ( ev->x() > dragInfo.start.x() + distance || ev->x() < dragInfo.start.x() - distance ||
+if (ev->buttons () == Qt::NoButton)
-ev->y() > dragInfo.start.y() + distance || ev->y() < dragInfo.start.y() - distance)
+return;
-{
-// we've left the drag square, we can start a real drag operation now
+// if the terminal is interested in mouse movements
-emit isBusySelecting(false); // Ok.. we can breath again.
+// then emit a mouse movement signal, unless the shift
+// key is being held down, which overrides this.
-_screenWindow->clearSelection();
+if (!_mouseMarks && !(ev->modifiers () & Qt::ShiftModifier))
-doDrag();
+{
-}
+int button = 3;
-return;
+if (ev->buttons () & Qt::LeftButton)
-}
+	button = 0;
-else if (dragInfo.state == diDragging)
+if (ev->buttons () & Qt::MidButton)
-{
+	button = 1;
-// this isn't technically needed because mouseMoveEvent is suppressed during
+if (ev->buttons () & Qt::RightButton)
-// Qt drag operations, replaced by dragMoveEvent
+	button = 2;
-return;
-}
+emit mouseSignal (button,
-if (_actSel == 0) return;
+			charColumn + 1,
+			charLine + 1 + _scrollBar->value () -
-// don't extend selection while pasting
+			_scrollBar->maximum (), 1);
-if (ev->buttons() & Qt::MidButton) return;
+return;
-extendSelection( ev->pos() );
+}
-}
+if (dragInfo.state == diPending)
-void TerminalDisplay::extendSelection( const QPoint& position )
+{
-{
+// we had a mouse down, but haven't confirmed a drag yet
-QPoint pos = position;
+// if the mouse has moved sufficiently, we will confirm
-if ( !_screenWindow )
+int distance = 10;	//KGlobalSettings::dndEventDelay();
-return;
+if (ev->x () > dragInfo.start.x () + distance
+	  || ev->x () < dragInfo.start.x () - distance
-//if ( !contentsRect().contains(ev->pos()) ) return;
+	  || ev->y () > dragInfo.start.y () + distance
-QPoint tL  = contentsRect().topLeft();
+	  || ev->y () < dragInfo.start.y () - distance)
-int    tLx = tL.x();
+	{
-int    tLy = tL.y();
+	  // we've left the drag square, we can start a real drag operation now
-int    scroll = _scrollBar->value();
+	  emit isBusySelecting (false);	// Ok.. we can breath again.
-// we're in the process of moving the mouse with the left button pressed
+	  _screenWindow->clearSelection ();
-// the mouse cursor will kept caught within the bounds of the text in
+	  doDrag ();
-// this widget.
+	}
+return;
-int linesBeyondWidget = 0;
+}
+else if (dragInfo.state == diDragging)
-QRect textBounds(tLx + _leftMargin,
+{
-tLy + _topMargin,
+// this isn't technically needed because mouseMoveEvent is suppressed during
-_usedColumns*_fontWidth-1,
+// Qt drag operations, replaced by dragMoveEvent
-_usedLines*_fontHeight-1);
+return;
+}
-// Adjust position within text area bounds.
-QPoint oldpos = pos;
+if (_actSel == 0)
+return;
-pos.setX( qBound(textBounds.left(),pos.x(),textBounds.right()) );
-pos.setY( qBound(textBounds.top(),pos.y(),textBounds.bottom()) );
+// don't extend selection while pasting
+if (ev->buttons () & Qt::MidButton)
-if ( oldpos.y() > textBounds.bottom() )
+return;
-{
-linesBeyondWidget = (oldpos.y()-textBounds.bottom()) / _fontHeight;
+extendSelection (ev->pos ());
-_scrollBar->setValue(_scrollBar->value()+linesBeyondWidget+1); // scrollforward
+}
-}
-if ( oldpos.y() < textBounds.top() )
+void
-{
+TerminalDisplay::extendSelection (const QPoint & position)
-linesBeyondWidget = (textBounds.top()-oldpos.y()) / _fontHeight;
+{
-_scrollBar->setValue(_scrollBar->value()-linesBeyondWidget-1); // history
+QPoint pos = position;
-}
+if (!_screenWindow)
-int charColumn = 0;
+return;
-int charLine = 0;
-getCharacterPosition(pos,charLine,charColumn);
+//if ( !contentsRect().contains(ev->pos()) ) return;
+QPoint tL = contentsRect ().topLeft ();
-QPoint here = QPoint(charColumn,charLine); //QPoint((pos.x()-tLx-_leftMargin+(_fontWidth/2))/_fontWidth,(pos.y()-tLy-_topMargin)/_fontHeight);
+int tLx = tL.x ();
-QPoint ohere;
+int tLy = tL.y ();
-QPoint _iPntSelCorr = _iPntSel;
+int scroll = _scrollBar->value ();
-_iPntSelCorr.ry() -= _scrollBar->value();
-QPoint _pntSelCorr = _pntSel;
+// we're in the process of moving the mouse with the left button pressed
-_pntSelCorr.ry() -= _scrollBar->value();
+// the mouse cursor will kept caught within the bounds of the text in
-bool swapping = false;
+// this widget.
-if ( _wordSelectionMode )
+int linesBeyondWidget = 0;
-{
-// Extend to word boundaries
+QRect textBounds (tLx + _leftMargin,
-int i;
+		    tLy + _topMargin,
-QChar selClass;
+		    _usedColumns * _fontWidth - 1,
+		    _usedLines * _fontHeight - 1);
-bool left_not_right = ( here.y() < _iPntSelCorr.y() ||
-( here.y() == _iPntSelCorr.y() && here.x() < _iPntSelCorr.x() ) );
+// Adjust position within text area bounds.
-bool old_left_not_right = ( _pntSelCorr.y() < _iPntSelCorr.y() ||
+QPoint oldpos = pos;
-( _pntSelCorr.y() == _iPntSelCorr.y() && _pntSelCorr.x() < _iPntSelCorr.x() ) );
-swapping = left_not_right != old_left_not_right;
+pos.setX (qBound (textBounds.left (), pos.x (), textBounds.right ()));
+pos.setY (qBound (textBounds.top (), pos.y (), textBounds.bottom ()));
-// Find left (left_not_right ? from here : from start)
-QPoint left = left_not_right ? here : _iPntSelCorr;
+if (oldpos.y () > textBounds.bottom ())
-i = loc(left.x(),left.y());
+{
-if (i>=0 && i<=_imageSize) {
+linesBeyondWidget = (oldpos.y () - textBounds.bottom ()) / _fontHeight;
-selClass = charClass(_image[i].character);
+_scrollBar->setValue (_scrollBar->value () + linesBeyondWidget + 1);	// scrollforward
-while ( ((left.x()>0) || (left.y()>0 && (_lineProperties[left.y()-1] & LINE_WRAPPED) ))
+}
-&& charClass(_image[i-1].character) == selClass )
+if (oldpos.y () < textBounds.top ())
-{ i--; if (left.x()>0) left.rx()--; else {left.rx()=_usedColumns-1; left.ry()--;} }
+{
-}
+linesBeyondWidget = (textBounds.top () - oldpos.y ()) / _fontHeight;
+_scrollBar->setValue (_scrollBar->value () - linesBeyondWidget - 1);	// history
-// Find left (left_not_right ? from start : from here)
+}
-QPoint right = left_not_right ? _iPntSelCorr : here;
-i = loc(right.x(),right.y());
+int charColumn = 0;
-if (i>=0 && i<=_imageSize) {
+int charLine = 0;
-selClass = charClass(_image[i].character);
+getCharacterPosition (pos, charLine, charColumn);
-while( ((right.x()<_usedColumns-1) || (right.y()<_usedLines-1 && (_lineProperties[right.y()] & LINE_WRAPPED) ))
-&& charClass(_image[i+1].character) == selClass )
+QPoint here = QPoint (charColumn, charLine);	//QPoint((pos.x()-tLx-_leftMargin+(_fontWidth/2))/_fontWidth,(pos.y()-tLy-_topMargin)/_fontHeight);
-{ i++; if (right.x()<_usedColumns-1) right.rx()++; else {right.rx()=0; right.ry()++; } }
+QPoint ohere;
-}
+QPoint _iPntSelCorr = _iPntSel;
+_iPntSelCorr.ry () -= _scrollBar->value ();
-// Pick which is start (ohere) and which is extension (here)
+QPoint _pntSelCorr = _pntSel;
-if ( left_not_right )
+_pntSelCorr.ry () -= _scrollBar->value ();
-{
+bool swapping = false;
-here = left; ohere = right;
-}
+if (_wordSelectionMode)
-else
+{
-{
+// Extend to word boundaries
-here = right; ohere = left;
+int i;
-}
+QChar selClass;
-ohere.rx()++;
-}
+bool left_not_right = (here.y () < _iPntSelCorr.y () ||
+			     (here.y () == _iPntSelCorr.y ()
-if ( _lineSelectionMode )
+			      && here.x () < _iPntSelCorr.x ()));
-{
+bool old_left_not_right = (_pntSelCorr.y () < _iPntSelCorr.y ()
-// Extend to complete line
+				 || (_pntSelCorr.y () == _iPntSelCorr.y ()
-bool above_not_below = ( here.y() < _iPntSelCorr.y() );
+				     && _pntSelCorr.x () <
+				     _iPntSelCorr.x ()));
-QPoint above = above_not_below ? here : _iPntSelCorr;
+swapping = left_not_right != old_left_not_right;
-QPoint below = above_not_below ? _iPntSelCorr : here;
+// Find left (left_not_right ? from here : from start)
-while (above.y()>0 && (_lineProperties[above.y()-1] & LINE_WRAPPED) )
+QPoint left = left_not_right ? here : _iPntSelCorr;
-above.ry()--;
+i = loc (left.x (), left.y ());
-while (below.y()<_usedLines-1 && (_lineProperties[below.y()] & LINE_WRAPPED) )
+if (i >= 0 && i <= _imageSize)
-below.ry()++;
+	{
+	  selClass = charClass (_image[i].character);
-above.setX(0);
+	  while (((left.x () > 0)
-below.setX(_usedColumns-1);
+		  || (left.y () > 0
+		      && (_lineProperties[left.y () - 1] & LINE_WRAPPED)))
-// Pick which is start (ohere) and which is extension (here)
+		 && charClass (_image[i - 1].character) == selClass)
-if ( above_not_below )
+	    {
-{
+	      i--;
-here = above; ohere = below;
+	      if (left.x () > 0)
-}
+		left.rx ()--;
-else
+	      else
-{
+		{
-here = below; ohere = above;
+		  left.rx () = _usedColumns - 1;
-}
+		  left.ry ()--;
+		}
-QPoint newSelBegin = QPoint( ohere.x(), ohere.y() );
+	    }
-swapping = !(_tripleSelBegin==newSelBegin);
+	}
-_tripleSelBegin = newSelBegin;
+// Find left (left_not_right ? from start : from here)
-ohere.rx()++;
+QPoint right = left_not_right ? _iPntSelCorr : here;
-}
+i = loc (right.x (), right.y ());
+if (i >= 0 && i <= _imageSize)
-int offset = 0;
+	{
-if ( !_wordSelectionMode && !_lineSelectionMode )
+	  selClass = charClass (_image[i].character);
-{
+	  while (((right.x () < _usedColumns - 1)
-int i;
+		  || (right.y () < _usedLines - 1
-QChar selClass;
+		      && (_lineProperties[right.y ()] & LINE_WRAPPED)))
+		 && charClass (_image[i + 1].character) == selClass)
-bool left_not_right = ( here.y() < _iPntSelCorr.y() ||
+	    {
-( here.y() == _iPntSelCorr.y() && here.x() < _iPntSelCorr.x() ) );
+	      i++;
-bool old_left_not_right = ( _pntSelCorr.y() < _iPntSelCorr.y() ||
+	      if (right.x () < _usedColumns - 1)
-( _pntSelCorr.y() == _iPntSelCorr.y() && _pntSelCorr.x() < _iPntSelCorr.x() ) );
+		right.rx ()++;
-swapping = left_not_right != old_left_not_right;
+	      else
+		{
-// Find left (left_not_right ? from here : from start)
+		  right.rx () = 0;
-QPoint left = left_not_right ? here : _iPntSelCorr;
+		  right.ry ()++;
+		}
-// Find left (left_not_right ? from start : from here)
+	    }
-QPoint right = left_not_right ? _iPntSelCorr : here;
+	}
-if ( right.x() > 0 && !_columnSelectionMode )
-{
+// Pick which is start (ohere) and which is extension (here)
-i = loc(right.x(),right.y());
+if (left_not_right)
-if (i>=0 && i<=_imageSize) {
+	{
-selClass = charClass(_image[i-1].character);
+	  here = left;
-/* if (selClass == ' ')
+	  ohere = right;
-{
+	}
-while ( right.x() < _usedColumns-1 && charClass(_image[i+1].character) == selClass && (right.y()<_usedLines-1) &&
+else
-!(_lineProperties[right.y()] & LINE_WRAPPED))
+	{
-{ i++; right.rx()++; }
+	  here = right;
-if (right.x() < _usedColumns-1)
+	  ohere = left;
-right = left_not_right ? _iPntSelCorr : here;
+	}
-else
+ohere.rx ()++;
-right.rx()++;  // will be balanced later because of offset=-1;
+}
-}*/
-}
+if (_lineSelectionMode)
-}
+{
+// Extend to complete line
-// Pick which is start (ohere) and which is extension (here)
+bool above_not_below = (here.y () < _iPntSelCorr.y ());
-if ( left_not_right )
-{
+QPoint above = above_not_below ? here : _iPntSelCorr;
-here = left; ohere = right; offset = 0;
+QPoint below = above_not_below ? _iPntSelCorr : here;
-}
-else
+while (above.y () > 0
-{
+	     && (_lineProperties[above.y () - 1] & LINE_WRAPPED))
-here = right; ohere = left; offset = -1;
+	above.ry ()--;
-}
+while (below.y () < _usedLines - 1
-}
+	     && (_lineProperties[below.y ()] & LINE_WRAPPED))
+	below.ry ()++;
-if ((here == _pntSelCorr) && (scroll == _scrollBar->value())) return; // not moved
+above.setX (0);
-if (here == ohere) return; // It's not left, it's not right.
+below.setX (_usedColumns - 1);
-if ( _actSel < 2 || swapping )
+// Pick which is start (ohere) and which is extension (here)
-{
+if (above_not_below)
-if ( _columnSelectionMode && !_lineSelectionMode && !_wordSelectionMode )
+	{
-{
+	  here = above;
-_screenWindow->setSelectionStart( ohere.x() , ohere.y() , true );
+	  ohere = below;
-}
+	}
 else
-{
+	{
-_screenWindow->setSelectionStart( ohere.x()-1-offset , ohere.y() , false );
+	  here = below;
-}
+	  ohere = above;
+	}
-}
+QPoint newSelBegin = QPoint (ohere.x (), ohere.y ());
-_actSel = 2; // within selection
+swapping = !(_tripleSelBegin == newSelBegin);
-_pntSel = here;
+_tripleSelBegin = newSelBegin;
-_pntSel.ry() += _scrollBar->value();
+ohere.rx ()++;
-if ( _columnSelectionMode && !_lineSelectionMode && !_wordSelectionMode )
+}
-{
-_screenWindow->setSelectionEnd( here.x() , here.y() );
+int offset = 0;
-}
+if (!_wordSelectionMode && !_lineSelectionMode)
-else
+{
-{
+int i;
-_screenWindow->setSelectionEnd( here.x()+offset , here.y() );
+QChar selClass;
-}
+bool left_not_right = (here.y () < _iPntSelCorr.y () ||
-}
+			     (here.y () == _iPntSelCorr.y ()
+			      && here.x () < _iPntSelCorr.x ()));
-void TerminalDisplay::mouseReleaseEvent(QMouseEvent* ev)
+bool old_left_not_right = (_pntSelCorr.y () < _iPntSelCorr.y ()
-{
+				 || (_pntSelCorr.y () == _iPntSelCorr.y ()
-if ( !_screenWindow )
+				     && _pntSelCorr.x () <
-return;
+				     _iPntSelCorr.x ()));
+swapping = left_not_right != old_left_not_right;
-int charLine;
-int charColumn;
+// Find left (left_not_right ? from here : from start)
-getCharacterPosition(ev->pos(),charLine,charColumn);
+QPoint left = left_not_right ? here : _iPntSelCorr;
-if ( ev->button() == Qt::LeftButton)
+// Find left (left_not_right ? from start : from here)
-{
+QPoint right = left_not_right ? _iPntSelCorr : here;
-emit isBusySelecting(false);
+if (right.x () > 0 && !_columnSelectionMode)
-if(dragInfo.state == diPending)
+	{
-{
+	  i = loc (right.x (), right.y ());
-// We had a drag event pending but never confirmed.  Kill selection
+	  if (i >= 0 && i <= _imageSize)
-_screenWindow->clearSelection();
+	    {
-//emit clearSelectionSignal();
+	      selClass = charClass (_image[i - 1].character);
-}
+	      /* if (selClass == ' ')
-else
+	         {
-{
+	         while ( right.x() < _usedColumns-1 && charClass(_image[i+1].character) == selClass && (right.y()<_usedLines-1) &&
-if ( _actSel > 1 )
+	         !(_lineProperties[right.y()] & LINE_WRAPPED))
-{
+	         { i++; right.rx()++; }
-setSelection(  _screenWindow->selectedText(_preserveLineBreaks)  );
+	         if (right.x() < _usedColumns-1)
-}
+	         right = left_not_right ? _iPntSelCorr : here;
+	         else
-_actSel = 0;
+	         right.rx()++;  // will be balanced later because of offset=-1;
+	         } */
-//FIXME: emits a release event even if the mouse is
+	    }
-//       outside the range. The procedure used in `mouseMoveEvent'
+	}
-//       applies here, too.
+// Pick which is start (ohere) and which is extension (here)
-if (!_mouseMarks && !(ev->modifiers() & Qt::ShiftModifier))
+if (left_not_right)
-emit mouseSignal( 3, // release
+	{
-charColumn + 1,
+	  here = left;
-charLine + 1 +_scrollBar->value() -_scrollBar->maximum() , 0);
+	  ohere = right;
-}
+	  offset = 0;
-dragInfo.state = diNone;
+	}
-}
+else
+	{
+	  here = right;
-if ( !_mouseMarks &&
+	  ohere = left;
-((ev->button() == Qt::RightButton && !(ev->modifiers() & Qt::ShiftModifier))
+	  offset = -1;
-|| ev->button() == Qt::MidButton) )
+	}
-{
+}
-emit mouseSignal( 3,
-charColumn + 1,
+if ((here == _pntSelCorr) && (scroll == _scrollBar->value ()))
-charLine + 1 +_scrollBar->value() -_scrollBar->maximum() ,
+return;			// not moved
-0);
-}
+if (here == ohere)
-}
+return;			// It's not left, it's not right.
-void TerminalDisplay::getCharacterPosition(const QPoint& widgetPoint,int& line,int& column) const
+if (_actSel < 2 || swapping)
 {
-column = (widgetPoint.x() + _fontWidth/2 -contentsRect().left()-_leftMargin) / _fontWidth;
+if (_columnSelectionMode && !_lineSelectionMode && !_wordSelectionMode)
-line = (widgetPoint.y()-contentsRect().top()-_topMargin) / _fontHeight;
+	{
+	  _screenWindow->setSelectionStart (ohere.x (), ohere.y (), true);
-if ( line < 0 )
+	}
-line = 0;
+else
-if ( column < 0 )
+	{
-column = 0;
+	  _screenWindow->setSelectionStart (ohere.x () - 1 - offset,
+					    ohere.y (), false);
-if ( line >= _usedLines )
+	}
-line = _usedLines-1;
+}
-// the column value returned can be equal to _usedColumns, which
-// is the position just after the last character displayed in a line.
+_actSel = 2;			// within selection
-//
+_pntSel = here;
-// this is required so that the user can select characters in the right-most
+_pntSel.ry () += _scrollBar->value ();
-// column (or left-most for right-to-left input)
-if ( column > _usedColumns )
+if (_columnSelectionMode && !_lineSelectionMode && !_wordSelectionMode)
-column = _usedColumns;
+{
-}
+_screenWindow->setSelectionEnd (here.x (), here.y ());
+}
-void TerminalDisplay::updateLineProperties()
+else
 {
-if ( !_screenWindow )
+_screenWindow->setSelectionEnd (here.x () + offset, here.y ());
-return;
+}
-_lineProperties = _screenWindow->getLineProperties();
+}
-}
+void
-void TerminalDisplay::mouseDoubleClickEvent(QMouseEvent* ev)
+TerminalDisplay::mouseReleaseEvent (QMouseEvent * ev)
 {
-if ( ev->button() != Qt::LeftButton) return;
+if (!_screenWindow)
-if ( !_screenWindow ) return;
+return;
-int charLine = 0;
+int charLine;
-int charColumn = 0;
+int charColumn;
+getCharacterPosition (ev->pos (), charLine, charColumn);
-getCharacterPosition(ev->pos(),charLine,charColumn);
+if (ev->button () == Qt::LeftButton)
-QPoint pos(charColumn,charLine);
+{
+emit isBusySelecting (false);
-// pass on double click as two clicks.
+if (dragInfo.state == diPending)
-if (!_mouseMarks && !(ev->modifiers() & Qt::ShiftModifier))
+	{
-{
+	  // We had a drag event pending but never confirmed.  Kill selection
-// Send just _ONE_ click event, since the first click of the double click
+	  _screenWindow->clearSelection ();
-// was already sent by the click handler
+	  //emit clearSelectionSignal();
-emit mouseSignal( 0,
+	}
-pos.x()+1,
+else
-pos.y()+1 +_scrollBar->value() -_scrollBar->maximum(),
+	{
-0 ); // left button
+	  if (_actSel > 1)
-return;
+	    {
-}
+	      setSelection (_screenWindow->
+			    selectedText (_preserveLineBreaks));
-_screenWindow->clearSelection();
+	    }
-QPoint bgnSel = pos;
-QPoint endSel = pos;
+	  _actSel = 0;
-int i = loc(bgnSel.x(),bgnSel.y());
-_iPntSel = bgnSel;
+	  //FIXME: emits a release event even if the mouse is
-_iPntSel.ry() += _scrollBar->value();
+	  //       outside the range. The procedure used in `mouseMoveEvent'
+	  //       applies here, too.
-_wordSelectionMode = true;
+	  if (!_mouseMarks && !(ev->modifiers () & Qt::ShiftModifier))
-// find word boundaries...
+	    emit mouseSignal (3,	// release
-QChar selClass = charClass(_image[i].character);
+			      charColumn + 1,
-{
+			      charLine + 1 + _scrollBar->value () -
-// find the start of the word
+			      _scrollBar->maximum (), 0);
-int x = bgnSel.x();
+	}
-while ( ((x>0) || (bgnSel.y()>0 && (_lineProperties[bgnSel.y()-1] & LINE_WRAPPED) ))
+dragInfo.state = diNone;
-&& charClass(_image[i-1].character) == selClass )
+}
-{
-i--;
-if (x>0)
+if (!_mouseMarks &&
-x--;
+((ev->button () == Qt::RightButton
-else
+	&& !(ev->modifiers () & Qt::ShiftModifier))
-{
+|| ev->button () == Qt::MidButton))
-x=_usedColumns-1;
+{
-bgnSel.ry()--;
+emit mouseSignal (3,
-}
+			charColumn + 1,
-}
+			charLine + 1 + _scrollBar->value () -
+			_scrollBar->maximum (), 0);
-bgnSel.setX(x);
+}
-_screenWindow->setSelectionStart( bgnSel.x() , bgnSel.y() , false );
+}
-// find the end of the word
+void
-i = loc( endSel.x(), endSel.y() );
+TerminalDisplay::getCharacterPosition (const QPoint & widgetPoint, int &line,
-x = endSel.x();
+				       int &column) const
-while( ((x<_usedColumns-1) || (endSel.y()<_usedLines-1 && (_lineProperties[endSel.y()] & LINE_WRAPPED) ))
+{
-&& charClass(_image[i+1].character) == selClass )
+column =
-{
+(widgetPoint.x () + _fontWidth / 2 - contentsRect ().left () -
-i++;
+_leftMargin) / _fontWidth;
-if (x<_usedColumns-1)
+line =
-x++;
+(widgetPoint.y () - contentsRect ().top () - _topMargin) / _fontHeight;
-else
-{
+if (line < 0)
-x=0;
+line = 0;
-endSel.ry()++;
+if (column < 0)
-}
+column = 0;
-}
+if (line >= _usedLines)
-endSel.setX(x);
+line = _usedLines - 1;
-// In word selection mode don't select @ (64) if at end of word.
+// the column value returned can be equal to _usedColumns, which
-if ( ( QChar( _image[i].character ) == '@' ) && ( ( endSel.x() - bgnSel.x() ) > 0 ) )
+// is the position just after the last character displayed in a line.
-endSel.setX( x - 1 );
+//
+// this is required so that the user can select characters in the right-most
+// column (or left-most for right-to-left input)
-_actSel = 2; // within selection
+if (column > _usedColumns)
+column = _usedColumns;
-_screenWindow->setSelectionEnd( endSel.x() , endSel.y() );
+}
-setSelection( _screenWindow->selectedText(_preserveLineBreaks) );
+void
-}
+TerminalDisplay::updateLineProperties ()
+{
-_possibleTripleClick=true;
+if (!_screenWindow)
+return;
-QTimer::singleShot(QApplication::doubleClickInterval(),this,
-SLOT(tripleClickTimeout()));
+_lineProperties = _screenWindow->getLineProperties ();
 }
-void TerminalDisplay::wheelEvent( QWheelEvent* ev )
+void
-{
+TerminalDisplay::mouseDoubleClickEvent (QMouseEvent * ev)
-if (ev->orientation() != Qt::Vertical)
+{
-return;
+if (ev->button () != Qt::LeftButton)
+return;
-// if the terminal program is not interested mouse events
+if (!_screenWindow)
-// then send the event to the scrollbar if the slider has room to move
+return;
-// or otherwise send simulated up / down key presses to the terminal program
-// for the benefit of programs such as 'less'
+int charLine = 0;
-if ( _mouseMarks )
+int charColumn = 0;
-{
-bool canScroll = _scrollBar->maximum() > 0;
+getCharacterPosition (ev->pos (), charLine, charColumn);
-if (canScroll)
-_scrollBar->event(ev);
+QPoint pos (charColumn, charLine);
-else
-{
+// pass on double click as two clicks.
-// assume that each Up / Down key event will cause the terminal application
+if (!_mouseMarks && !(ev->modifiers () & Qt::ShiftModifier))
-// to scroll by one line.
+{
-//
+// Send just _ONE_ click event, since the first click of the double click
-// to get a reasonable scrolling speed, scroll by one line for every 5 degrees
+// was already sent by the click handler
-// of mouse wheel rotation.  Mouse wheels typically move in steps of 15 degrees,
+emit mouseSignal (0, pos.x () + 1, pos.y () + 1 + _scrollBar->value () - _scrollBar->maximum (), 0);	// left button
-// giving a scroll of 3 lines
+return;
-int key = ev->delta() > 0 ? Qt::Key_Up : Qt::Key_Down;
+}
-// QWheelEvent::delta() gives rotation in eighths of a degree
+_screenWindow->clearSelection ();
-int wheelDegrees = ev->delta() / 8;
+QPoint bgnSel = pos;
-int linesToScroll = abs(wheelDegrees) / 5;
+QPoint endSel = pos;
+int i = loc (bgnSel.x (), bgnSel.y ());
-QKeyEvent keyScrollEvent(QEvent::KeyPress,key,Qt::NoModifier);
+_iPntSel = bgnSel;
+_iPntSel.ry () += _scrollBar->value ();
-for (int i=0;i<linesToScroll;i++)
-emit keyPressedSignal(&keyScrollEvent);
+_wordSelectionMode = true;
-}
-}
+// find word boundaries...
-else
+QChar selClass = charClass (_image[i].character);
 {
-// terminal program wants notification of mouse activity
+// find the start of the word
+int x = bgnSel.x ();
-int charLine;
+while (((x > 0)
-int charColumn;
+	    || (bgnSel.y () > 0
-getCharacterPosition( ev->pos() , charLine , charColumn );
+		&& (_lineProperties[bgnSel.y () - 1] & LINE_WRAPPED)))
+	   && charClass (_image[i - 1].character) == selClass)
-emit mouseSignal( ev->delta() > 0 ? 4 : 5,
+{
-charColumn + 1,
+	i--;
-charLine + 1 +_scrollBar->value() -_scrollBar->maximum() ,
+	if (x > 0)
-0);
+	  x--;
-}
+	else
-}
+	  {
+	    x = _usedColumns - 1;
-void TerminalDisplay::tripleClickTimeout()
+	    bgnSel.ry ()--;
-{
+	  }
-_possibleTripleClick=false;
+}
-}
+bgnSel.setX (x);
-void TerminalDisplay::mouseTripleClickEvent(QMouseEvent* ev)
+_screenWindow->setSelectionStart (bgnSel.x (), bgnSel.y (), false);
-{
-if ( !_screenWindow ) return;
+// find the end of the word
+i = loc (endSel.x (), endSel.y ());
-int charLine;
+x = endSel.x ();
-int charColumn;
+while (((x < _usedColumns - 1)
-getCharacterPosition(ev->pos(),charLine,charColumn);
+	    || (endSel.y () < _usedLines - 1
-_iPntSel = QPoint(charColumn,charLine);
+		&& (_lineProperties[endSel.y ()] & LINE_WRAPPED)))
+	   && charClass (_image[i + 1].character) == selClass)
-_screenWindow->clearSelection();
+{
+	i++;
-_lineSelectionMode = true;
+	if (x < _usedColumns - 1)
-_wordSelectionMode = false;
+	  x++;
+	else
-_actSel = 2; // within selection
+	  {
-emit isBusySelecting(true); // Keep it steady...
+	    x = 0;
+	    endSel.ry ()++;
-while (_iPntSel.y()>0 && (_lineProperties[_iPntSel.y()-1] & LINE_WRAPPED) )
+	  }
-_iPntSel.ry()--;
+}
-if (_tripleClickMode == SelectForwardsFromCursor) {
+endSel.setX (x);
-// find word boundary start
-int i = loc(_iPntSel.x(),_iPntSel.y());
+// In word selection mode don't select @ (64) if at end of word.
-QChar selClass = charClass(_image[i].character);
+if ((QChar (_image[i].character) == '@')
-int x = _iPntSel.x();
+	&& ((endSel.x () - bgnSel.x ()) > 0))
+endSel.setX (x - 1);
-while ( ((x>0) ||
-(_iPntSel.y()>0 && (_lineProperties[_iPntSel.y()-1] & LINE_WRAPPED) )
-)
+_actSel = 2;		// within selection
-&& charClass(_image[i-1].character) == selClass )
-{
+_screenWindow->setSelectionEnd (endSel.x (), endSel.y ());
-i--;
-if (x>0)
+setSelection (_screenWindow->selectedText (_preserveLineBreaks));
-x--;
+}
-else
-{
+_possibleTripleClick = true;
-x=_columns-1;
-_iPntSel.ry()--;
+QTimer::singleShot (QApplication::doubleClickInterval (), this,
-}
+		      SLOT (tripleClickTimeout ()));
 }
-_screenWindow->setSelectionStart( x , _iPntSel.y() , false );
+void
-_tripleSelBegin = QPoint( x, _iPntSel.y() );
+TerminalDisplay::wheelEvent (QWheelEvent * ev)
-}
+{
-else if (_tripleClickMode == SelectWholeLine) {
+if (ev->orientation () != Qt::Vertical)
-_screenWindow->setSelectionStart( 0 , _iPntSel.y() , false );
+return;
-_tripleSelBegin = QPoint( 0, _iPntSel.y() );
-}
+// if the terminal program is not interested mouse events
+// then send the event to the scrollbar if the slider has room to move
-while (_iPntSel.y()<_lines-1 && (_lineProperties[_iPntSel.y()] & LINE_WRAPPED) )
+// or otherwise send simulated up / down key presses to the terminal program
-_iPntSel.ry()++;
+// for the benefit of programs such as 'less'
+if (_mouseMarks)
-_screenWindow->setSelectionEnd( _columns - 1 , _iPntSel.y() );
+{
+bool canScroll = _scrollBar->maximum () > 0;
-setSelection(_screenWindow->selectedText(_preserveLineBreaks));
+if (canScroll)
+	_scrollBar->event (ev);
-_iPntSel.ry() += _scrollBar->value();
+else
-}
+	{
+	  // assume that each Up / Down key event will cause the terminal application
+	  // to scroll by one line.
-bool TerminalDisplay::focusNextPrevChild( bool next )
+	  //
-{
+	  // to get a reasonable scrolling speed, scroll by one line for every 5 degrees
-if (next)
+	  // of mouse wheel rotation.  Mouse wheels typically move in steps of 15 degrees,
-return false; // This disables changing the active part in konqueror
+	  // giving a scroll of 3 lines
-// when pressing Tab
+	  int key = ev->delta () > 0 ? Qt::Key_Up : Qt::Key_Down;
-return QWidget::focusNextPrevChild( next );
-}
+	  // QWheelEvent::delta() gives rotation in eighths of a degree
+	  int wheelDegrees = ev->delta () / 8;
+	  int linesToScroll = abs (wheelDegrees) / 5;
-QChar TerminalDisplay::charClass(QChar qch) const
-{
+	  QKeyEvent keyScrollEvent (QEvent::KeyPress, key, Qt::NoModifier);
-if ( qch.isSpace() ) return ' ';
+	  for (int i = 0; i < linesToScroll; i++)
-if ( qch.isLetterOrNumber() || _wordCharacters.contains(qch, Qt::CaseInsensitive ) )
+	    emit keyPressedSignal (&keyScrollEvent);
-return 'a';
+	}
+}
-return qch;
+else
-}
+{
+// terminal program wants notification of mouse activity
-void TerminalDisplay::setWordCharacters(const QString& wc)
-{
+int charLine;
-_wordCharacters = wc;
+int charColumn;
-}
+getCharacterPosition (ev->pos (), charLine, charColumn);
-void TerminalDisplay::setUsesMouse(bool on)
+emit mouseSignal (ev->delta () > 0 ? 4 : 5,
-{
+			charColumn + 1,
-_mouseMarks = on;
+			charLine + 1 + _scrollBar->value () -
-setCursor( _mouseMarks ? Qt::IBeamCursor : Qt::ArrowCursor );
+			_scrollBar->maximum (), 0);
 }
-bool TerminalDisplay::usesMouse() const
+}
-{
-return _mouseMarks;
+void
+TerminalDisplay::tripleClickTimeout ()
+{
+_possibleTripleClick = false;
+}
+void
+TerminalDisplay::mouseTripleClickEvent (QMouseEvent * ev)
+{
+if (!_screenWindow)
+return;
+int charLine;
+int charColumn;
+getCharacterPosition (ev->pos (), charLine, charColumn);
+_iPntSel = QPoint (charColumn, charLine);
+_screenWindow->clearSelection ();
+_lineSelectionMode = true;
+_wordSelectionMode = false;
+_actSel = 2;			// within selection
+emit isBusySelecting (true);	// Keep it steady...
+while (_iPntSel.y () > 0
+	 && (_lineProperties[_iPntSel.y () - 1] & LINE_WRAPPED))
+_iPntSel.ry ()--;
+if (_tripleClickMode == SelectForwardsFromCursor)
+{
+// find word boundary start
+int i = loc (_iPntSel.x (), _iPntSel.y ());
+QChar selClass = charClass (_image[i].character);
+int x = _iPntSel.x ();
+while (((x > 0) ||
+	      (_iPntSel.y () > 0
+	       && (_lineProperties[_iPntSel.y () - 1] & LINE_WRAPPED)))
+	     && charClass (_image[i - 1].character) == selClass)
+	{
+	  i--;
+	  if (x > 0)
+	    x--;
+	  else
+	    {
+	      x = _columns - 1;
+	      _iPntSel.ry ()--;
+	    }
+	}
+_screenWindow->setSelectionStart (x, _iPntSel.y (), false);
+_tripleSelBegin = QPoint (x, _iPntSel.y ());
+}
+else if (_tripleClickMode == SelectWholeLine)
+{
+_screenWindow->setSelectionStart (0, _iPntSel.y (), false);
+_tripleSelBegin = QPoint (0, _iPntSel.y ());
+}
+while (_iPntSel.y () < _lines - 1
+	 && (_lineProperties[_iPntSel.y ()] & LINE_WRAPPED))
+_iPntSel.ry ()++;
+_screenWindow->setSelectionEnd (_columns - 1, _iPntSel.y ());
+setSelection (_screenWindow->selectedText (_preserveLineBreaks));
+_iPntSel.ry () += _scrollBar->value ();
+}
+bool
+TerminalDisplay::focusNextPrevChild (bool next)
+{
+if (next)
+return false;		// This disables changing the active part in konqueror
+// when pressing Tab
+return QWidget::focusNextPrevChild (next);
+}
+QChar
+TerminalDisplay::charClass (QChar qch) const
+{
+if (qch.isSpace ())
+return ' ';
+if (qch.isLetterOrNumber ()
+|| _wordCharacters.contains (qch, Qt::CaseInsensitive))
+return 'a';
+return qch;
+}
+void
+TerminalDisplay::setWordCharacters (const QString & wc)
+{
+_wordCharacters = wc;
+}
+void
+TerminalDisplay::setUsesMouse (bool on)
+{
+_mouseMarks = on;
+setCursor (_mouseMarks ? Qt::IBeamCursor : Qt::ArrowCursor);
+}
+bool
+TerminalDisplay::usesMouse () const
+{
+return _mouseMarks;
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                               Clipboard                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 #undef KeyPress
-void TerminalDisplay::emitSelection(bool useXselection,bool appendReturn)
+void
-{
+TerminalDisplay::emitSelection (bool useXselection, bool appendReturn)
-if ( !_screenWindow )
+{
-return;
+if (!_screenWindow)
+return;
-// Paste Clipboard by simulating keypress events
-QString text = QApplication::clipboard()->text(useXselection ? QClipboard::Selection :
+// Paste Clipboard by simulating keypress events
-QClipboard::Clipboard);
+QString text =
-if(appendReturn)
+QApplication::clipboard ()->
-text.append("\r");
+text (useXselection ? QClipboard::Selection : QClipboard::Clipboard);
-if ( ! text.isEmpty() )
+if (appendReturn)
-{
+text.append ("\r");
-text.replace('\n', '\r');
+if (!text.isEmpty ())
-QKeyEvent e(QEvent::KeyPress, 0, Qt::NoModifier, text);
+{
-emit keyPressedSignal(&e); // expose as a big fat keypress event
+text.replace ('\n', '\r');
+QKeyEvent e (QEvent::KeyPress, 0, Qt::NoModifier, text);
-_screenWindow->clearSelection();
+emit keyPressedSignal (&e);	// expose as a big fat keypress event
-}
-}
+_screenWindow->clearSelection ();
+}
-void TerminalDisplay::setSelection(const QString& t)
+}
-{
-QApplication::clipboard()->setText(t, QClipboard::Selection);
+void
-}
+TerminalDisplay::setSelection (const QString & t)
+{
-void TerminalDisplay::copyClipboard()
+QApplication::clipboard ()->setText (t, QClipboard::Selection);
-{
+}
-if ( !_screenWindow )
-return;
+void
+TerminalDisplay::copyClipboard ()
-QString text = _screenWindow->selectedText(_preserveLineBreaks);
+{
-if (!text.isEmpty())
+if (!_screenWindow)
-QApplication::clipboard()->setText(text);
+return;
-}
+QString text = _screenWindow->selectedText (_preserveLineBreaks);
-void TerminalDisplay::pasteClipboard()
+if (!text.isEmpty ())
-{
+QApplication::clipboard ()->setText (text);
-emitSelection(false,false);
+}
-}
+void
-void TerminalDisplay::pasteSelection()
+TerminalDisplay::pasteClipboard ()
 {
-emitSelection(true,false);
+emitSelection (false, false);
+}
+void
+TerminalDisplay::pasteSelection ()
+{
+emitSelection (true, false);
 }
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Keyboard                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
-void TerminalDisplay::setFlowControlWarningEnabled( bool enable )
+void
-{
+TerminalDisplay::setFlowControlWarningEnabled (bool enable)
-_flowControlWarningEnabled = enable;
+{
+_flowControlWarningEnabled = enable;
-// if the dialog is currently visible and the flow control warning has
-// been disabled then hide the dialog
+// if the dialog is currently visible and the flow control warning has
-if (!enable)
+// been disabled then hide the dialog
-outputSuspended(false);
+if (!enable)
-}
+outputSuspended (false);
+}
-void TerminalDisplay::keyPressEvent( QKeyEvent* event )
-{
+void
-bool emitKeyPressSignal = true;
+TerminalDisplay::keyPressEvent (QKeyEvent * event)
+{
-if(event->modifiers() == Qt::ControlModifier)
+bool emitKeyPressSignal = true;
-{
-switch(event->key()) {
+if (event->modifiers () == Qt::ControlModifier)
-case Qt::Key_C:
+{
-copyClipboard();
+switch (event->key ())
-break;
+	{
-case Qt::Key_V:
+	case Qt::Key_C:
-pasteClipboard();
+	  copyClipboard ();
-break;
+	  break;
-};
+	case Qt::Key_V:
-} else if ( event->modifiers() == Qt::ShiftModifier ) {
+	  pasteClipboard ();
-bool update = true;
+	  break;
+	};
-if ( event->key() == Qt::Key_PageUp )
+}
-{
+else if (event->modifiers () == Qt::ShiftModifier)
-_screenWindow->scrollBy( ScreenWindow::ScrollPages , -1 );
+{
-}
+bool update = true;
-else if ( event->key() == Qt::Key_PageDown )
-{
+if (event->key () == Qt::Key_PageUp)
-_screenWindow->scrollBy( ScreenWindow::ScrollPages , 1 );
+	{
-}
+	  _screenWindow->scrollBy (ScreenWindow::ScrollPages, -1);
-else if ( event->key() == Qt::Key_Up )
+	}
-{
+else if (event->key () == Qt::Key_PageDown)
-_screenWindow->scrollBy( ScreenWindow::ScrollLines , -1 );
+	{
-}
+	  _screenWindow->scrollBy (ScreenWindow::ScrollPages, 1);
-else if ( event->key() == Qt::Key_Down )
+	}
-{
+else if (event->key () == Qt::Key_Up)
-_screenWindow->scrollBy( ScreenWindow::ScrollLines , 1 );
+	{
-}
+	  _screenWindow->scrollBy (ScreenWindow::ScrollLines, -1);
-else
+	}
-update = false;
+else if (event->key () == Qt::Key_Down)
+	{
-if ( update )
+	  _screenWindow->scrollBy (ScreenWindow::ScrollLines, 1);
-{
+	}
-_screenWindow->setTrackOutput( _screenWindow->atEndOfOutput() );
+else
+	update = false;
-updateLineProperties();
-updateImage();
+if (update)
+	{
-// do not send key press to terminal
+	  _screenWindow->setTrackOutput (_screenWindow->atEndOfOutput ());
-emitKeyPressSignal = false;
-}
+	  updateLineProperties ();
-}
+	  updateImage ();
-_actSel=0; // Key stroke implies a screen update, so TerminalDisplay won't
+	  // do not send key press to terminal
-// know where the current selection is.
+	  emitKeyPressSignal = false;
+	}
-if (_hasBlinkingCursor)
+}
-{
-_blinkCursorTimer->start(QApplication::cursorFlashTime() / 2);
+_actSel = 0;			// Key stroke implies a screen update, so TerminalDisplay won't
-if (_cursorBlinking)
+// know where the current selection is.
-blinkCursorEvent();
-else
+if (_hasBlinkingCursor)
-_cursorBlinking = false;
+{
-}
+_blinkCursorTimer->start (QApplication::cursorFlashTime () / 2);
+if (_cursorBlinking)
-if ( emitKeyPressSignal )
+	blinkCursorEvent ();
-emit keyPressedSignal(event);
+else
+	_cursorBlinking = false;
-event->accept();
+}
-}
+if (emitKeyPressSignal)
-void TerminalDisplay::inputMethodEvent( QInputMethodEvent* event )
+emit keyPressedSignal (event);
-{
-QKeyEvent keyEvent(QEvent::KeyPress,0,(Qt::KeyboardModifiers)Qt::NoModifier,event->commitString());
+event->accept ();
-emit keyPressedSignal(&keyEvent);
+}
-_inputMethodData.preeditString = event->preeditString();
+void
-update(preeditRect() | _inputMethodData.previousPreeditRect);
+TerminalDisplay::inputMethodEvent (QInputMethodEvent * event)
+{
-event->accept();
+QKeyEvent keyEvent (QEvent::KeyPress, 0,
-}
+		      (Qt::KeyboardModifiers) Qt::NoModifier,
-QVariant TerminalDisplay::inputMethodQuery( Qt::InputMethodQuery query ) const
+		      event->commitString ());
-{
+emit keyPressedSignal (&keyEvent);
-const QPoint cursorPos = _screenWindow ? _screenWindow->cursorPosition() : QPoint(0,0);
-switch ( query )
+_inputMethodData.preeditString = event->preeditString ();
+update (preeditRect () | _inputMethodData.previousPreeditRect);
+event->accept ();
+}
+QVariant
+TerminalDisplay::inputMethodQuery (Qt::InputMethodQuery query) const
+{
+const QPoint cursorPos =
+_screenWindow ? _screenWindow->cursorPosition () : QPoint (0, 0);
+switch (query)
 {
 case Qt::ImMicroFocus:
-return imageToWidget(QRect(cursorPos.x(),cursorPos.y(),1,1));
+return imageToWidget (QRect (cursorPos.x (), cursorPos.y (), 1, 1));
 break;
 case Qt::ImFont:
-return font();
+return font ();
 break;
 case Qt::ImCursorPosition:
 // return the cursor position within the current line
-return cursorPos.x();
+return cursorPos.x ();
 break;
 case Qt::ImSurroundingText:
 {
-// return the text from the current line
+	// return the text from the current line
-QString lineText;
+	QString lineText;
-QTextStream stream(&lineText);
+	QTextStream stream (&lineText);
-PlainTextDecoder decoder;
+	PlainTextDecoder decoder;
-decoder.begin(&stream);
+	decoder.begin (&stream);
-decoder.decodeLine(&_image[loc(0,cursorPos.y())],_usedColumns,_lineProperties[cursorPos.y()]);
+	decoder.decodeLine (&_image[loc (0, cursorPos.y ())], _usedColumns,
-decoder.end();
+			    _lineProperties[cursorPos.y ()]);
-return lineText;
+	decoder.end ();
-}
+	return lineText;
-break;
+}
+break;
 case Qt::ImCurrentSelection:
-return QString();
+return QString ();
 break;
 default:
 break;
 }
-return QVariant();
+return QVariant ();
 }
-bool TerminalDisplay::handleShortcutOverrideEvent(QKeyEvent* keyEvent)
+bool
-{
+TerminalDisplay::handleShortcutOverrideEvent (QKeyEvent * keyEvent)
-int modifiers = keyEvent->modifiers();
+{
+int modifiers = keyEvent->modifiers ();
-//  When a possible shortcut combination is pressed,
-//  emit the overrideShortcutCheck() signal to allow the host
+//  When a possible shortcut combination is pressed,
-//  to decide whether the terminal should override it or not.
+//  emit the overrideShortcutCheck() signal to allow the host
-if (modifiers != Qt::NoModifier)
+//  to decide whether the terminal should override it or not.
-{
+if (modifiers != Qt::NoModifier)
-int modifierCount = 0;
+{
-unsigned int currentModifier = Qt::ShiftModifier;
+int modifierCount = 0;
+unsigned int currentModifier = Qt::ShiftModifier;
-while (currentModifier <= Qt::KeypadModifier)
-{
+while (currentModifier <= Qt::KeypadModifier)
-if (modifiers & currentModifier)
+	{
-modifierCount++;
+	  if (modifiers & currentModifier)
-currentModifier <<= 1;
+	    modifierCount++;
-}
+	  currentModifier <<= 1;
-if (modifierCount < 2)
+	}
-{
+if (modifierCount < 2)
-bool override = false;
+	{
-emit overrideShortcutCheck(keyEvent,override);
+	  bool override = false;
-if (override)
+	  emit overrideShortcutCheck (keyEvent, override);
-{
+	  if (override)
-keyEvent->accept();
+	    {
-return true;
+	      keyEvent->accept ();
-}
+	      return true;
-}
+	    }
-}
+	}
+}
-// Override any of the following shortcuts because
-// they are needed by the terminal
+// Override any of the following shortcuts because
-int keyCode = keyEvent->key() | modifiers;
+// they are needed by the terminal
-switch ( keyCode )
+int keyCode = keyEvent->key () | modifiers;
-{
+switch (keyCode)
-// list is taken from the QLineEdit::event() code
+{
+// list is taken from the QLineEdit::event() code
 case Qt::Key_Tab:
 case Qt::Key_Delete:
 case Qt::Key_Home:
 case Qt::Key_End:
 case Qt::Key_Backspace:
 case Qt::Key_Left:
 case Qt::Key_Right:
-keyEvent->accept();
+keyEvent->accept ();
 return true;
 }
 return false;
 }
-bool TerminalDisplay::event(QEvent* event)
+bool
-{
+TerminalDisplay::event (QEvent * event)
-bool eventHandled = false;
+{
-switch (event->type())
+bool eventHandled = false;
+switch (event->type ())
 {
 case QEvent::ShortcutOverride:
-eventHandled = handleShortcutOverrideEvent((QKeyEvent*)event);
+eventHandled = handleShortcutOverrideEvent ((QKeyEvent *) event);
 break;
 case QEvent::PaletteChange:
 case QEvent::ApplicationPaletteChange:
-_scrollBar->setPalette( QApplication::palette() );
+_scrollBar->setPalette (QApplication::palette ());
 break;
 default:
 break;
 }
-return eventHandled ? true : QWidget::event(event);
+return eventHandled ? true : QWidget::event (event);
 }
-void TerminalDisplay::setBellMode(int mode)
+void
-{
+TerminalDisplay::setBellMode (int mode)
-_bellMode=mode;
+{
-}
+_bellMode = mode;
+}
-void TerminalDisplay::enableBell()
-{
+void
-_allowBell = true;
+TerminalDisplay::enableBell ()
-}
+{
+_allowBell = true;
-void TerminalDisplay::bell(const QString& message)
+}
-{
-Q_UNUSED(message);
+void
-if (_bellMode==NoBell) return;
+TerminalDisplay::bell (const QString & message)
+{
-//limit the rate at which bells can occur
+Q_UNUSED (message);
-//...mainly for sound effects where rapid bells in sequence
+if (_bellMode == NoBell)
-//produce a horrible noise
+return;
-if ( _allowBell )
-{
+//limit the rate at which bells can occur
-_allowBell = false;
+//...mainly for sound effects where rapid bells in sequence
-QTimer::singleShot(500,this,SLOT(enableBell()));
+//produce a horrible noise
+if (_allowBell)
-if (_bellMode==SystemBeepBell)
+{
-{
+_allowBell = false;
-// TODO: This will need added back in at some point
+QTimer::singleShot (500, this, SLOT (enableBell ()));
-//KNotification::beep();
-}
+if (_bellMode == SystemBeepBell)
-else if (_bellMode==NotifyBell)
+	{
-{
+	  // TODO: This will need added back in at some point
-// TODO: This will need added back in at some point
+	  //KNotification::beep();
-//KNotification::event("BellVisible", message,QPixmap(),this);
+	}
-}
+else if (_bellMode == NotifyBell)
-else if (_bellMode==VisualBell)
+	{
-{
+	  // TODO: This will need added back in at some point
-swapColorTable();
+	  //KNotification::event("BellVisible", message,QPixmap(),this);
-QTimer::singleShot(200,this,SLOT(swapColorTable()));
+	}
-}
+else if (_bellMode == VisualBell)
-}
+	{
-}
+	  swapColorTable ();
+	  QTimer::singleShot (200, this, SLOT (swapColorTable ()));
-void TerminalDisplay::swapColorTable()
+	}
-{
+}
-ColorEntry color = _colorTable[1];
+}
-_colorTable[1]=_colorTable[0];
-_colorTable[0]= color;
+void
-_colorsInverted = !_colorsInverted;
+TerminalDisplay::swapColorTable ()
-update();
+{
-}
+ColorEntry color = _colorTable[1];
+_colorTable[1] = _colorTable[0];
-void TerminalDisplay::clearImage()
+_colorTable[0] = color;
-{
+_colorsInverted = !_colorsInverted;
-// We initialize _image[_imageSize] too. See makeImage()
+update ();
-for (int i = 0; i <= _imageSize; i++)
+}
-{
-_image[i].character = ' ';
+void
-_image[i].foregroundColor = CharacterColor(COLOR_SPACE_DEFAULT,
+TerminalDisplay::clearImage ()
-DEFAULT_FORE_COLOR);
+{
-_image[i].backgroundColor = CharacterColor(COLOR_SPACE_DEFAULT,
+// We initialize _image[_imageSize] too. See makeImage()
-DEFAULT_BACK_COLOR);
+for (int i = 0; i <= _imageSize; i++)
-_image[i].rendition = DEFAULT_RENDITION;
+{
-}
+_image[i].character = ' ';
-}
+_image[i].foregroundColor = CharacterColor (COLOR_SPACE_DEFAULT,
+						  DEFAULT_FORE_COLOR);
-void TerminalDisplay::calcGeometry()
+_image[i].backgroundColor = CharacterColor (COLOR_SPACE_DEFAULT,
-{
+						  DEFAULT_BACK_COLOR);
-_scrollBar->resize(_scrollBar->sizeHint().width(), contentsRect().height());
+_image[i].rendition = DEFAULT_RENDITION;
-switch(_scrollbarLocation)
+}
-{
+}
-case NoScrollBar :
-_leftMargin = DEFAULT_LEFT_MARGIN;
+void
-_contentWidth = contentsRect().width() - 2 * DEFAULT_LEFT_MARGIN;
+TerminalDisplay::calcGeometry ()
-break;
+{
-case ScrollBarLeft :
+_scrollBar->resize (_scrollBar->sizeHint ().width (),
-_leftMargin = DEFAULT_LEFT_MARGIN + _scrollBar->width();
+		      contentsRect ().height ());
-_contentWidth = contentsRect().width() - 2 * DEFAULT_LEFT_MARGIN - _scrollBar->width();
+switch (_scrollbarLocation)
-_scrollBar->move(contentsRect().topLeft());
+{
-break;
+case NoScrollBar:
+_leftMargin = DEFAULT_LEFT_MARGIN;
+_contentWidth = contentsRect ().width () - 2 * DEFAULT_LEFT_MARGIN;
+break;
+case ScrollBarLeft:
+_leftMargin = DEFAULT_LEFT_MARGIN + _scrollBar->width ();
+_contentWidth =
+	contentsRect ().width () - 2 * DEFAULT_LEFT_MARGIN -
+	_scrollBar->width ();
+_scrollBar->move (contentsRect ().topLeft ());
+break;
 case ScrollBarRight:
 _leftMargin = DEFAULT_LEFT_MARGIN;
-_contentWidth = contentsRect().width()  - 2 * DEFAULT_LEFT_MARGIN - _scrollBar->width();
+_contentWidth =
-_scrollBar->move(contentsRect().topRight() - QPoint(_scrollBar->width()-1,0));
+	contentsRect ().width () - 2 * DEFAULT_LEFT_MARGIN -
-break;
+	_scrollBar->width ();
-}
+_scrollBar->move (contentsRect ().topRight () -
+			QPoint (_scrollBar->width () - 1, 0));
-_topMargin = DEFAULT_TOP_MARGIN;
+break;
-_contentHeight = contentsRect().height() - 2 * DEFAULT_TOP_MARGIN + /* mysterious */ 1;
+}
-if (!_isFixedSize)
+_topMargin = DEFAULT_TOP_MARGIN;
-{
+_contentHeight =
-// ensure that display is always at least one column wide
+contentsRect ().height () - 2 * DEFAULT_TOP_MARGIN + /* mysterious */ 1;
-_columns = qMax(1,_contentWidth / _fontWidth);
-_usedColumns = qMin(_usedColumns,_columns);
+if (!_isFixedSize)
+{
-// ensure that display is always at least one line high
+// ensure that display is always at least one column wide
-_lines = qMax(1,_contentHeight / _fontHeight);
+_columns = qMax (1, _contentWidth / _fontWidth);
-_usedLines = qMin(_usedLines,_lines);
+_usedColumns = qMin (_usedColumns, _columns);
-}
-}
+// ensure that display is always at least one line high
+_lines = qMax (1, _contentHeight / _fontHeight);
-void TerminalDisplay::makeImage()
+_usedLines = qMin (_usedLines, _lines);
-{
+}
-calcGeometry();
+}
-// confirm that array will be of non-zero size, since the painting code
+void
-// assumes a non-zero array length
+TerminalDisplay::makeImage ()
-Q_ASSERT( _lines > 0 && _columns > 0 );
+{
-Q_ASSERT( _usedLines <= _lines && _usedColumns <= _columns );
+calcGeometry ();
-_imageSize=_lines*_columns;
+// confirm that array will be of non-zero size, since the painting code
+// assumes a non-zero array length
-// We over-commit one character so that we can be more relaxed in dealing with
+Q_ASSERT (_lines > 0 && _columns > 0);
-// certain boundary conditions: _image[_imageSize] is a valid but unused position
+Q_ASSERT (_usedLines <= _lines && _usedColumns <= _columns);
-_image = new Character[_imageSize+1];
+_imageSize = _lines * _columns;
-clearImage();
+// We over-commit one character so that we can be more relaxed in dealing with
+// certain boundary conditions: _image[_imageSize] is a valid but unused position
+_image = new Character[_imageSize + 1];
+clearImage ();
 }
 // calculate the needed size, this must be synced with calcGeometry()
-void TerminalDisplay::setSize(int columns, int lines)
+void
-{
+TerminalDisplay::setSize (int columns, int lines)
-int scrollBarWidth = _scrollBar->isHidden() ? 0 : _scrollBar->sizeHint().width();
+{
-int horizontalMargin = 2 * DEFAULT_LEFT_MARGIN;
+int scrollBarWidth =
-int verticalMargin = 2 * DEFAULT_TOP_MARGIN;
+_scrollBar->isHidden ()? 0 : _scrollBar->sizeHint ().width ();
+int horizontalMargin = 2 * DEFAULT_LEFT_MARGIN;
-QSize newSize = QSize( horizontalMargin + scrollBarWidth + (columns * _fontWidth)  ,
+int verticalMargin = 2 * DEFAULT_TOP_MARGIN;
-verticalMargin + (lines * _fontHeight)   );
+QSize newSize =
-if ( newSize != size() )
+QSize (horizontalMargin + scrollBarWidth + (columns * _fontWidth),
-{
+	   verticalMargin + (lines * _fontHeight));
-_size = newSize;
-updateGeometry();
+if (newSize != size ())
-}
+{
-}
+_size = newSize;
+updateGeometry ();
-void TerminalDisplay::setFixedSize(int cols, int lins)
+}
-{
+}
-_isFixedSize = true;
+void
-//ensure that display is at least one line by one column in size
+TerminalDisplay::setFixedSize (int cols, int lins)
-_columns = qMax(1,cols);
+{
-_lines = qMax(1,lins);
+_isFixedSize = true;
-_usedColumns = qMin(_usedColumns,_columns);
-_usedLines = qMin(_usedLines,_lines);
+//ensure that display is at least one line by one column in size
+_columns = qMax (1, cols);
-if (_image)
+_lines = qMax (1, lins);
-{
+_usedColumns = qMin (_usedColumns, _columns);
-delete[] _image;
+_usedLines = qMin (_usedLines, _lines);
-makeImage();
-}
+if (_image)
-setSize(cols, lins);
+{
-QWidget::setFixedSize(_size);
+delete[]_image;
-}
+makeImage ();
+}
-QSize TerminalDisplay::sizeHint() const
+setSize (cols, lins);
-{
+QWidget::setFixedSize (_size);
-return _size;
+}
+QSize
+TerminalDisplay::sizeHint () const
+{
+return _size;
 }
 /* --------------------------------------------------------------------- */
 /*                                                                       */
 /* Drag & Drop                                                           */
 /*                                                                       */
 /* --------------------------------------------------------------------- */
-void TerminalDisplay::dragEnterEvent(QDragEnterEvent* event)
+void
-{
+TerminalDisplay::dragEnterEvent (QDragEnterEvent * event)
-if (event->mimeData()->hasFormat("text/plain"))
+{
-event->acceptProposedAction();
+if (event->mimeData ()->hasFormat ("text/plain"))
-}
+event->acceptProposedAction ();
+}
-void TerminalDisplay::dropEvent(QDropEvent* event)
-{
+void
-//KUrl::List urls = KUrl::List::fromMimeData(event->mimeData());
+TerminalDisplay::dropEvent (QDropEvent * event)
+{
-QString dropText;
+//KUrl::List urls = KUrl::List::fromMimeData(event->mimeData());
-/*
-if (!urls.isEmpty())
+QString dropText;
-{
+/*
-for ( int i = 0 ; i < urls.count() ; i++ )
+if (!urls.isEmpty())
 {
-KUrl url = KIO::NetAccess::mostLocalUrl( urls[i] , 0 );
+for ( int i = 0 ; i < urls.count() ; i++ )
-QString urlText;
+{
+KUrl url = KIO::NetAccess::mostLocalUrl( urls[i] , 0 );
-if (url.isLocalFile())
+QString urlText;
-urlText = url.path();
-else
+if (url.isLocalFile())
-urlText = url.url();
+urlText = url.path();
+else
-// in future it may be useful to be able to insert file names with drag-and-drop
+urlText = url.url();
-// without quoting them (this only affects paths with spaces in)
-urlText = KShell::quoteArg(urlText);
+// in future it may be useful to be able to insert file names with drag-and-drop
+// without quoting them (this only affects paths with spaces in)
-dropText += urlText;
+urlText = KShell::quoteArg(urlText);
-if ( i != urls.count()-1 )
+dropText += urlText;
-dropText += ' ';
-}
+if ( i != urls.count()-1 )
-}
+dropText += ' ';
-else
+}
-{
+}
-dropText = event->mimeData()->text();
+else
-}
+{
-*/
+dropText = event->mimeData()->text();
+}
-if(event->mimeData()->hasFormat("text/plain"))
+*/
-{
-emit sendStringToEmu(dropText.toLocal8Bit());
+if (event->mimeData ()->hasFormat ("text/plain"))
-}
+{
-}
+emit sendStringToEmu (dropText.toLocal8Bit ());
+}
-void TerminalDisplay::doDrag()
+}
-{
-dragInfo.state = diDragging;
+void
-dragInfo.dragObject = new QDrag(this);
+TerminalDisplay::doDrag ()
-QMimeData *mimeData = new QMimeData;
+{
-mimeData->setText(QApplication::clipboard()->text(QClipboard::Selection));
+dragInfo.state = diDragging;
-dragInfo.dragObject->setMimeData(mimeData);
+dragInfo.dragObject = new QDrag (this);
-dragInfo.dragObject->start(Qt::CopyAction);
+QMimeData *mimeData = new QMimeData;
-// Don't delete the QTextDrag object.  Qt will delete it when it's done with it.
+mimeData->setText (QApplication::clipboard ()->
-}
+		     text (QClipboard::Selection));
+dragInfo.dragObject->setMimeData (mimeData);
-void TerminalDisplay::outputSuspended(bool suspended)
+dragInfo.dragObject->start (Qt::CopyAction);
-{
+// Don't delete the QTextDrag object.  Qt will delete it when it's done with it.
-//create the label when this function is first called
+}
-if (!_outputSuspendedLabel)
-{
+void
-//This label includes a link to an English language website
+TerminalDisplay::outputSuspended (bool suspended)
-//describing the 'flow control' (Xon/Xoff) feature found in almost
+{
-//all terminal emulators.
+//create the label when this function is first called
-//If there isn't a suitable article available in the target language the link
+if (!_outputSuspendedLabel)
-//can simply be removed.
+{
-_outputSuspendedLabel = new QLabel( QString("<qt>Output has been "
+//This label includes a link to an English language website
-"<a href=\"http://en.wikipedia.org/wiki/Flow_control\">suspended</a>"
+//describing the 'flow control' (Xon/Xoff) feature found in almost
-" by pressing Ctrl+S."
+//all terminal emulators.
-"  Press <b>Ctrl+Q</b> to resume.</qt>"),
+//If there isn't a suitable article available in the target language the link
-this );
+//can simply be removed.
+_outputSuspendedLabel = new QLabel (QString ("<qt>Output has been "
-QPalette palette(_outputSuspendedLabel->palette());
+						   "<a href=\"http://en.wikipedia.org/wiki/Flow_control\">suspended</a>"
-//KColorScheme::adjustBackground(palette,KColorScheme::NeutralBackground);
+						   " by pressing Ctrl+S."
-_outputSuspendedLabel->setPalette(palette);
+						   "  Press <b>Ctrl+Q</b> to resume.</qt>"),
-_outputSuspendedLabel->setAutoFillBackground(true);
+					  this);
-_outputSuspendedLabel->setBackgroundRole(QPalette::Base);
-_outputSuspendedLabel->setFont(QApplication::font());
+QPalette palette (_outputSuspendedLabel->palette ());
-_outputSuspendedLabel->setContentsMargins(5, 5, 5, 5);
+//KColorScheme::adjustBackground(palette,KColorScheme::NeutralBackground);
+_outputSuspendedLabel->setPalette (palette);
-//enable activation of "Xon/Xoff" link in label
+_outputSuspendedLabel->setAutoFillBackground (true);
-_outputSuspendedLabel->setTextInteractionFlags(Qt::LinksAccessibleByMouse |
+_outputSuspendedLabel->setBackgroundRole (QPalette::Base);
-Qt::LinksAccessibleByKeyboard);
+_outputSuspendedLabel->setFont (QApplication::font ());
-_outputSuspendedLabel->setOpenExternalLinks(true);
+_outputSuspendedLabel->setContentsMargins (5, 5, 5, 5);
-_outputSuspendedLabel->setVisible(false);
+//enable activation of "Xon/Xoff" link in label
-_gridLayout->addWidget(_outputSuspendedLabel);
+_outputSuspendedLabel->
-_gridLayout->addItem( new QSpacerItem(0,0,QSizePolicy::Expanding,
+	setTextInteractionFlags (Qt::LinksAccessibleByMouse | Qt::
-QSizePolicy::Expanding),
+				 LinksAccessibleByKeyboard);
-1,0);
+_outputSuspendedLabel->setOpenExternalLinks (true);
+_outputSuspendedLabel->setVisible (false);
-}
+_gridLayout->addWidget (_outputSuspendedLabel);
-_outputSuspendedLabel->setVisible(suspended);
+_gridLayout->addItem (new QSpacerItem (0, 0, QSizePolicy::Expanding,
-}
+					     QSizePolicy::Expanding), 1, 0);
-uint TerminalDisplay::lineSpacing() const
+}
-{
-return _lineSpacing;
+_outputSuspendedLabel->setVisible (suspended);
 }
-void TerminalDisplay::setLineSpacing(uint i)
+uint
-{
+TerminalDisplay::lineSpacing () const
-_lineSpacing = i;
+{
-setVTFont(font()); // Trigger an update.
+return _lineSpacing;
 }
-AutoScrollHandler::AutoScrollHandler(QWidget* parent)
+void
-: QObject(parent)
+TerminalDisplay::setLineSpacing (uint i)
-, _timerId(0)
+{
-{
+_lineSpacing = i;
-//parent->installEventFilter(this);
+setVTFont (font ());		// Trigger an update.
 }
-void AutoScrollHandler::timerEvent(QTimerEvent* event)
-{
+AutoScrollHandler::AutoScrollHandler (QWidget * parent):QObject (parent),
-if (event->timerId() != _timerId)
+_timerId (0)
-return;
+{
+//parent->installEventFilter(this);
-QMouseEvent mouseEvent(    QEvent::MouseMove,
+}
-widget()->mapFromGlobal(QCursor::pos()),
-Qt::NoButton,
+void
-Qt::LeftButton,
+AutoScrollHandler::timerEvent (QTimerEvent * event)
-Qt::NoModifier);
+{
+if (event->timerId () != _timerId)
-QApplication::sendEvent(widget(),&mouseEvent);
+return;
-}
-bool AutoScrollHandler::eventFilter(QObject* watched,QEvent* event)
+QMouseEvent mouseEvent (QEvent::MouseMove,
-{
+			  widget ()->mapFromGlobal (QCursor::pos ()),
-Q_ASSERT( watched == parent() );
+			  Qt::NoButton, Qt::LeftButton, Qt::NoModifier);
-Q_UNUSED( watched );
+QApplication::sendEvent (widget (), &mouseEvent);
-QMouseEvent* mouseEvent = (QMouseEvent*)event;
+}
-switch (event->type())
+bool
+AutoScrollHandler::eventFilter (QObject * watched, QEvent * event)
+{
+Q_ASSERT (watched == parent ());
+Q_UNUSED (watched);
+QMouseEvent *mouseEvent = (QMouseEvent *) event;
+switch (event->type ())
 {
 case QEvent::MouseMove:
 {
-bool mouseInWidget = widget()->rect().contains(mouseEvent->pos());
+	bool mouseInWidget = widget ()->rect ().contains (mouseEvent->pos ());
-if (mouseInWidget)
+	if (mouseInWidget)
-{
+	  {
-if (_timerId)
+	    if (_timerId)
-killTimer(_timerId);
+	      killTimer (_timerId);
-_timerId = 0;
+	    _timerId = 0;
-}
+	  }
-else
+	else
-{
+	  {
-if (!_timerId && (mouseEvent->buttons() & Qt::LeftButton))
+	    if (!_timerId && (mouseEvent->buttons () & Qt::LeftButton))
-_timerId = startTimer(100);
+	      _timerId = startTimer (100);
-}
+	  }
-break;
+	break;
 }
 case QEvent::MouseButtonRelease:
-if (_timerId && (mouseEvent->buttons() & ~Qt::LeftButton))
+if (_timerId && (mouseEvent->buttons () & ~Qt::LeftButton))
-{
+	{
-killTimer(_timerId);
+	  killTimer (_timerId);
-_timerId = 0;
+	  _timerId = 0;
-}
+	}
 break;
 default:
 break;
 };
 return false;
 }

Mercurial > hg > octave-lyh

comparison gui/src/terminal/TerminalDisplay.cpp @ 13506:c70511cf64ee