TerminalDisplay.cpp 83.6 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
32
33
34
35
36
37
#include <QtGui/QApplication>
#include <QtGui/QBoxLayout>
#include <QtGui/QClipboard>
#include <QtGui/QKeyEvent>
#include <QtCore/QEvent>
#include <QtCore/QFile>
#include <QtGui/QGridLayout>
#include <QtGui/QLabel>
#include <QtGui/QLayout>
#include <QtGui/QPainter>
#include <QtGui/QPixmap>
38
#include <QtGui/QScrollBar>
Dirk Mueller's avatar
Dirk Mueller committed
39
40
41
#include <QtGui/QStyle>
#include <QtCore/QTimer>
#include <QtGui/QToolTip>
42

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

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

60
61
using namespace Konsole;

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

#define yMouseScroll 1
Waldo Bastian's avatar
Waldo Bastian committed
67
68
69
70

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

72
73
// scroll increment used when dragging selection at top/bottom of window.

74
// static
75
bool TerminalDisplay::_antialiasText = true;
76
bool TerminalDisplay::HAVE_TRANSPARENCY = false;
77

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

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

104
    _screenWindow = window;
105

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

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

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

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

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

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

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

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

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

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

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

180
  _fixedFont = true;
181

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

192
  if (_fontWidth < 1)
193
    _fontWidth=1;
194

195
  _fontAscent = fm.ascent();
196

197
  emit changedFontMetricSignal( _fontHeight, _fontWidth );
198
199
200
201
  propagateSize();
  update();
}

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

  QFontMetrics metrics(font);

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

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

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

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

298
  // The offsets are not yet calculated.
299
  // Do not calculate these too often to be more smoothly when resizing
300
  // konsole in opaque mode.
301
  _bY = _bX = 1;
302

303
304
  // 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
305
  _scrollBar = new QScrollBar(this);
306
  setScroll(0,0); 
307
  _scrollBar->setCursor( Qt::ArrowCursor );
308
  connect(_scrollBar, SIGNAL(valueChanged(int)), this, SLOT(scrollBarPositionChanged(int)));
309

310
311
312
313
  _blinkTimer   = new QTimer(this);
  connect(_blinkTimer, SIGNAL(timeout()), this, SLOT(blinkEvent()));
  _blinkCursorTimer   = new QTimer(this);
  connect(_blinkCursorTimer, SIGNAL(timeout()), this, SLOT(blinkCursorEvent()));
314

Robert Knight's avatar
   
Robert Knight committed
315
  setUsesMouse(true);
316
  setColorTable(base_color_table); 
317
318
319

  KCursor::setAutoHideCursor( this, true );

320
321
  setMouseTracking(true);

Robert Knight's avatar
   
Robert Knight committed
322
  // Init DnD 
323
  setAcceptDrops(true); // attempt
324
  dragInfo.state = diNone;
325

326
  setFocusPolicy( Qt::WheelFocus );
Kazuki Ohta's avatar
Kazuki Ohta committed
327
  // im
328
  setAttribute(Qt::WA_InputMethodEnabled, true);
Stephan Kulow's avatar
Stephan Kulow committed
329

Robert Knight's avatar
Robert Knight committed
330
  // this is an important optimization, it tells Qt
331
332
  // that TerminalDisplay will handle repainting its entire area.
  setAttribute(Qt::WA_OpaquePaintEvent);
333

334
335
  _gridLayout = new QGridLayout(this);
  _gridLayout->setMargin(0);
336

337
  setLayout( _gridLayout ); 
338
  setLineWidth(0);
339
340
341

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

344
TerminalDisplay::~TerminalDisplay()
345
346
{
  qApp->removeEventFilter( this );
347
  
348
  delete[] _image;
349

350
351
  delete _gridLayout;
  delete _outputSuspendedLabel;
352
  delete _filterChain;
353
354
355
356
357
358
359
360
}

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

361
362
363
364
365
/**
 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
366

367
368
369
370
371
372
373
374
375
376
377
 Then, the pixels basically have the following interpretation:
 _|||_
 -...-
 -...-
 -...-
 _|||_

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

379
380
381
382
383
384

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

386
387
388
389
390
    LeftT = (1<<5),
    Int11 = (1<<6),
    Int12 = (1<<7),
    Int13 = (1<<8),
    RightT = (1<<9),
Stephan Kulow's avatar
Stephan Kulow committed
391

392
393
394
395
396
    LeftC = (1<<10),
    Int21 = (1<<11),
    Int22 = (1<<12),
    Int23 = (1<<13),
    RightC = (1<<14),
Stephan Kulow's avatar
Stephan Kulow committed
397

398
399
400
401
402
    LeftB = (1<<15),
    Int31 = (1<<16),
    Int32 = (1<<17),
    Int33 = (1<<18),
    RightB = (1<<19),
Stephan Kulow's avatar
Stephan Kulow committed
403

404
405
    BotL  = (1<<21),
    BotC  = (1<<22),
Dirk Mueller's avatar
Dirk Mueller committed
406
    BotR  = (1<<23)
407
408
};

409
#include "LineFont.h"
410
411
412
413
414
415
416
417
418

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;

419
    quint32 toDraw = LineChars[code];
Stephan Kulow's avatar
Stephan Kulow committed
420

421
    //Top _lines:
422
423
424
425
426
427
428
    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);

429
    //Bot _lines:
430
431
432
433
434
435
436
    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);

437
    //Left _lines:
438
439
440
441
442
443
444
    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);

445
    //Right _lines:
446
447
448
449
450
451
    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
452

453
454
455
456
457
458
459
    //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
460

461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
    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);

}

477
void TerminalDisplay::drawLineCharString(	QPainter& painter, int x, int y, const QString& str, 
478
									const Character* attributes)
479
480
481
{
		const QPen& currentPen = painter.pen();
		
482
		if ( attributes->rendition & RE_BOLD )
483
484
485
486
487
488
489
490
491
492
		{
			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])
493
            	drawLineChar(painter, x + (_fontWidth*i), y, _fontWidth, _fontHeight, code);
494
495
496
497
498
		}

		painter.setPen( currentPen );
}

499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
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;
}
522

523
524
525
526
void TerminalDisplay::setOpacity(qreal opacity)
{
    QColor color(_blendColor);
    color.setAlphaF(opacity);
527
528
529
530
531
532
533
534
535
536
537
538

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

539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
    _blendColor = color.rgba();
}

void TerminalDisplay::drawBackground(QPainter& painter, const QRect& rect, const QColor& backgroundColor)
{
        if ( HAVE_TRANSPARENCY && qAlpha(_blendColor) < 0xff ) 
        {
            QColor color(backgroundColor);
            color.setAlpha(qAlpha(_blendColor));

            painter.save();
            painter.setCompositionMode(QPainter::CompositionMode_Source);
            painter.fillRect(rect, color);
            painter.restore();
        } 
        else
            painter.fillRect(rect, backgroundColor);
}

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

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

617
    QFont font = painter.font();
Robert Knight's avatar
   
Robert Knight committed
618
619
    if (    font.bold() != useBold 
         || font.underline() != useUnderline )
620
621
    {
       font.setBold(useBold);
Robert Knight's avatar
   
Robert Knight committed
622
       font.setUnderline(useUnderline);
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
       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
655
    if ( backgroundColor != palette().background().color() )
656
657
658
659
660
661
662
663
664
665
666
667
668
669
        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();
}

670
671
672
void TerminalDisplay::setRandomSeed(uint randomSeed) { _randomSeed = randomSeed; }
uint TerminalDisplay::randomSeed() const { return _randomSeed; }

Waldo Bastian's avatar
Waldo Bastian committed
673
674
675
/*!
    Set XIM Position
*/
676
void TerminalDisplay::setCursorPos(const int curx, const int cury)
Waldo Bastian's avatar
Waldo Bastian committed
677
678
679
680
681
682
{
    QPoint tL  = contentsRect().topLeft();
    int    tLx = tL.x();
    int    tLy = tL.y();

    int xpos, ypos;
683
684
685
    ypos = _bY + tLy + _fontHeight*(cury-1) + _fontAscent;
    xpos = _bX + tLx + _fontWidth*curx;
    //setMicroFocusHint(xpos, ypos, 0, _fontHeight); //### ???
Waldo Bastian's avatar
Waldo Bastian committed
686
    // fprintf(stderr, "x/y = %d/%d\txpos/ypos = %d/%d\n", curx, cury, xpos, ypos);
687
688
    _cursorLine = cury;
    _cursorCol = curx;
Waldo Bastian's avatar
Waldo Bastian committed
689
690
}

691
// scrolls the image by 'lines', down if lines > 0 or up otherwise.
692
//
693
// the terminal emulation keeps track of the scrolling of the character 
694
// image as it receives input, and when the view is updated, it calls scrollImage() 
695
// with the final scroll amount.  this improves performance because scrolling the 
696
697
698
// 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
699
//
700
701
702
// 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) , 
703
// a cell width of _fontWidth and a cell height of _fontHeight).    
704
void TerminalDisplay::scrollImage(int lines , const QRect& screenWindowRegion)
705
{
706
707
708
709
710
711
712
    // 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) ); 

713
    if (    lines == 0 
714
715
716
717
718
719
         || _image == 0
         || !region.isValid() 
         || (region.top() + abs(lines)) >= region.bottom() 
         || this->_lines <= region.height() ) return;

   
720
721
722

    QRect scrollRect;

723
724
725
726
727
    //qDebug() << "Scrolled region: top =" << region.top() 
    //         << ", bottom =" << region.bottom()
    //         << ", height =" << region.height() << "lines.  Image height ="
    //         << this->_usedLines << "lines"
    //         << ", scroll =" << lines << "lines";
728

729
730
    void* firstCharPos = &_image[ region.top() * this->_columns ];
    void* lastCharPos = &_image[ (region.top() + abs(lines)) * this->_columns ];
731
732
733
734

    int top = _bY + (region.top() * _fontHeight);
    int linesToMove = region.height() - abs(lines);
    int bytesToMove = linesToMove * 
735
                      this->_columns *
736
737
738
739
740
                      sizeof(Character);

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

741
    //scroll internal image
742
    if ( lines > 0 )
743
    {
744
745
        // check that the memory areas that we are going to move are valid
        Q_ASSERT( (char*)lastCharPos + bytesToMove < 
746
                  (char*)(_image + (this->_lines * this->_columns)) );
747
        
748
        Q_ASSERT( (lines*this->_columns) < _imageSize ); 
749

750
        //scroll internal image down
751
752
        memmove( firstCharPos , lastCharPos , bytesToMove ); 
      
753
754
        //set region of display to scroll, making sure that
        //the region aligns correctly to the character grid 
755
        scrollRect = QRect( _bX , top, 
756
                            this->_usedColumns * _fontWidth , 
757
                            linesToMove * _fontHeight );
758
759
760
    }
    else
    {
761
762
        // check that the memory areas that we are going to move are valid
        Q_ASSERT( (char*)firstCharPos + bytesToMove < 
763
                  (char*)(_image + (this->_lines * this->_columns)) );
764
765

        //scroll internal image up
766
767
        memmove( lastCharPos , firstCharPos , bytesToMove ); 
     
768
769
        //set region of the display to scroll, making sure that
        //the region aligns correctly to the character grid
770
        QPoint topPoint( _bX , top + abs(lines)*_fontHeight );
771

772
        scrollRect = QRect( topPoint ,
773
                     QSize( this->_usedColumns*_fontWidth , 
774
                            linesToMove * _fontHeight ));
775
776
    }

777
    //scroll the display vertically to match internal _image
778
    scroll( 0 , _fontHeight * (-lines) , scrollRect );
779
}
780

781
void TerminalDisplay::processFilters() 
782
{
783
784
785
786
787
    QTime t;
    t.start();

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

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

790
    _filterChain->process();
791

Robert Knight's avatar
   
Robert Knight committed
792
    //qDebug() << "Processed filters in" << t.elapsed() << "ms.";
793
794
}

795
void TerminalDisplay::updateImage() 
796
{
797
798
799
  if ( !_screenWindow )
      return;

800
801
  // 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
802
  // can simply be moved up or down
803
804
  scrollImage( _screenWindow->scrollCount() ,
               _screenWindow->scrollRegion() );
805
806
  _screenWindow->resetScrollCount();

807
  Character* const newimg = _screenWindow->getImage();
808
809
  int lines = _screenWindow->windowLines();
  int columns = _screenWindow->windowColumns();
810
811
812

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

813
814
  if (!_image)
     updateImageSize(); // Create _image
815

816
817
  Q_ASSERT( this->_usedLines <= this->_lines );
  Q_ASSERT( this->_usedColumns <= this->_columns );
818

819
  int y,x,len;
820
821
822
823

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

826
  CharacterColor cf;       // undefined
827
  CharacterColor _clipboard;       // undefined
828
  int cr  = -1;   // undefined
829

830
831
  const int linesToUpdate = qMin(this->_lines, qMax(0,lines  ));
  const int columnsToUpdate = qMin(this->_columns,qMax(0,columns));
832

833
  QChar *disstrU = new QChar[columnsToUpdate];
834
  char *dirtyMask = new char[columnsToUpdate+2]; 
835
  QRegion dirtyRegion;
836

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

842
  for (y = 0; y < linesToUpdate; y++)
843
  {
844
    const Character*       currentLine = &_image[y*this->_columns];
845
    const Character* const newLine = &newimg[y*columns];
846

847
848
    bool updateLine = false;
    
849
    // The dirty mask indicates which characters need repainting. We also
Waldo Bastian's avatar
Waldo Bastian committed
850
851
    // mark surrounding neighbours dirty, in case the character exceeds
    // its cell boundaries
852
    memset(dirtyMask, 0, columnsToUpdate+2);
Waldo Bastian's avatar
Waldo Bastian committed
853
    // Two extra so that we don't have to have to care about start and end conditions
854
    for (x = 0; x < columnsToUpdate; x++)
Waldo Bastian's avatar
Waldo Bastian committed
855
    {
856
857
858
859
860
861
	if ( ( (_imPreeditLength > 0) && 
           ( ( _imStartLine == y ) && 
             ( ( _imStart < _imEnd ) && 
               ( ( x > _imStart ) ) && 
               ( x < _imEnd ) )
              || ( ( _imSelStart < _imSelEnd ) && ( ( x > _imSelStart ) ) ) ) )
862
            || newLine[x] != currentLine[x])
Waldo Bastian's avatar
Waldo Bastian committed
863
864
865
866
867
      {
         dirtyMask[x] = dirtyMask[x+1] = dirtyMask[x+2] = 1;
      }
    }
    dirtyMask++; // Position correctly
868

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

Robert Knight's avatar
   
Robert Knight committed
894
895
896
897
            if (!ch.character)
                continue; // Skip trailing part of multi-col chars.

            if (  ch.foregroundColor != cf || 
898
                  ch.backgroundColor != _clipboard || 
Robert Knight's avatar
   
Robert Knight committed
899
900
901
902
                  ch.rendition != cr ||
                  !dirtyMask[x+len] || 
                  isLineChar(c) != lineDraw || 
                  (newLine[x+len+1].character == 0) != doubleWidth )
903
            break;
904

Stephan Binner's avatar
Stephan Binner committed
905
          disstrU[p++] = c; //fontMap(c);
906
        }
907
908

        QString unistr(disstrU, p);
909
910

        // for XIM on the spot input style
911
        _isIMEdit = _isIMSel = false;
912

913
        if ( _imStartLine == y ) 
Robert Knight's avatar
   
Robert Knight committed
914
        {
915
916
917
          if (  ( _imStart < _imEnd ) && 
                ( x >= _imStart-1 ) && 
                ( x + int( unistr.length() ) <= _imEnd ) 
Robert Knight's avatar
   
Robert Knight committed
918
             )
919
                _isIMEdit = true;
Robert Knight's avatar
   
Robert Knight committed
920

921
922
923
          if ( ( _imSelStart < _imSelEnd ) && 
               ( x >= _imStart-1 ) && 
               ( x + int( unistr.length() ) <= _imEnd ) 
Robert Knight's avatar
   
Robert Knight committed
924
             )
925
                _isIMSel = true;
Robert Knight's avatar
   
Robert Knight committed
926
	    }
927
        else if ( _imStartLine < y ) 
Robert Knight's avatar
   
Robert Knight committed
928
        {  // for word warp
929
930
          if ( _imStart < _imEnd )
            _isIMEdit = true;
931

932
933
          if (  _imSelStart < _imSelEnd )
            _isIMSel = true;
Robert Knight's avatar
   
Robert Knight committed
934
	    }
Stephan Kulow's avatar
Stephan Kulow committed
935

936
        bool save__fixedFont = _fixedFont;
937
        if (lineDraw)
938
           _fixedFont = false;
939
        if (doubleWidth)
940
           _fixedFont = false;
941

942
		updateLine = true;
943

944
		_fixedFont = save__fixedFont;
945
946
        x += len - 1;
      }
947
      
948
    }
949

950
	//both the top and bottom halves of double height _lines must always be redrawn
Robert Knight's avatar
   
Robert Knight committed
951
952
	//although both top and bottom halves contain the same characters, only 
    //the top one is actually 
953
	//drawn.
954
955
    if (_lineProperties.count() > y)
        updateLine |= (_lineProperties[y] & LINE_DOUBLEHEIGHT);
Robert Knight's avatar
   
Robert Knight committed
956

957
    // if the characters on the line are different in the old and the new _image
Robert Knight's avatar
   
Robert Knight committed
958
    // then this line must be repainted.    
959
960
    if (updateLine)
    {
961
        dirtyLineCount++;
Robert Knight's avatar
   
Robert Knight committed
962
963
964

        // add the area occupied by this line to the region which needs to be
        // repainted
965
966
967
968
        QRect dirtyRect = QRect( _bX+tLx , 
                                 _bY+tLy+_fontHeight*y , 
                                 _fontWidth * columnsToUpdate , 
                                 _fontHeight ); 	
969

970
        dirtyRegion |= dirtyRect;
971
    }
972

Waldo Bastian's avatar
Waldo Bastian committed
973
    dirtyMask--; // Set back
974

975
976
    // replace the line of characters in the old _image with the 
    // current line of the new _image 
977
    memcpy((void*)currentLine,(const void*)newLine,columnsToUpdate*sizeof(Character));
978
  }
979

980
  // free the image from the screen window
981
  delete[] newimg;
982

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

987
988
989
  // if the new _image is smaller than the previous _image, then ensure that the area
  // outside the new _image is cleared 
  if ( linesToUpdate < _usedLines )
990
  {
991
992
993
994
    dirtyRegion |= QRect(   _bX+tLx , 
                            _bY+tLy+_fontHeight*linesToUpdate , 
                            _fontWidth * this->_columns , 
                            _fontHeight * (_usedLines-linesToUpdate) );
995
  }
996
  _usedLines = linesToUpdate;
997
  
998
  if ( columnsToUpdate < _usedColumns )
999
  {
1000
1001
1002