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