TerminalDisplay.cpp 85.7 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
124
125
126
127
128
129
130
131
132
133
134
135
136
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();
}
void TerminalDisplay::setForegroundColor(const QColor& color)
{
	_colorTable[DEFAULT_FORE_COLOR].color = color;
137

138
139
	update();
}
140
void TerminalDisplay::setColorTable(const ColorEntry table[])
141
{
Robert Knight's avatar
   
Robert Knight committed
142
143
  for (int i = 0; i < TABLE_COLORS; i++)
      _colorTable[i] = table[i];
144

145
  setBackgroundColor(_colorTable[DEFAULT_BACK_COLOR].color);
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
}

/* ------------------------------------------------------------------------- */
/*                                                                           */
/*                                   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.
*/

166
static inline bool isLineChar(quint16 c) { return ((c & 0xFF80) == 0x2500);}
167
168
169
170
171
static inline bool isLineCharString(const QString& string)
{
		return (string.length() > 0) && (isLineChar(string.at(0).unicode()));
}
						
172

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

175
unsigned short Konsole::vt100_graphics[32] =
176
177
178
179
180
181
182
{ // 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
};

183
void TerminalDisplay::fontChange(const QFont&)
184
185
{
  QFontMetrics fm(font());
186
  _fontHeight = fm.height() + _lineSpacing;
187

188
  // waba TerminalDisplay 1.123:
189
190
  // "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
191
  // Get the width from representative normal width characters
192
  _fontWidth = qRound((double)fm.width(REPCHAR)/(double)strlen(REPCHAR));
Waldo Bastian's avatar
Waldo Bastian committed
193

194
  _fixedFont = true;
195

196
  int fw = fm.width(REPCHAR[0]);
197
198
199
200
  for(unsigned int i=1; i< strlen(REPCHAR); i++)
  {
    if (fw != fm.width(REPCHAR[i]))
    {
201
      _fixedFont = false;
Waldo Bastian's avatar
Waldo Bastian committed
202
      break;
203
    }
204
  }
Stephan Kulow's avatar
Stephan Kulow committed
205

206
  if (_fontWidth < 1)
207
    _fontWidth=1;
208

209
  _fontAscent = fm.ascent();
210

211
  emit changedFontMetricSignal( _fontHeight, _fontWidth );
212
213
214
215
  propagateSize();
  update();
}

216
void TerminalDisplay::setVTFont(const QFont& f)
217
{
218
  QFont font = f;
Robert Knight's avatar
Robert Knight committed
219
220
221

  QFontMetrics metrics(font);

222
223
224
225
226
  if ( !QFontInfo(font).fixedPitch() )
  {
	  kWarning() << "Using an unsupported variable-width font in the terminal.  This may produce display errors.";
  }

Robert Knight's avatar
Robert Knight committed
227
228
  if ( metrics.height() < height() && metrics.maxWidth() < width() )
  {
229
230
231
    // 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
232
        font.setStyleStrategy( QFont::NoAntialias );
Robert Knight's avatar
   
Robert Knight committed
233
234
235
236
237
238
 
    // 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);

239
    QWidget::setFont(font);
Robert Knight's avatar
Robert Knight committed
240
241
    fontChange(font);
  }
242
243
}

244
void TerminalDisplay::setFont(const QFont &)
245
246
247
248
249
250
251
252
253
254
{
  // ignore font change request if not coming from konsole itself
}

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

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

304
  // The offsets are not yet calculated.
305
  // Do not calculate these too often to be more smoothly when resizing
306
  // konsole in opaque mode.
Robert Knight's avatar
   
Robert Knight committed
307
308
  _topMargin = DEFAULT_TOP_MARGIN;
  _leftMargin = DEFAULT_LEFT_MARGIN;
309

310
311
  // 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
312
  _scrollBar = new QScrollBar(this);
313
  setScroll(0,0); 
314
  _scrollBar->setCursor( Qt::ArrowCursor );
Robert Knight's avatar
   
Robert Knight committed
315
316
  connect(_scrollBar, SIGNAL(valueChanged(int)), this, 
  					  SLOT(scrollBarPositionChanged(int)));
317

Robert Knight's avatar
   
Robert Knight committed
318
  // setup timers for blinking cursor and text
319
320
321
322
  _blinkTimer   = new QTimer(this);
  connect(_blinkTimer, SIGNAL(timeout()), this, SLOT(blinkEvent()));
  _blinkCursorTimer   = new QTimer(this);
  connect(_blinkCursorTimer, SIGNAL(timeout()), this, SLOT(blinkCursorEvent()));
323

Robert Knight's avatar
   
Robert Knight committed
324
325
  KCursor::setAutoHideCursor( this, true );
  
Robert Knight's avatar
   
Robert Knight committed
326
  setUsesMouse(true);
327
  setColorTable(base_color_table); 
328
329
  setMouseTracking(true);

Robert Knight's avatar
   
Robert Knight committed
330
  // Enable drag and drop 
331
  setAcceptDrops(true); // attempt
332
  dragInfo.state = diNone;
333

334
  setFocusPolicy( Qt::WheelFocus );
335
336

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

Robert Knight's avatar
Robert Knight committed
339
  // this is an important optimization, it tells Qt
340
341
  // that TerminalDisplay will handle repainting its entire area.
  setAttribute(Qt::WA_OpaquePaintEvent);
342

343
344
  _gridLayout = new QGridLayout(this);
  _gridLayout->setMargin(0);
345

346
  setLayout( _gridLayout ); 
347
348
349

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

  new AutoScrollHandler(this);
352
353
}

354
TerminalDisplay::~TerminalDisplay()
355
356
{
  qApp->removeEventFilter( this );
357
  
358
  delete[] _image;
359

360
361
  delete _gridLayout;
  delete _outputSuspendedLabel;
362
  delete _filterChain;
363
364
365
366
367
368
369
370
}

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

371
372
373
374
375
/**
 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
376

377
378
379
380
381
382
383
384
385
386
387
 Then, the pixels basically have the following interpretation:
 _|||_
 -...-
 -...-
 -...-
 _|||_

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

389
390
391
392
393
394

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

396
397
398
399
400
    LeftT = (1<<5),
    Int11 = (1<<6),
    Int12 = (1<<7),
    Int13 = (1<<8),
    RightT = (1<<9),
Stephan Kulow's avatar
Stephan Kulow committed
401

402
403
404
405
406
    LeftC = (1<<10),
    Int21 = (1<<11),
    Int22 = (1<<12),
    Int23 = (1<<13),
    RightC = (1<<14),
Stephan Kulow's avatar
Stephan Kulow committed
407

408
409
410
411
412
    LeftB = (1<<15),
    Int31 = (1<<16),
    Int32 = (1<<17),
    Int33 = (1<<18),
    RightB = (1<<19),
Stephan Kulow's avatar
Stephan Kulow committed
413

414
415
    BotL  = (1<<21),
    BotC  = (1<<22),
Dirk Mueller's avatar
Dirk Mueller committed
416
    BotR  = (1<<23)
417
418
};

419
#include "LineFont.h"
420
421
422
423
424
425
426
427
428

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;

429
    quint32 toDraw = LineChars[code];
Stephan Kulow's avatar
Stephan Kulow committed
430

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

439
    //Bot _lines:
440
441
442
443
444
445
446
    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);

447
    //Left _lines:
448
449
450
451
452
453
454
    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);

455
    //Right _lines:
456
457
458
459
460
461
    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
462

463
464
465
466
467
468
469
    //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
470

471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
    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);

}

487
void TerminalDisplay::drawLineCharString(	QPainter& painter, int x, int y, const QString& str, 
488
									const Character* attributes)
489
490
491
{
		const QPen& currentPen = painter.pen();
		
492
		if ( attributes->rendition & RE_BOLD )
493
494
495
496
497
498
499
500
501
502
		{
			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])
503
            	drawLineChar(painter, x + (_fontWidth*i), y, _fontWidth, _fontHeight, code);
504
505
506
507
508
		}

		painter.setPen( currentPen );
}

509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
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;
}
532

533
534
535
536
void TerminalDisplay::setOpacity(qreal opacity)
{
    QColor color(_blendColor);
    color.setAlphaF(opacity);
537
538
539
540
541
542
543
544
545
546
547
548

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

549
550
551
    _blendColor = color.rgba();
}

Robert Knight's avatar
   
Robert Knight committed
552
void TerminalDisplay::drawBackground(QPainter& painter, const QRect& rect, const QColor& backgroundColor, bool useOpacitySetting )
553
{
554
555
556
557
558
559
560
561
        // 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.  
        //
562
563
564
        QRect scrollBarArea = _scrollBar->isVisible() ? 
                                    rect.intersected(_scrollBar->geometry()) :
                                    QRect();
565
566
567
        QRegion contentsRegion = QRegion(rect).subtracted(scrollBarArea);
        QRect contentsRect = contentsRegion.boundingRect();

Robert Knight's avatar
   
Robert Knight committed
568
        if ( HAVE_TRANSPARENCY && qAlpha(_blendColor) < 0xff && useOpacitySetting ) 
569
570
571
572
573
574
        {
            QColor color(backgroundColor);
            color.setAlpha(qAlpha(_blendColor));

            painter.save();
            painter.setCompositionMode(QPainter::CompositionMode_Source);
575
            painter.fillRect(contentsRect, color);
576
577
578
            painter.restore();
        } 
        else
579
580
581
            painter.fillRect(contentsRect, backgroundColor);

        painter.fillRect(scrollBarArea,_scrollBar->palette().background());
582
583
}

584
585
586
587
588
589
590
591
592
593
594
595
596
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);
597
598
       else
           painter.setPen(foregroundColor);
599
600
601

       if ( _cursorShape == BlockCursor )
       {
602
603
604
605
606
607
608
609
            // 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));
610
611
612
            if ( hasFocus() )
            {
                painter.fillRect(cursorRect, _cursorColor.isValid() ? _cursorColor : foregroundColor);
613
614
615
616
617
618
619
            
                if ( !_cursorColor.isValid() )
                {
                    // invert the colour used to draw the text to ensure that the character at
                    // the cursor position is readable
                    invertCharacterColor = true;
                }
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
            }
       }
       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
646
    // setup bold and underline
647
648
    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
649

650
    QFont font = painter.font();
Robert Knight's avatar
   
Robert Knight committed
651
652
    if (    font.bold() != useBold 
         || font.underline() != useUnderline )
653
654
    {
       font.setBold(useBold);
Robert Knight's avatar
   
Robert Knight committed
655
       font.setUnderline(useUnderline);
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
       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) )
671
        drawLineCharString(painter,rect.x(),rect.y(),text,style);
672
    else
673
674
675
676
677
678
679
680
681
682
683
    {
        // 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
        if (_bidiEnabled)
            painter.drawText(rect,0,text);
        else
            painter.drawText(rect,0,QChar(0x202D)+text);
    }
684
685
686
687
688
689
690
691
692
693
694
695
696
697
}

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
698
    if ( backgroundColor != palette().background().color() )
Robert Knight's avatar
   
Robert Knight committed
699
700
        drawBackground(painter,rect,backgroundColor,
					   false /* do not use transparency */);
701
702
703
704
705
706
707
708
709
710
711
712
713

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

714
715
716
void TerminalDisplay::setRandomSeed(uint randomSeed) { _randomSeed = randomSeed; }
uint TerminalDisplay::randomSeed() const { return _randomSeed; }

717
#if 0
Waldo Bastian's avatar
Waldo Bastian committed
718
719
720
/*!
    Set XIM Position
*/
721
void TerminalDisplay::setCursorPos(const int curx, const int cury)
Waldo Bastian's avatar
Waldo Bastian committed
722
723
724
725
726
727
{
    QPoint tL  = contentsRect().topLeft();
    int    tLx = tL.x();
    int    tLy = tL.y();

    int xpos, ypos;
Robert Knight's avatar
   
Robert Knight committed
728
729
    ypos = _topMargin + tLy + _fontHeight*(cury-1) + _fontAscent;
    xpos = _leftMargin + tLx + _fontWidth*curx;
730
    //setMicroFocusHint(xpos, ypos, 0, _fontHeight); //### ???
Waldo Bastian's avatar
Waldo Bastian committed
731
    // fprintf(stderr, "x/y = %d/%d\txpos/ypos = %d/%d\n", curx, cury, xpos, ypos);
732
733
    _cursorLine = cury;
    _cursorCol = curx;
Waldo Bastian's avatar
Waldo Bastian committed
734
}
735
#endif
Waldo Bastian's avatar
Waldo Bastian committed
736

737
// scrolls the image by 'lines', down if lines > 0 or up otherwise.
738
//
739
// the terminal emulation keeps track of the scrolling of the character 
740
// image as it receives input, and when the view is updated, it calls scrollImage() 
741
// with the final scroll amount.  this improves performance because scrolling the 
742
743
744
// 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
745
void TerminalDisplay::scrollImage(int lines , const QRect& screenWindowRegion)
746
{
Robert Knight's avatar
   
Robert Knight committed
747
748
749
750
751
752
	// 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;

753
754
755
756
757
758
759
    // 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) ); 

760
	// return if there is nothing to do
761
    if (    lines == 0 
762
763
764
765
766
         || _image == 0
         || !region.isValid() 
         || (region.top() + abs(lines)) >= region.bottom() 
         || this->_lines <= region.height() ) return;

767
	// hide terminal size label to prevent it being scrolled
768
	if (_resizeWidget && _resizeWidget->isVisible())
769
		_resizeWidget->hide();
770

771
772
773
774
775
776
777
778
779
780
	// 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();
781
    QRect scrollRect;
782
783
	scrollRect.setLeft(0);
	scrollRect.setRight(width() - scrollBarWidth - 1);
784

785
786
    void* firstCharPos = &_image[ region.top() * this->_columns ];
    void* lastCharPos = &_image[ (region.top() + abs(lines)) * this->_columns ];
787

Robert Knight's avatar
   
Robert Knight committed
788
    int top = _topMargin + (region.top() * _fontHeight);
789
790
    int linesToMove = region.height() - abs(lines);
    int bytesToMove = linesToMove * 
791
                      this->_columns *
792
793
794
795
796
                      sizeof(Character);

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

797
    //scroll internal image
798
    if ( lines > 0 )
799
    {
800
801
        // check that the memory areas that we are going to move are valid
        Q_ASSERT( (char*)lastCharPos + bytesToMove < 
802
                  (char*)(_image + (this->_lines * this->_columns)) );
803
        
804
        Q_ASSERT( (lines*this->_columns) < _imageSize ); 
805

806
        //scroll internal image down
807
808
        memmove( firstCharPos , lastCharPos , bytesToMove ); 
      
809
810
        //set region of display to scroll
        scrollRect.setTop(top);
811
812
813
    }
    else
    {
814
815
        // check that the memory areas that we are going to move are valid
        Q_ASSERT( (char*)firstCharPos + bytesToMove < 
816
                  (char*)(_image + (this->_lines * this->_columns)) );
817
818

        //scroll internal image up
819
820
        memmove( lastCharPos , firstCharPos , bytesToMove ); 
     
821
822
        //set region of the display to scroll
        scrollRect.setTop(top + abs(lines) * _fontHeight); 
823
    }
824
    scrollRect.setHeight(linesToMove * _fontHeight );
825

826
827
	Q_ASSERT(scrollRect.isValid() && !scrollRect.isEmpty());

828
    //scroll the display vertically to match internal _image
829
    scroll( 0 , _fontHeight * (-lines) , scrollRect );
830
}
831

832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
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;
}

848
void TerminalDisplay::processFilters() 
849
{
850
851
852
	if (!_screenWindow)
		return;

853
	QRegion preUpdateHotSpots = hotSpotRegion();
854

855
856
857
858
859
	// 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
860
861
862
863
	_filterChain->setImage( _screenWindow->getImage(),
							_screenWindow->windowLines(),
							_screenWindow->windowColumns(),
							_screenWindow->getLineProperties() );
864
    _filterChain->process();
865
866
867
868

	QRegion postUpdateHotSpots = hotSpotRegion();

	update( preUpdateHotSpots | postUpdateHotSpots );
869
870
}

871
void TerminalDisplay::updateImage() 
872
{
873
874
875
  if ( !_screenWindow )
      return;

876
877
  // 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
878
  // can simply be moved up or down
879
880
  scrollImage( _screenWindow->scrollCount() ,
               _screenWindow->scrollRegion() );
881
882
  _screenWindow->resetScrollCount();

883
  Character* const newimg = _screenWindow->getImage();
884
885
  int lines = _screenWindow->windowLines();
  int columns = _screenWindow->windowColumns();
886
887
888

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

889
890
  if (!_image)
     updateImageSize(); // Create _image
891

892
893
  Q_ASSERT( this->_usedLines <= this->_lines );
  Q_ASSERT( this->_usedColumns <= this->_columns );
894

895
  int y,x,len;
896
897
898
899

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

902
  CharacterColor cf;       // undefined
903
  CharacterColor _clipboard;       // undefined
904
  int cr  = -1;   // undefined
905

906
907
  const int linesToUpdate = qMin(this->_lines, qMax(0,lines  ));
  const int columnsToUpdate = qMin(this->_columns,qMax(0,columns));
908

909
  QChar *disstrU = new QChar[columnsToUpdate];
910
  char *dirtyMask = new char[columnsToUpdate+2]; 
911
  QRegion dirtyRegion;
912

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

918
  for (y = 0; y < linesToUpdate; y++)
919
  {
920
    const Character*       currentLine = &_image[y*this->_columns];
921
    const Character* const newLine = &newimg[y*columns];
922

923
924
    bool updateLine = false;
    
925
    // The dirty mask indicates which characters need repainting. We also
Waldo Bastian's avatar
Waldo Bastian committed
926
927
    // mark surrounding neighbours dirty, in case the character exceeds
    // its cell boundaries
928
    memset(dirtyMask, 0, columnsToUpdate+2);
929
930
   
    for( x = 0 ; x < columnsToUpdate ; x++)
Waldo Bastian's avatar
Waldo Bastian committed
931
    {
932
933
934
935
        if ( newLine[x] != currentLine[x] ) 
        {
            dirtyMask[x] = true;
        }
Waldo Bastian's avatar
Waldo Bastian committed
936
    }
937

938
    if (!_resizing) // not while _resizing, we're expecting a paintEvent
939
    for (x = 0; x < columnsToUpdate; x++)
940
    {
941
      _hasBlinker |= (newLine[x].rendition & RE_BLINK);
942
    
Waldo Bastian's avatar
Waldo Bastian committed
943
944
945
946
      // 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])
947
      {
948
        quint16 c = newLine[x+0].character;
949
950
951
        if ( !c )
            continue;
        int p = 0;
Stephan Binner's avatar
Stephan Binner committed
952
        disstrU[p++] = c; //fontMap(c);
953
        bool lineDraw = isLineChar(c);
954
        bool doubleWidth = (x+1 == columnsToUpdate) ? false : (newLine[x+1].character == 0);
955
        cr = newLine[x].rendition;
956
        _clipboard = newLine[x].backgroundColor;
957
        if (newLine[x].foregroundColor != cf) cf = newLine[x].foregroundColor;
958
        int lln = columnsToUpdate - x;
959
960
        for (len = 1; len < lln; len++)
        {
Robert Knight's avatar
   
Robert Knight committed
961
            const Character& ch = newLine[x+len];
962

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

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

Robert Knight's avatar
   
Robert Knight committed
968
            if (  ch.foregroundColor != cf || 
969
                  ch.backgroundColor != _clipboard || 
Robert Knight's avatar
   
Robert Knight committed
970
971
972
                  ch.rendition != cr ||
                  !dirtyMask[x+len] || 
                  isLineChar(c) != lineDraw || 
973
                  nextIsDoubleWidth != doubleWidth )
974
            break;
975

Stephan Binner's avatar
Stephan Binner committed
976
          disstrU[p++] = c; //fontMap(c);
977
        }
978
979

        QString unistr(disstrU, p);
980

Robert Knight's avatar
   
Robert Knight committed
981
        bool saveFixedFont = _fixedFont;
982
        if (lineDraw)
983
           _fixedFont = false;
984
        if (doubleWidth)
985
           _fixedFont = false;
986

987
		updateLine = true;
988

Robert Knight's avatar
   
Robert Knight committed
989
		_fixedFont = saveFixedFont;
990
991
        x += len - 1;
      }
992
      
993
    }
994

995
	//both the top and bottom halves of double height _lines must always be redrawn
Robert Knight's avatar
   
Robert Knight committed
996
997
	//although both top and bottom halves contain the same characters, only 
    //the top one is actually 
998
	//drawn.
999
1000
    if (_lineProperties.count() > y)
        updateLine |= (_lineProperties[y] & LINE_DOUBLEHEIGHT);
Robert Knight's avatar
   
Robert Knight committed
1001

1002
    // if the characters on the line are different in the old and the new _image
Robert Knight's avatar
   
Robert Knight committed
1003
    // then this line must be repainted.    
1004
1005
    if (updateLine)
    {
1006
        dirtyLineCount++;
Robert Knight's avatar
   
Robert Knight committed
1007
1008
1009

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

1015
        dirtyRegion |= dirtyRect;
1016
    }
1017

1018
1019
    // replace the line of characters in the old _image with the 
    // current line of the new _image 
1020
    memcpy((void*)currentLine,(const void*)newLine,columnsToUpdate*sizeof(Character));
1021
  }
1022

1023
1024
1025
  // if the new _image is smaller than the previous _image, then ensure that the area
  // outside the new _image is cleared 
  if ( linesToUpdate < _usedLines )