TerminalDisplay.cpp 81.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 <KCursor>
47
#include <kdebug.h>
Robert Knight's avatar
Robert Knight committed
48
#include <KLocale>
49
#include <KMenu>
Robert Knight's avatar
Robert Knight committed
50
51
52
53
54
55
#include <KNotification>
#include <KGlobalSettings>
#include <KShortcut>
#include <KIO/NetAccess>

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

62
63
using namespace Konsole;

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

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

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

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

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

80
81
82
83
84
85
86
87
88
89
90
91
92
93
/* ------------------------------------------------------------------------- */
/*                                                                           */
/*                                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
*/

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

106
    _screenWindow = window;
107

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

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

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

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

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

133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
  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.
*/

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

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

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

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

176
  // waba TerminalDisplay 1.123:
177
178
  // "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
179
  // Get the width from representative normal width characters
180
  _fontWidth = qRound((double)fm.width(REPCHAR)/(double)strlen(REPCHAR));
Waldo Bastian's avatar
Waldo Bastian committed
181

182
  _fixedFont = true;
183

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

194
  if (_fontWidth < 1)
195
    _fontWidth=1;
196

197
  _fontAscent = fm.ascent();
198

199
  emit changedFontMetricSignal( _fontHeight, _fontWidth );
200
201
202
203
  propagateSize();
  update();
}

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

  QFontMetrics metrics(font);

  if ( metrics.height() < height() && metrics.maxWidth() < width() )
  {
212
213
214
    // 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
215
        font.setStyleStrategy( QFont::NoAntialias );
Robert Knight's avatar
   
Robert Knight committed
216
217
218
219
220
221
 
    // 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);

Robert Knight's avatar
Robert Knight committed
222
223
224
    QFrame::setFont(font);
    fontChange(font);
  }
225
226
}

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

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

238
TerminalDisplay::TerminalDisplay(QWidget *parent)
239
:QFrame(parent)
240
,_screenWindow(0)
241
242
243
244
245
246
247
248
249
250
251
252
,_allowBell(true)
,_gridLayout(0)
,_fontHeight(1)
,_fontWidth(1)
,_fontAscent(1)
,_lines(1)
,_columns(1)
,_usedLines(1)
,_usedColumns(1)
,_contentHeight(1)
,_contentWidth(1)
,_image(0)
253
,_randomSeed(0)
254
255
256
257
258
259
260
,_resizing(false)
,_terminalSizeHint(false)
,_terminalSizeStartup(true)
,_bidiEnabled(false)
,_actSel(0)
,_wordSelectionMode(false)
,_lineSelectionMode(false)
261
,_preserveLineBreaks(false)
262
,_columnSelectionMode(false)
263
,_scrollbarLocation(NoScrollBar)
264
,_wordCharacters(":@-./_~")
265
,_bellMode(BELL_SYSTEM)
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
,_blinking(false)
,_cursorBlinking(false)
,_hasBlinkingCursor(false)
,_ctrlDrag(false)
,_cutToBeginningOfLine(false)
,_isFixedSize(false)
,_possibleTripleClick(false)
,_resizeWidget(0)
,_resizeLabel(0)
,_resizeTimer(0)
,_outputSuspendedLabel(0)
,_lineSpacing(0)
,_colorsInverted(false)
,_rimX(1)
,_rimY(1)
,_blendColor(qRgba(0,0,0,0xff))
282
,_filterChain(new TerminalImageFilterChain())
283
,_cursorShape(BlockCursor)
284
{
285

286
  // The offsets are not yet calculated.
287
  // Do not calculate these too often to be more smoothly when resizing
288
  // konsole in opaque mode.
289
  _bY = _bX = 1;
290

291
292
  // 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
293
  _scrollBar = new QScrollBar(this);
294
  setScroll(0,0); 
295
  _scrollBar->setCursor( Qt::ArrowCursor );
296
  connect(_scrollBar, SIGNAL(valueChanged(int)), this, SLOT(scrollBarPositionChanged(int)));
297

298
299
300
301
  _blinkTimer   = new QTimer(this);
  connect(_blinkTimer, SIGNAL(timeout()), this, SLOT(blinkEvent()));
  _blinkCursorTimer   = new QTimer(this);
  connect(_blinkCursorTimer, SIGNAL(timeout()), this, SLOT(blinkCursorEvent()));
302

Robert Knight's avatar
   
Robert Knight committed
303
  setUsesMouse(true);
304
  setColorTable(base_color_table); 
305
306
307

  KCursor::setAutoHideCursor( this, true );

308
309
  setMouseTracking(true);

Robert Knight's avatar
   
Robert Knight committed
310
  // Init DnD 
311
  setAcceptDrops(true); // attempt
312
  dragInfo.state = diNone;
313

314
  setFocusPolicy( Qt::WheelFocus );
315
316

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

Robert Knight's avatar
Robert Knight committed
319
  // this is an important optimization, it tells Qt
320
321
  // that TerminalDisplay will handle repainting its entire area.
  setAttribute(Qt::WA_OpaquePaintEvent);
322

323
324
  _gridLayout = new QGridLayout(this);
  _gridLayout->setMargin(0);
325

326
  setLayout( _gridLayout ); 
327
  setLineWidth(0);
328
329
330

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

333
TerminalDisplay::~TerminalDisplay()
334
335
{
  qApp->removeEventFilter( this );
336
  
337
  delete[] _image;
338

339
340
  delete _gridLayout;
  delete _outputSuspendedLabel;
341
  delete _filterChain;
342
343
344
345
346
347
348
349
}

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

350
351
352
353
354
/**
 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
355

356
357
358
359
360
361
362
363
364
365
366
 Then, the pixels basically have the following interpretation:
 _|||_
 -...-
 -...-
 -...-
 _|||_

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

368
369
370
371
372
373

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

375
376
377
378
379
    LeftT = (1<<5),
    Int11 = (1<<6),
    Int12 = (1<<7),
    Int13 = (1<<8),
    RightT = (1<<9),
Stephan Kulow's avatar
Stephan Kulow committed
380

381
382
383
384
385
    LeftC = (1<<10),
    Int21 = (1<<11),
    Int22 = (1<<12),
    Int23 = (1<<13),
    RightC = (1<<14),
Stephan Kulow's avatar
Stephan Kulow committed
386

387
388
389
390
391
    LeftB = (1<<15),
    Int31 = (1<<16),
    Int32 = (1<<17),
    Int33 = (1<<18),
    RightB = (1<<19),
Stephan Kulow's avatar
Stephan Kulow committed
392

393
394
    BotL  = (1<<21),
    BotC  = (1<<22),
Dirk Mueller's avatar
Dirk Mueller committed
395
    BotR  = (1<<23)
396
397
};

398
#include "LineFont.h"
399
400
401
402
403
404
405
406
407

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;

408
    quint32 toDraw = LineChars[code];
Stephan Kulow's avatar
Stephan Kulow committed
409

410
    //Top _lines:
411
412
413
414
415
416
417
    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);

418
    //Bot _lines:
419
420
421
422
423
424
425
    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);

426
    //Left _lines:
427
428
429
430
431
432
433
    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);

434
    //Right _lines:
435
436
437
438
439
440
    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
441

442
443
444
445
446
447
448
    //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
449

450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
    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);

}

466
void TerminalDisplay::drawLineCharString(	QPainter& painter, int x, int y, const QString& str, 
467
									const Character* attributes)
468
469
470
{
		const QPen& currentPen = painter.pen();
		
471
		if ( attributes->rendition & RE_BOLD )
472
473
474
475
476
477
478
479
480
481
		{
			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])
482
            	drawLineChar(painter, x + (_fontWidth*i), y, _fontWidth, _fontHeight, code);
483
484
485
486
487
		}

		painter.setPen( currentPen );
}

488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
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;
}
511

512
513
514
515
void TerminalDisplay::setOpacity(qreal opacity)
{
    QColor color(_blendColor);
    color.setAlphaF(opacity);
516
517
518
519
520
521
522
523
524
525
526
527

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

528
529
530
531
532
    _blendColor = color.rgba();
}

void TerminalDisplay::drawBackground(QPainter& painter, const QRect& rect, const QColor& backgroundColor)
{
533
534
535
536
537
538
539
540
541
542
543
544
        // 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 = rect.intersected(_scrollBar->geometry());
        QRegion contentsRegion = QRegion(rect).subtracted(scrollBarArea);
        QRect contentsRect = contentsRegion.boundingRect();

545
546
547
548
549
550
551
        if ( HAVE_TRANSPARENCY && qAlpha(_blendColor) < 0xff ) 
        {
            QColor color(backgroundColor);
            color.setAlpha(qAlpha(_blendColor));

            painter.save();
            painter.setCompositionMode(QPainter::CompositionMode_Source);
552
            painter.fillRect(contentsRect, color);
553
554
555
            painter.restore();
        } 
        else
556
557
558
            painter.fillRect(contentsRect, backgroundColor);

        painter.fillRect(scrollBarArea,_scrollBar->palette().background());
559
560
}

561
562
563
564
565
566
567
568
569
570
571
572
573
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);
574
575
       else
           painter.setPen(foregroundColor);
576
577
578

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

627
    QFont font = painter.font();
Robert Knight's avatar
   
Robert Knight committed
628
629
    if (    font.bold() != useBold 
         || font.underline() != useUnderline )
630
631
    {
       font.setBold(useBold);
Robert Knight's avatar
   
Robert Knight committed
632
       font.setUnderline(useUnderline);
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
       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
        painter.drawText(rect,text);
}

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
665
    if ( backgroundColor != palette().background().color() )
666
667
668
669
670
671
672
673
674
675
676
677
678
679
        drawBackground(painter,rect,backgroundColor);

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

680
681
682
void TerminalDisplay::setRandomSeed(uint randomSeed) { _randomSeed = randomSeed; }
uint TerminalDisplay::randomSeed() const { return _randomSeed; }

683
#if 0
Waldo Bastian's avatar
Waldo Bastian committed
684
685
686
/*!
    Set XIM Position
*/
687
void TerminalDisplay::setCursorPos(const int curx, const int cury)
Waldo Bastian's avatar
Waldo Bastian committed
688
689
690
691
692
693
{
    QPoint tL  = contentsRect().topLeft();
    int    tLx = tL.x();
    int    tLy = tL.y();

    int xpos, ypos;
694
695
696
    ypos = _bY + tLy + _fontHeight*(cury-1) + _fontAscent;
    xpos = _bX + tLx + _fontWidth*curx;
    //setMicroFocusHint(xpos, ypos, 0, _fontHeight); //### ???
Waldo Bastian's avatar
Waldo Bastian committed
697
    // fprintf(stderr, "x/y = %d/%d\txpos/ypos = %d/%d\n", curx, cury, xpos, ypos);
698
699
    _cursorLine = cury;
    _cursorCol = curx;
Waldo Bastian's avatar
Waldo Bastian committed
700
}
701
#endif
Waldo Bastian's avatar
Waldo Bastian committed
702

703
// scrolls the image by 'lines', down if lines > 0 or up otherwise.
704
//
705
// the terminal emulation keeps track of the scrolling of the character 
706
// image as it receives input, and when the view is updated, it calls scrollImage() 
707
// with the final scroll amount.  this improves performance because scrolling the 
708
709
710
// 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
711
//
712
713
714
// note:  it is important that the area of the display which is 
// scrolled aligns properly with the character grid - 
// which has a top left point at (_bX,_bY) , 
715
// a cell width of _fontWidth and a cell height of _fontHeight).    
716
void TerminalDisplay::scrollImage(int lines , const QRect& screenWindowRegion)
717
{
718
719
720
721
722
723
724
    // 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) ); 

725
    if (    lines == 0 
726
727
728
729
730
731
         || _image == 0
         || !region.isValid() 
         || (region.top() + abs(lines)) >= region.bottom() 
         || this->_lines <= region.height() ) return;

   
732
733
734

    QRect scrollRect;

735
736
737
738
739
    //qDebug() << "Scrolled region: top =" << region.top() 
    //         << ", bottom =" << region.bottom()
    //         << ", height =" << region.height() << "lines.  Image height ="
    //         << this->_usedLines << "lines"
    //         << ", scroll =" << lines << "lines";
740

741
742
    void* firstCharPos = &_image[ region.top() * this->_columns ];
    void* lastCharPos = &_image[ (region.top() + abs(lines)) * this->_columns ];
743
744
745
746

    int top = _bY + (region.top() * _fontHeight);
    int linesToMove = region.height() - abs(lines);
    int bytesToMove = linesToMove * 
747
                      this->_columns *
748
749
750
751
752
                      sizeof(Character);

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

753
    //scroll internal image
754
    if ( lines > 0 )
755
    {
756
757
        // check that the memory areas that we are going to move are valid
        Q_ASSERT( (char*)lastCharPos + bytesToMove < 
758
                  (char*)(_image + (this->_lines * this->_columns)) );
759
        
760
        Q_ASSERT( (lines*this->_columns) < _imageSize ); 
761

762
        //scroll internal image down
763
764
        memmove( firstCharPos , lastCharPos , bytesToMove ); 
      
765
766
        //set region of display to scroll, making sure that
        //the region aligns correctly to the character grid 
767
        scrollRect = QRect( _bX , top, 
768
                            this->_usedColumns * _fontWidth , 
769
                            linesToMove * _fontHeight );
770
771
772
    }
    else
    {
773
774
        // check that the memory areas that we are going to move are valid
        Q_ASSERT( (char*)firstCharPos + bytesToMove < 
775
                  (char*)(_image + (this->_lines * this->_columns)) );
776
777

        //scroll internal image up
778
779
        memmove( lastCharPos , firstCharPos , bytesToMove ); 
     
780
781
        //set region of the display to scroll, making sure that
        //the region aligns correctly to the character grid
782
        QPoint topPoint( _bX , top + abs(lines)*_fontHeight );
783

784
        scrollRect = QRect( topPoint ,
785
                     QSize( this->_usedColumns*_fontWidth , 
786
                            linesToMove * _fontHeight ));
787
788
    }

789
    //scroll the display vertically to match internal _image
790
    scroll( 0 , _fontHeight * (-lines) , scrollRect );
791
}
792

793
void TerminalDisplay::processFilters() 
794
{
795
796
797
798
799
    QTime t;
    t.start();

    _filterChain->setImage(_image,_lines,_columns);

Robert Knight's avatar
   
Robert Knight committed
800
    //qDebug() << "Setup filters in" << t.elapsed() << "ms.";
801

802
    _filterChain->process();
803

Robert Knight's avatar
   
Robert Knight committed
804
    //qDebug() << "Processed filters in" << t.elapsed() << "ms.";
805
806
}

807
void TerminalDisplay::updateImage() 
808
{
809
810
811
  if ( !_screenWindow )
      return;

812
813
  // 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
814
  // can simply be moved up or down
815
816
  scrollImage( _screenWindow->scrollCount() ,
               _screenWindow->scrollRegion() );
817
818
  _screenWindow->resetScrollCount();

819
  Character* const newimg = _screenWindow->getImage();
820
821
  int lines = _screenWindow->windowLines();
  int columns = _screenWindow->windowColumns();
822
823
824

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

825
826
  if (!_image)
     updateImageSize(); // Create _image
827

828
829
  Q_ASSERT( this->_usedLines <= this->_lines );
  Q_ASSERT( this->_usedColumns <= this->_columns );
830

831
  int y,x,len;
832
833
834
835

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

838
  CharacterColor cf;       // undefined
839
  CharacterColor _clipboard;       // undefined
840
  int cr  = -1;   // undefined
841

842
843
  const int linesToUpdate = qMin(this->_lines, qMax(0,lines  ));
  const int columnsToUpdate = qMin(this->_columns,qMax(0,columns));
844

845
  QChar *disstrU = new QChar[columnsToUpdate];
846
  char *dirtyMask = new char[columnsToUpdate+2]; 
847
  QRegion dirtyRegion;
848

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

854
  for (y = 0; y < linesToUpdate; y++)
855
  {
856
    const Character*       currentLine = &_image[y*this->_columns];
857
    const Character* const newLine = &newimg[y*columns];
858

859
860
    bool updateLine = false;
    
861
    // The dirty mask indicates which characters need repainting. We also
Waldo Bastian's avatar
Waldo Bastian committed
862
863
    // mark surrounding neighbours dirty, in case the character exceeds
    // its cell boundaries
864
    memset(dirtyMask, 0, columnsToUpdate+2);
865
866
   
    for( x = 0 ; x < columnsToUpdate ; x++)
Waldo Bastian's avatar
Waldo Bastian committed
867
    {
868
869
870
871
        if ( newLine[x] != currentLine[x] ) 
        {
            dirtyMask[x] = true;
        }
Waldo Bastian's avatar
Waldo Bastian committed
872
    }
873

874
    if (!_resizing) // not while _resizing, we're expecting a paintEvent
875
    for (x = 0; x < columnsToUpdate; x++)
876
    {
877
      _hasBlinker |= (newLine[x].rendition & RE_BLINK);
878
    
Waldo Bastian's avatar
Waldo Bastian committed
879
880
881
882
      // 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])
883
      {
884
        quint16 c = newLine[x+0].character;
885
886
887
        if ( !c )
            continue;
        int p = 0;
Stephan Binner's avatar
Stephan Binner committed
888
        disstrU[p++] = c; //fontMap(c);
889
        bool lineDraw = isLineChar(c);
890
891
        bool doubleWidth = (newLine[x+1].character == 0);
        cr = newLine[x].rendition;
892
        _clipboard = newLine[x].backgroundColor;
893
        if (newLine[x].foregroundColor != cf) cf = newLine[x].foregroundColor;
894
        int lln = columnsToUpdate - x;
895
896
        for (len = 1; len < lln; len++)
        {
Robert Knight's avatar
   
Robert Knight committed
897
            const Character& ch = newLine[x+len];
898

Robert Knight's avatar
   
Robert Knight committed
899
900
901
902
            if (!ch.character)
                continue; // Skip trailing part of multi-col chars.

            if (  ch.foregroundColor != cf || 
903
                  ch.backgroundColor != _clipboard || 
Robert Knight's avatar
   
Robert Knight committed
904
905
906
907
                  ch.rendition != cr ||
                  !dirtyMask[x+len] || 
                  isLineChar(c) != lineDraw || 
                  (newLine[x+len+1].character == 0) != doubleWidth )
908
            break;
909

Stephan Binner's avatar
Stephan Binner committed
910
          disstrU[p++] = c; //fontMap(c);
911
        }
912
913

        QString unistr(disstrU, p);
914

915
        bool save__fixedFont = _fixedFont;
916
        if (lineDraw)
917
           _fixedFont = false;
918
        if (doubleWidth)
919
           _fixedFont = false;
920

921
		updateLine = true;
922

923
		_fixedFont = save__fixedFont;
924
925
        x += len - 1;
      }
926
      
927
    }
928

929
	//both the top and bottom halves of double height _lines must always be redrawn
Robert Knight's avatar
   
Robert Knight committed
930
931
	//although both top and bottom halves contain the same characters, only 
    //the top one is actually 
932
	//drawn.
933
934
    if (_lineProperties.count() > y)
        updateLine |= (_lineProperties[y] & LINE_DOUBLEHEIGHT);
Robert Knight's avatar
   
Robert Knight committed
935

936
    // if the characters on the line are different in the old and the new _image
Robert Knight's avatar
   
Robert Knight committed
937
    // then this line must be repainted.    
938
939
    if (updateLine)
    {
940
        dirtyLineCount++;
Robert Knight's avatar
   
Robert Knight committed
941
942
943

        // add the area occupied by this line to the region which needs to be
        // repainted
944
945
946
947
        QRect dirtyRect = QRect( _bX+tLx , 
                                 _bY+tLy+_fontHeight*y , 
                                 _fontWidth * columnsToUpdate , 
                                 _fontHeight ); 	
948

949
        dirtyRegion |= dirtyRect;
950
    }
951

952
953
    // replace the line of characters in the old _image with the 
    // current line of the new _image 
954
    memcpy((void*)currentLine,(const void*)newLine,columnsToUpdate*sizeof(Character));
955
  }
956

957
  // free the image from the screen window
958
  delete[] newimg;
959

960
  // debugging - display a count of the number of lines that will need 
Robert Knight's avatar
   
Robert Knight committed
961
  // to be repainted
962
  //qDebug() << "dirty line count = " << dirtyLineCount;
963

964
965
966
  // if the new _image is smaller than the previous _image, then ensure that the area
  // outside the new _image is cleared 
  if ( linesToUpdate < _usedLines )
967
  {
968
969
970
971
    dirtyRegion |= QRect(   _bX+tLx , 
                            _bY+tLy+_fontHeight*linesToUpdate , 
                            _fontWidth * this->_columns , 
                            _fontHeight * (_usedLines-linesToUpdate) );
972
  }
973
  _usedLines = linesToUpdate;
974
  
975
  if ( columnsToUpdate < _usedColumns )
976
  {
977
978
979
980
    dirtyRegion |= QRect(   _bX+tLx+columnsToUpdate*_fontWidth , 
                            _bY+tLy , 
                            _fontWidth * (_usedColumns-columnsToUpdate) , 
                            _fontHeight * this->_lines );
981
  }
982
  _usedColumns = columnsToUpdate;
983

984
985
  dirtyRegion |= _inputMethodData.previousPreeditRect;

986
987
  //qDebug() << "Expecting to update: " << dirtyRegion.boundingRect();

Robert Knight's avatar
   
Robert Knight committed
988
  // update the parts of the display which have changed
989
  update(dirtyRegion);
Stephan Kulow's avatar
Stephan Kulow committed
990

991
992
  if ( _hasBlinker && !_blinkTimer->isActive()) _blinkTimer->start( BLINK_DELAY ); 
  if (!_hasBlinker && _blinkTimer->isActive()) { _blinkTimer->stop(); _blinking = false; }