TerminalDisplay.cpp 85.3 KB
Newer Older
1
/*
2
    This file is part of Konsole, a terminal emulator for KDE.
3
    
4
    Copyright (C) 2006-7 by Robert Knight <robertknight@gmail.com>
5
    Copyright (C) 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
6
    
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301  USA.
*/
22

23
24
25
// Own
#include "TerminalDisplay.h"

Robert Knight's avatar
Robert Knight committed
26
// Qt
Dirk Mueller's avatar
Dirk Mueller committed
27
28
29
30
31
#include <QtGui/QApplication>
#include <QtGui/QBoxLayout>
#include <QtGui/QClipboard>
#include <QtGui/QKeyEvent>
#include <QtCore/QEvent>
32
#include <QtCore/QTime>
Dirk Mueller's avatar
Dirk Mueller committed
33
34
35
36
37
38
#include <QtCore/QFile>
#include <QtGui/QGridLayout>
#include <QtGui/QLabel>
#include <QtGui/QLayout>
#include <QtGui/QPainter>
#include <QtGui/QPixmap>
39
#include <QtGui/QScrollBar>
Dirk Mueller's avatar
Dirk Mueller committed
40
41
42
#include <QtGui/QStyle>
#include <QtCore/QTimer>
#include <QtGui/QToolTip>
43

Robert Knight's avatar
Robert Knight committed
44
// KDE
45
#include <kshell.h>
Robert Knight's avatar
   
Robert Knight committed
46
#include <KColorScheme>
Robert Knight's avatar
Robert Knight committed
47
#include <KCursor>
48
#include <kdebug.h>
Robert Knight's avatar
Robert Knight committed
49
#include <KLocale>
50
#include <KMenu>
Robert Knight's avatar
Robert Knight committed
51
52
53
54
55
56
#include <KNotification>
#include <KGlobalSettings>
#include <KShortcut>
#include <KIO/NetAccess>

// Konsole
Dirk Mueller's avatar
Dirk Mueller committed
57
#include <config-apps.h>
58
#include "Filter.h"
Robert Knight's avatar
Robert Knight committed
59
#include "konsole_wcwidth.h"
60
#include "ScreenWindow.h"
61
#include "TerminalCharacterDecoder.h"
62

63
64
using namespace Konsole;

65
#ifndef loc
66
#define loc(X,Y) ((Y)*_columns+(X))
67
68
69
#endif

#define yMouseScroll 1
Waldo Bastian's avatar
Waldo Bastian committed
70
71
72
73

#define REPCHAR   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
                  "abcdefgjijklmnopqrstuvwxyz" \
                  "0123456789./+@"
74

75
76
// scroll increment used when dragging selection at top/bottom of window.

77
// static
78
bool TerminalDisplay::_antialiasText = true;
79
bool TerminalDisplay::HAVE_TRANSPARENCY = false;
80

81
82
83
84
85
86
87
88
89
90
91
92
93
94
/* ------------------------------------------------------------------------- */
/*                                                                           */
/*                                Colors                                     */
/*                                                                           */
/* ------------------------------------------------------------------------- */

/* Note that we use ANSI color order (bgr), while IBMPC color order is (rgb)

   Code        0       1       2       3       4       5       6       7
   ----------- ------- ------- ------- ------- ------- ------- ------- -------
   ANSI  (bgr) Black   Red     Green   Yellow  Blue    Magenta Cyan    White
   IBMPC (rgb) Black   Blue    Green   Cyan    Red     Magenta Yellow  White
*/

95
ScreenWindow* TerminalDisplay::screenWindow() const
96
97
98
{
    return _screenWindow;
}
99
void TerminalDisplay::setScreenWindow(ScreenWindow* window)
100
{
101
102
103
104
105
106
    // disconnect existing screen window if any
    if ( _screenWindow )
    {
        disconnect( _screenWindow , 0 , this , 0 );
    }

107
    _screenWindow = window;
108

109
110
    if ( window )
    {
111
#warning "The order here is not specified - does it matter whether updateImage or updateLineProperties comes first?"
112
113
        connect( _screenWindow , SIGNAL(outputChanged()) , this , SLOT(updateLineProperties()) );
        connect( _screenWindow , SIGNAL(outputChanged()) , this , SLOT(updateImage()) );
114
		window->setWindowLines(_lines);
115
    }
116
117
}

118
const ColorEntry* TerminalDisplay::colorTable() const
119
{
120
  return _colorTable;
121
122
}

123
void TerminalDisplay::setColorTable(const ColorEntry table[])
124
{
Robert Knight's avatar
   
Robert Knight committed
125
126
  for (int i = 0; i < TABLE_COLORS; i++)
      _colorTable[i] = table[i];
127

128
  QPalette p = palette();
129
  p.setColor( backgroundRole(), _colorTable[DEFAULT_BACK_COLOR].color );
130
  setPalette( p );
131

132
  // Avoid propagating the palette change to the scroll bar 
133
134
  _scrollBar->setPalette( QApplication::palette() );  

135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
  update();
}

/* ------------------------------------------------------------------------- */
/*                                                                           */
/*                                   Font                                    */
/*                                                                           */
/* ------------------------------------------------------------------------- */

/*
   The VT100 has 32 special graphical characters. The usual vt100 extended
   xterm fonts have these at 0x00..0x1f.

   QT's iso mapping leaves 0x00..0x7f without any changes. But the graphicals
   come in here as proper unicode characters.

   We treat non-iso10646 fonts as VT100 extended and do the requiered mapping
   from unicode to 0x00..0x1f. The remaining translation is then left to the
   QCodec.
*/

156
static inline bool isLineChar(quint16 c) { return ((c & 0xFF80) == 0x2500);}
157
158
159
160
161
static inline bool isLineCharString(const QString& string)
{
		return (string.length() > 0) && (isLineChar(string.at(0).unicode()));
}
						
162

163
164
// assert for i in [0..31] : vt100extended(vt100_graphics[i]) == i.

165
unsigned short Konsole::vt100_graphics[32] =
166
167
168
169
170
171
172
{ // 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
};

173
void TerminalDisplay::fontChange(const QFont&)
174
175
{
  QFontMetrics fm(font());
176
  _fontHeight = fm.height() + _lineSpacing;
177

178
  // waba TerminalDisplay 1.123:
179
180
  // "Base character width on widest ASCII character. This prevents too wide
  //  characters in the presence of double wide (e.g. Japanese) characters."
Waldo Bastian's avatar
Waldo Bastian committed
181
  // Get the width from representative normal width characters
182
  _fontWidth = qRound((double)fm.width(REPCHAR)/(double)strlen(REPCHAR));
Waldo Bastian's avatar
Waldo Bastian committed
183

184
  _fixedFont = true;
185

186
  int fw = fm.width(REPCHAR[0]);
187
188
189
190
  for(unsigned int i=1; i< strlen(REPCHAR); i++)
  {
    if (fw != fm.width(REPCHAR[i]))
    {
191
      _fixedFont = false;
Waldo Bastian's avatar
Waldo Bastian committed
192
      break;
193
    }
194
  }
Stephan Kulow's avatar
Stephan Kulow committed
195

196
  if (_fontWidth < 1)
197
    _fontWidth=1;
198

199
  _fontAscent = fm.ascent();
200

201
  emit changedFontMetricSignal( _fontHeight, _fontWidth );
202
203
204
205
  propagateSize();
  update();
}

206
void TerminalDisplay::setVTFont(const QFont& f)
207
{
208
  QFont font = f;
Robert Knight's avatar
Robert Knight committed
209
210
211
212
213

  QFontMetrics metrics(font);

  if ( metrics.height() < height() && metrics.maxWidth() < width() )
  {
214
215
216
    // hint that text should be drawn without anti-aliasing.  
    // depending on the user's font configuration, this may not be respected
    if (!_antialiasText)
Robert Knight's avatar
Robert Knight committed
217
        font.setStyleStrategy( QFont::NoAntialias );
Robert Knight's avatar
   
Robert Knight committed
218
219
220
221
222
223
 
    // 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);

224
    QWidget::setFont(font);
Robert Knight's avatar
Robert Knight committed
225
226
    fontChange(font);
  }
227
228
}

229
void TerminalDisplay::setFont(const QFont &)
230
231
232
233
234
235
236
237
238
239
{
  // ignore font change request if not coming from konsole itself
}

/* ------------------------------------------------------------------------- */
/*                                                                           */
/*                         Constructor / Destructor                          */
/*                                                                           */
/* ------------------------------------------------------------------------- */

240
TerminalDisplay::TerminalDisplay(QWidget *parent)
241
:QWidget(parent)
242
,_screenWindow(0)
243
244
245
246
247
248
249
250
251
252
253
254
,_allowBell(true)
,_gridLayout(0)
,_fontHeight(1)
,_fontWidth(1)
,_fontAscent(1)
,_lines(1)
,_columns(1)
,_usedLines(1)
,_usedColumns(1)
,_contentHeight(1)
,_contentWidth(1)
,_image(0)
255
,_randomSeed(0)
256
257
258
259
260
261
262
,_resizing(false)
,_terminalSizeHint(false)
,_terminalSizeStartup(true)
,_bidiEnabled(false)
,_actSel(0)
,_wordSelectionMode(false)
,_lineSelectionMode(false)
263
,_preserveLineBreaks(false)
264
,_columnSelectionMode(false)
265
,_scrollbarLocation(NoScrollBar)
266
,_wordCharacters(":@-./_~")
Robert Knight's avatar
   
Robert Knight committed
267
,_bellMode(SystemBeepBell)
268
269
270
271
,_blinking(false)
,_cursorBlinking(false)
,_hasBlinkingCursor(false)
,_ctrlDrag(false)
272
,_tripleClickMode(SelectWholeLine)
273
274
275
276
,_isFixedSize(false)
,_possibleTripleClick(false)
,_resizeWidget(0)
,_resizeTimer(0)
Robert Knight's avatar
   
Robert Knight committed
277
,_flowControlWarningEnabled(false)
278
279
280
281
,_outputSuspendedLabel(0)
,_lineSpacing(0)
,_colorsInverted(false)
,_blendColor(qRgba(0,0,0,0xff))
282
,_filterChain(new TerminalImageFilterChain())
283
,_cursorShape(BlockCursor)
284
{
Robert Knight's avatar
   
Robert Knight committed
285
286
287
288
  // terminal applications are not designed with Right-To-Left in mind,
  // so the layout is forced to Left-To-Right
  setLayoutDirection(Qt::LeftToRight);

289
  // The offsets are not yet calculated.
290
  // Do not calculate these too often to be more smoothly when resizing
291
  // konsole in opaque mode.
Robert Knight's avatar
   
Robert Knight committed
292
293
  _topMargin = DEFAULT_TOP_MARGIN;
  _leftMargin = DEFAULT_LEFT_MARGIN;
294

295
296
  // 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
297
  _scrollBar = new QScrollBar(this);
298
  setScroll(0,0); 
299
  _scrollBar->setCursor( Qt::ArrowCursor );
Robert Knight's avatar
   
Robert Knight committed
300
301
  connect(_scrollBar, SIGNAL(valueChanged(int)), this, 
  					  SLOT(scrollBarPositionChanged(int)));
302

Robert Knight's avatar
   
Robert Knight committed
303
  // setup timers for blinking cursor and text
304
305
306
307
  _blinkTimer   = new QTimer(this);
  connect(_blinkTimer, SIGNAL(timeout()), this, SLOT(blinkEvent()));
  _blinkCursorTimer   = new QTimer(this);
  connect(_blinkCursorTimer, SIGNAL(timeout()), this, SLOT(blinkCursorEvent()));
308

Robert Knight's avatar
   
Robert Knight committed
309
310
  KCursor::setAutoHideCursor( this, true );
  
Robert Knight's avatar
   
Robert Knight committed
311
  setUsesMouse(true);
312
  setColorTable(base_color_table); 
313
314
  setMouseTracking(true);

Robert Knight's avatar
   
Robert Knight committed
315
  // Enable drag and drop 
316
  setAcceptDrops(true); // attempt
317
  dragInfo.state = diNone;
318

319
  setFocusPolicy( Qt::WheelFocus );
320
321

  // enable input method support
322
  setAttribute(Qt::WA_InputMethodEnabled, true);
Stephan Kulow's avatar
Stephan Kulow committed
323

Robert Knight's avatar
Robert Knight committed
324
  // this is an important optimization, it tells Qt
325
326
  // that TerminalDisplay will handle repainting its entire area.
  setAttribute(Qt::WA_OpaquePaintEvent);
327

328
329
  _gridLayout = new QGridLayout(this);
  _gridLayout->setMargin(0);
330

331
  setLayout( _gridLayout ); 
332
333
334

  //set up a warning message when the user presses Ctrl+S to avoid confusion
  connect( this,SIGNAL(flowControlKeyPressed(bool)),this,SLOT(outputSuspended(bool)) );
335
336

  new AutoScrollHandler(this);
337
338
}

339
TerminalDisplay::~TerminalDisplay()
340
341
{
  qApp->removeEventFilter( this );
342
  
343
  delete[] _image;
344

345
346
  delete _gridLayout;
  delete _outputSuspendedLabel;
347
  delete _filterChain;
348
349
350
351
352
353
354
355
}

/* ------------------------------------------------------------------------- */
/*                                                                           */
/*                             Display Operations                            */
/*                                                                           */
/* ------------------------------------------------------------------------- */

356
357
358
359
360
/**
 A table for emulating the simple (single width) unicode drawing chars.
 It represents the 250x - 257x glyphs. If it's zero, we can't use it.
 if it's not, it's encoded as follows: imagine a 5x5 grid where the points are numbered
 0 to 24 left to top, top to bottom. Each point is represented by the corresponding bit.
Stephan Kulow's avatar
Stephan Kulow committed
361

362
363
364
365
366
367
368
369
370
371
372
 Then, the pixels basically have the following interpretation:
 _|||_
 -...-
 -...-
 -...-
 _|||_

where _ = none
      | = vertical line.
      - = horizontal line.
 */
Stephan Kulow's avatar
Stephan Kulow committed
373

374
375
376
377
378
379

enum LineEncode
{
    TopL  = (1<<1),
    TopC  = (1<<2),
    TopR  = (1<<3),
Stephan Kulow's avatar
Stephan Kulow committed
380

381
382
383
384
385
    LeftT = (1<<5),
    Int11 = (1<<6),
    Int12 = (1<<7),
    Int13 = (1<<8),
    RightT = (1<<9),
Stephan Kulow's avatar
Stephan Kulow committed
386

387
388
389
390
391
    LeftC = (1<<10),
    Int21 = (1<<11),
    Int22 = (1<<12),
    Int23 = (1<<13),
    RightC = (1<<14),
Stephan Kulow's avatar
Stephan Kulow committed
392

393
394
395
396
397
    LeftB = (1<<15),
    Int31 = (1<<16),
    Int32 = (1<<17),
    Int33 = (1<<18),
    RightB = (1<<19),
Stephan Kulow's avatar
Stephan Kulow committed
398

399
400
    BotL  = (1<<21),
    BotC  = (1<<22),
Dirk Mueller's avatar
Dirk Mueller committed
401
    BotR  = (1<<23)
402
403
};

404
#include "LineFont.h"
405
406
407
408
409
410
411
412
413

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;

414
    quint32 toDraw = LineChars[code];
Stephan Kulow's avatar
Stephan Kulow committed
415

416
    //Top _lines:
417
418
419
420
421
422
423
    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);

424
    //Bot _lines:
425
426
427
428
429
430
431
    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);

432
    //Left _lines:
433
434
435
436
437
438
439
    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);

440
    //Right _lines:
441
442
443
444
445
446
    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);
Stephan Kulow's avatar
Stephan Kulow committed
447

448
449
450
451
452
453
454
    //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);
Stephan Kulow's avatar
Stephan Kulow committed
455

456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
    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);

}

472
void TerminalDisplay::drawLineCharString(	QPainter& painter, int x, int y, const QString& str, 
473
									const Character* attributes)
474
475
476
{
		const QPen& currentPen = painter.pen();
		
477
		if ( attributes->rendition & RE_BOLD )
478
479
480
481
482
483
484
485
486
487
		{
			QPen boldPen(currentPen);
			boldPen.setWidth(3);
			painter.setPen( boldPen );
		}	
		
		for (int i=0 ; i < str.length(); i++)
		{
			uchar code = str[i].cell();
        	if (LineChars[code])
488
            	drawLineChar(painter, x + (_fontWidth*i), y, _fontWidth, _fontHeight, code);
489
490
491
492
493
		}

		painter.setPen( currentPen );
}

494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
void TerminalDisplay::setKeyboardCursorShape(KeyboardCursorShape shape)
{
    _cursorShape = shape;
}
TerminalDisplay::KeyboardCursorShape TerminalDisplay::keyboardCursorShape() const
{
    return _cursorShape;
}
void TerminalDisplay::setKeyboardCursorColor(bool useForegroundColor, const QColor& color)
{
    if (useForegroundColor)
        _cursorColor = QColor(); // an invalid color means that
                                 // the foreground color of the
                                 // current character should
                                 // be used

    else
        _cursorColor = color;
}
QColor TerminalDisplay::keyboardCursorColor() const
{
    return _cursorColor;
}
517

518
519
520
521
void TerminalDisplay::setOpacity(qreal opacity)
{
    QColor color(_blendColor);
    color.setAlphaF(opacity);
522
523
524
525
526
527
528
529
530
531
532
533

    // enable automatic background filling to prevent the display
    // flickering if there is no transparency
    /*if ( color.alpha() == 255 ) 
    {
        setAutoFillBackground(true);
    }
    else
    {
        setAutoFillBackground(false);
    }*/

534
535
536
    _blendColor = color.rgba();
}

Robert Knight's avatar
   
Robert Knight committed
537
void TerminalDisplay::drawBackground(QPainter& painter, const QRect& rect, const QColor& backgroundColor, bool useOpacitySetting )
538
{
539
540
541
542
543
544
545
546
        // 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.  
        //
547
548
549
        QRect scrollBarArea = _scrollBar->isVisible() ? 
                                    rect.intersected(_scrollBar->geometry()) :
                                    QRect();
550
551
552
        QRegion contentsRegion = QRegion(rect).subtracted(scrollBarArea);
        QRect contentsRect = contentsRegion.boundingRect();

Robert Knight's avatar
   
Robert Knight committed
553
        if ( HAVE_TRANSPARENCY && qAlpha(_blendColor) < 0xff && useOpacitySetting ) 
554
555
556
557
558
559
        {
            QColor color(backgroundColor);
            color.setAlpha(qAlpha(_blendColor));

            painter.save();
            painter.setCompositionMode(QPainter::CompositionMode_Source);
560
            painter.fillRect(contentsRect, color);
561
562
563
            painter.restore();
        } 
        else
564
565
566
            painter.fillRect(contentsRect, backgroundColor);

        painter.fillRect(scrollBarArea,_scrollBar->palette().background());
567
568
}

569
570
571
572
573
574
575
576
577
578
579
580
581
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);
582
583
       else
           painter.setPen(foregroundColor);
584
585
586

       if ( _cursorShape == BlockCursor )
       {
587
588
589
590
591
592
593
594
            // 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));
595
596
597
            if ( hasFocus() )
            {
                painter.fillRect(cursorRect, _cursorColor.isValid() ? _cursorColor : foregroundColor);
598
599
600
601
602
603
604
            
                if ( !_cursorColor.isValid() )
                {
                    // invert the colour used to draw the text to ensure that the character at
                    // the cursor position is readable
                    invertCharacterColor = true;
                }
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
            }
       }
       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)
{
    // don't draw text which is currently blinking
    if ( _blinking && (style->rendition & RE_BLINK) )
            return;
   
Robert Knight's avatar
   
Robert Knight committed
631
    // setup bold and underline
632
633
    bool useBold = style->rendition & RE_BOLD || style->isBold(_colorTable) || font().bold();
    bool useUnderline = style->rendition & RE_UNDERLINE || font().underline();
Robert Knight's avatar
   
Robert Knight committed
634

635
    QFont font = painter.font();
Robert Knight's avatar
   
Robert Knight committed
636
637
    if (    font.bold() != useBold 
         || font.underline() != useUnderline )
638
639
    {
       font.setBold(useBold);
Robert Knight's avatar
   
Robert Knight committed
640
       font.setUnderline(useUnderline);
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
       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 )
    {
        pen.setColor(color);
        painter.setPen(color);
    }

    // draw text
    if ( isLineCharString(text) )
	  	drawLineCharString(painter,rect.x(),rect.y(),text,style);
    else
Robert Knight's avatar
   
Robert Knight committed
658
659
660
661
662
663
664
665
	{
		// 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
        painter.drawText(rect,0,text);
	}
666
667
668
669
670
671
672
673
674
675
676
677
678
679
}

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
680
    if ( backgroundColor != palette().background().color() )
Robert Knight's avatar
   
Robert Knight committed
681
682
        drawBackground(painter,rect,backgroundColor,
					   false /* do not use transparency */);
683
684
685
686
687
688
689
690
691
692
693
694
695

    // 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();
}

696
697
698
void TerminalDisplay::setRandomSeed(uint randomSeed) { _randomSeed = randomSeed; }
uint TerminalDisplay::randomSeed() const { return _randomSeed; }

699
#if 0
Waldo Bastian's avatar
Waldo Bastian committed
700
701
702
/*!
    Set XIM Position
*/
703
void TerminalDisplay::setCursorPos(const int curx, const int cury)
Waldo Bastian's avatar
Waldo Bastian committed
704
705
706
707
708
709
{
    QPoint tL  = contentsRect().topLeft();
    int    tLx = tL.x();
    int    tLy = tL.y();

    int xpos, ypos;
Robert Knight's avatar
   
Robert Knight committed
710
711
    ypos = _topMargin + tLy + _fontHeight*(cury-1) + _fontAscent;
    xpos = _leftMargin + tLx + _fontWidth*curx;
712
    //setMicroFocusHint(xpos, ypos, 0, _fontHeight); //### ???
Waldo Bastian's avatar
Waldo Bastian committed
713
    // fprintf(stderr, "x/y = %d/%d\txpos/ypos = %d/%d\n", curx, cury, xpos, ypos);
714
715
    _cursorLine = cury;
    _cursorCol = curx;
Waldo Bastian's avatar
Waldo Bastian committed
716
}
717
#endif
Waldo Bastian's avatar
Waldo Bastian committed
718

719
// scrolls the image by 'lines', down if lines > 0 or up otherwise.
720
//
721
// the terminal emulation keeps track of the scrolling of the character 
722
// image as it receives input, and when the view is updated, it calls scrollImage() 
723
// with the final scroll amount.  this improves performance because scrolling the 
724
725
726
// 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
727
void TerminalDisplay::scrollImage(int lines , const QRect& screenWindowRegion)
728
{
Robert Knight's avatar
   
Robert Knight committed
729
730
731
732
733
734
	// if the flow control warning is enabled this will interfere with the 
	// scrolling optimisations and cause artifacts.  the simple solution here
	// is to just disable the optimisation whilst it is visible
	if ( _outputSuspendedLabel && _outputSuspendedLabel->isVisible() )
		return;

735
736
737
738
739
740
741
    // 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) ); 

742
	// return if there is nothing to do
743
    if (    lines == 0 
744
745
746
747
748
         || _image == 0
         || !region.isValid() 
         || (region.top() + abs(lines)) >= region.bottom() 
         || this->_lines <= region.height() ) return;

749
750
751
	// hide terminal size label to prevent it being scrolled
	if (_resizeWidget->isVisible())
		_resizeWidget->hide();
752

753
754
755
756
757
758
759
760
761
762
	// 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 the left edge of the scroll bar to 
	// avoid triggering a repaint of the entire widget.  
	//
	// Set the QT_FLUSH_PAINT environment variable to '1' before starting the
	// application to monitor repainting.
	//
	int scrollBarWidth = _scrollBar->isHidden() ? 0 : _scrollBar->width();
763
    QRect scrollRect;
764
765
	scrollRect.setLeft(0);
	scrollRect.setRight(width() - scrollBarWidth - 1);
766

767
768
    void* firstCharPos = &_image[ region.top() * this->_columns ];
    void* lastCharPos = &_image[ (region.top() + abs(lines)) * this->_columns ];
769

Robert Knight's avatar
   
Robert Knight committed
770
    int top = _topMargin + (region.top() * _fontHeight);
771
772
    int linesToMove = region.height() - abs(lines);
    int bytesToMove = linesToMove * 
773
                      this->_columns *
774
775
776
777
778
                      sizeof(Character);

    Q_ASSERT( linesToMove > 0 );
    Q_ASSERT( bytesToMove > 0 );

779
    //scroll internal image
780
    if ( lines > 0 )
781
    {
782
783
        // check that the memory areas that we are going to move are valid
        Q_ASSERT( (char*)lastCharPos + bytesToMove < 
784
                  (char*)(_image + (this->_lines * this->_columns)) );
785
        
786
        Q_ASSERT( (lines*this->_columns) < _imageSize ); 
787

788
        //scroll internal image down
789
790
        memmove( firstCharPos , lastCharPos , bytesToMove ); 
      
791
792
        //set region of display to scroll
        scrollRect.setTop(top);
793
794
795
    }
    else
    {
796
797
        // check that the memory areas that we are going to move are valid
        Q_ASSERT( (char*)firstCharPos + bytesToMove < 
798
                  (char*)(_image + (this->_lines * this->_columns)) );
799
800

        //scroll internal image up
801
802
        memmove( lastCharPos , firstCharPos , bytesToMove ); 
     
803
804
        //set region of the display to scroll
        scrollRect.setTop(top + abs(lines) * _fontHeight); 
805
    }
806
    scrollRect.setHeight(linesToMove * _fontHeight );
807

808
809
	Q_ASSERT(scrollRect.isValid() && !scrollRect.isEmpty());

810
    //scroll the display vertically to match internal _image
811
    scroll( 0 , _fontHeight * (-lines) , scrollRect );
812
}
813

814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
QRegion TerminalDisplay::hotSpotRegion() const 
{
	QRegion region;
	foreach( Filter::HotSpot* hotSpot , _filterChain->hotSpots() )
	{
		QRect rect;
		rect.setLeft(hotSpot->startColumn());
		rect.setTop(hotSpot->startLine());
		rect.setRight(hotSpot->endColumn());
		rect.setBottom(hotSpot->endLine());

		region |= imageToWidget(rect); 
	}
	return region;
}

830
void TerminalDisplay::processFilters() 
831
{
832
833
834
	if (!_screenWindow)
		return;

835
	QRegion preUpdateHotSpots = hotSpotRegion();
836

837
838
839
840
841
	// 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
842
843
844
845
	_filterChain->setImage( _screenWindow->getImage(),
							_screenWindow->windowLines(),
							_screenWindow->windowColumns(),
							_screenWindow->getLineProperties() );
846
    _filterChain->process();
847
848
849
850

	QRegion postUpdateHotSpots = hotSpotRegion();

	update( preUpdateHotSpots | postUpdateHotSpots );
851
852
}

853
void TerminalDisplay::updateImage() 
854
{
855
856
857
  if ( !_screenWindow )
      return;

858
859
  // optimization - scroll the existing image where possible and 
  // avoid expensive text drawing for parts of the image that 
Robert Knight's avatar
   
Robert Knight committed
860
  // can simply be moved up or down
861
862
  scrollImage( _screenWindow->scrollCount() ,
               _screenWindow->scrollRegion() );
863
864
  _screenWindow->resetScrollCount();

865
  Character* const newimg = _screenWindow->getImage();
866
867
  int lines = _screenWindow->windowLines();
  int columns = _screenWindow->windowColumns();
868
869
870

  setScroll( _screenWindow->currentLine() , _screenWindow->lineCount() );

871
872
  if (!_image)
     updateImageSize(); // Create _image
873

874
875
  Q_ASSERT( this->_usedLines <= this->_lines );
  Q_ASSERT( this->_usedColumns <= this->_columns );
876

877
  int y,x,len;
878
879
880
881

  QPoint tL  = contentsRect().topLeft();
  int    tLx = tL.x();
  int    tLy = tL.y();
882
  _hasBlinker = false;
883

884
  CharacterColor cf;       // undefined
885
  CharacterColor _clipboard;       // undefined
886
  int cr  = -1;   // undefined
887

888
889
  const int linesToUpdate = qMin(this->_lines, qMax(0,lines  ));
  const int columnsToUpdate = qMin(this->_columns,qMax(0,columns));
890

891
  QChar *disstrU = new QChar[columnsToUpdate];
892
  char *dirtyMask = new char[columnsToUpdate+2]; 
893
  QRegion dirtyRegion;
894

895
  // debugging variable, this records the number of lines that are found to
896
  // be 'dirty' ( ie. have changed from the old _image to the new _image ) and
Robert Knight's avatar
   
Robert Knight committed
897
  // which therefore need to be repainted
898
899
  int dirtyLineCount = 0;

900
  for (y = 0; y < linesToUpdate; y++)
901
  {
902
    const Character*       currentLine = &_image[y*this->_columns];
903
    const Character* const newLine = &newimg[y*columns];
904

905
906
    bool updateLine = false;
    
907
    // The dirty mask indicates which characters need repainting. We also
Waldo Bastian's avatar
Waldo Bastian committed
908
909
    // mark surrounding neighbours dirty, in case the character exceeds
    // its cell boundaries
910
    memset(dirtyMask, 0, columnsToUpdate+2);
911
912
   
    for( x = 0 ; x < columnsToUpdate ; x++)
Waldo Bastian's avatar
Waldo Bastian committed
913
    {
914
915
916
917
        if ( newLine[x] != currentLine[x] ) 
        {
            dirtyMask[x] = true;
        }
Waldo Bastian's avatar
Waldo Bastian committed
918
    }
919

920
    if (!_resizing) // not while _resizing, we're expecting a paintEvent
921
    for (x = 0; x < columnsToUpdate; x++)
922
    {
923
      _hasBlinker |= (newLine[x].rendition & RE_BLINK);
924
    
Waldo Bastian's avatar
Waldo Bastian committed
925
926
927
928
      // 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])
929
      {
930
        quint16 c = newLine[x+0].character;
931
932
933
        if ( !c )
            continue;
        int p = 0;
Stephan Binner's avatar
Stephan Binner committed
934
        disstrU[p++] = c; //fontMap(c);
935
        bool lineDraw = isLineChar(c);
936
        bool doubleWidth = (x+1 == columnsToUpdate) ? false : (newLine[x+1].character == 0);
937
        cr = newLine[x].rendition;
938
        _clipboard = newLine[x].backgroundColor;
939
        if (newLine[x].foregroundColor != cf) cf = newLine[x].foregroundColor;
940
        int lln = columnsToUpdate - x;
941
942
        for (len = 1; len < lln; len++)
        {
Robert Knight's avatar
   
Robert Knight committed
943
            const Character& ch = newLine[x+len];
944

Robert Knight's avatar
   
Robert Knight committed
945
946
947
            if (!ch.character)
                continue; // Skip trailing part of multi-col chars.

948
949
			bool nextIsDoubleWidth = (x+len+1 == columnsToUpdate) ? false : (newLine[x+len+1].character == 0);

Robert Knight's avatar
   
Robert Knight committed
950
            if (  ch.foregroundColor != cf || 
951
                  ch.backgroundColor != _clipboard || 
Robert Knight's avatar
   
Robert Knight committed
952
953
954
                  ch.rendition != cr ||
                  !dirtyMask[x+len] || 
                  isLineChar(c) != lineDraw || 
955
                  nextIsDoubleWidth != doubleWidth )
956
            break;
957

Stephan Binner's avatar
Stephan Binner committed
958
          disstrU[p++] = c; //fontMap(c);
959
        }
960
961

        QString unistr(disstrU, p);
962

Robert Knight's avatar
   
Robert Knight committed
963
        bool saveFixedFont = _fixedFont;
964
        if (lineDraw)
965
           _fixedFont = false;
966
        if (doubleWidth)
967
           _fixedFont = false;
968

969
		updateLine = true;
970

Robert Knight's avatar
   
Robert Knight committed
971
		_fixedFont = saveFixedFont;
972
973
        x += len - 1;
      }
974
      
975
    }
976

977
	//both the top and bottom halves of double height _lines must always be redrawn
Robert Knight's avatar
   
Robert Knight committed
978
979
	//although both top and bottom halves contain the same characters, only 
    //the top one is actually 
980
	//drawn.
981
982
    if (_lineProperties.count() > y)
        updateLine |= (_lineProperties[y] & LINE_DOUBLEHEIGHT);
Robert Knight's avatar
   
Robert Knight committed
983

984
    // if the characters on the line are different in the old and the new _image
Robert Knight's avatar
   
Robert Knight committed
985
    // then this line must be repainted.    
986
987
    if (updateLine)
    {
988
        dirtyLineCount++;
Robert Knight's avatar
   
Robert Knight committed
989
990
991

        // add the area occupied by this line to the region which needs to be
        // repainted
Robert Knight's avatar
   
Robert Knight committed
992
993
        QRect dirtyRect = QRect( _leftMargin+tLx , 
                                 _topMargin+tLy+_fontHeight*y , 
994
995
                                 _fontWidth * columnsToUpdate , 
                                 _fontHeight );