TerminalDisplay.h

Go to the documentation of this file.

/*
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
    Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>

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

#ifndef TERMINALDISPLAY_H
#define TERMINALDISPLAY_H

// Qt
#include <QtGui/QColor>
#include <QtCore/QPointer>
#include <QWidget>

// Konsole
#include "Character.h"
#include "konsole_export.h"
#include "ScreenWindow.h"
#include "ColorScheme.h"
#include "Enumeration.h"

class QDrag;
class QDragEnterEvent;
class QDropEvent;
class QLabel;
class QTimer;
class QEvent;
class QGridLayout;
class QKeyEvent;
class QScrollBar;
class QShowEvent;
class QHideEvent;
class QTimerEvent;

namespace Konsole
{
class FilterChain;
class TerminalImageFilterChain;
class SessionController;
class KONSOLEPRIVATE_EXPORT TerminalDisplay : public QWidget
{
    Q_OBJECT

public:
    explicit TerminalDisplay(QWidget* parent = 0);
    virtual ~TerminalDisplay();

    const ColorEntry* colorTable() const;
    void setColorTable(const ColorEntry table[]);
    void setRandomSeed(uint seed);
    uint randomSeed() const;

    void setOpacity(qreal opacity);

    void setWallpaper(ColorSchemeWallpaper::Ptr p);

    void setScrollBarPosition(Enum::ScrollBarPositionEnum position);
    Enum::ScrollBarPositionEnum scrollBarPosition() const {
        return _scrollbarLocation;
    }

    void setScroll(int cursor, int lines);

    void setScrollFullPage(bool fullPage);
    bool scrollFullPage() const;

    FilterChain* filterChain() const;

    void processFilters();

    QList<QAction*> filterActions(const QPoint& position);

    void setBlinkingCursorEnabled(bool blink);
    bool blinkingCursorEnabled() const {
        return _allowBlinkingCursor;
    }

    void setBlinkingTextEnabled(bool blink);

    void setControlDrag(bool enable) {
        _ctrlRequiredForDrag = enable;
    }
    bool ctrlRequiredForDrag() const {
        return _ctrlRequiredForDrag;
    }

    void setTripleClickMode(Enum::TripleClickModeEnum mode) {
        _tripleClickMode = mode;
    }
    Enum::TripleClickModeEnum tripleClickMode() const {
        return _tripleClickMode;
    }

    void setUnderlineLinks(bool value) {
        _underlineLinks = value;
    }
    bool getUnderlineLinks() const {
        return _underlineLinks;
    }

    void setOpenLinksByDirectClick(bool value) {
        _openLinksByDirectClick = value;
    }
    bool getOpenLinksByDirectClick() const {
        return _openLinksByDirectClick;
    }

    void setTrimTrailingSpaces(bool enabled) {
        _trimTrailingSpaces = enabled;
    }

    bool trimTrailingSpaces() const {
        return _trimTrailingSpaces;
    }

    void setLineSpacing(uint);
    uint lineSpacing() const;

    void setSessionController(SessionController* controller);
    SessionController* sessionController();

    void setKeyboardCursorShape(Enum::CursorShapeEnum shape);
    Enum::CursorShapeEnum keyboardCursorShape() const;

    void setKeyboardCursorColor(const QColor& color);

    QColor keyboardCursorColor() const;

    int  lines() const {
        return _lines;
    }
    int  columns() const {
        return _columns;
    }

    int  fontHeight() const {
        return _fontHeight;
    }
    int  fontWidth() const {
        return _fontWidth;
    }

    void setSize(int columns, int lines);
    void setFixedSize(int columns, int lines);

    // reimplemented
    QSize sizeHint() const;

    void setWordCharacters(const QString& wc);
    QString wordCharacters() const {
        return _wordCharacters;
    }

    void setBellMode(int mode);
    int bellMode() const;

    void visualBell();

    void setMouseWheelZoom(bool value) {
        _mouseWheelZoom = value;
    };
    bool mouseWheelZoom() {
        return _mouseWheelZoom;
    };

    virtual void setFont(const QFont &);

    QFont getVTFont() {
        return font();
    }

    void setVTFont(const QFont& font);

    void increaseFontSize();

    void decreaseFontSize();

    void setAntialias(bool value) {
        _antialiasText = value;
    }
    bool antialias() const {
        return _antialiasText;
    }

    void setBoldIntense(bool value) {
        _boldIntense = value;
    }
    bool getBoldIntense() const {
        return _boldIntense;
    }

    void setShowTerminalSizeHint(bool on) {
        _showTerminalSizeHint = on;
    }
    bool showTerminalSizeHint() const {
        return _showTerminalSizeHint;
    }

    void setBidiEnabled(bool set) {
        _bidiEnabled = set;
    }
    bool isBidiEnabled() const {
        return _bidiEnabled;
    }

    void setScreenWindow(ScreenWindow* window);
    ScreenWindow* screenWindow() const;

    void printContent(QPainter& painter, bool friendly);

public slots:
    void scrollScreenWindow(enum ScreenWindow::RelativeScrollMode mode , int amount);

    void updateImage();
    void updateLineProperties();

    void setAutoCopySelectedText(bool enabled);

    void setMiddleClickPasteMode(Enum::MiddleClickPasteModeEnum mode);

    void copyToX11Selection();

    void copyToClipboard();

    void pasteFromClipboard(bool appendEnter = false);
    void pasteFromX11Selection(bool appendEnter = false);

    void setFlowControlWarningEnabled(bool enabled);
    bool flowControlWarningEnabled() const {
        return _flowControlWarningEnabled;
    }

    void outputSuspended(bool suspended);

    void setUsesMouse(bool usesMouse);

    bool usesMouse() const;

    void bell(const QString& message);

    QColor getBackgroundColor() const;

    void setBackgroundColor(const QColor& color);

    void setForegroundColor(const QColor& color);

    void setMargin(int margin);

    void setCenterContents(bool enable);

signals:

    void keyPressedSignal(QKeyEvent* event);

    void mouseSignal(int button, int column, int line, int eventType);
    void changedFontMetricSignal(int height, int width);
    void changedContentSizeSignal(int height, int width);

    void configureRequest(const QPoint& position);

    void overrideShortcutCheck(QKeyEvent* keyEvent, bool& override);

    void sendStringToEmu(const char*);

protected:
    virtual bool event(QEvent* event);

    virtual void paintEvent(QPaintEvent* event);

    virtual void showEvent(QShowEvent* event);
    virtual void hideEvent(QHideEvent* event);
    virtual void resizeEvent(QResizeEvent* event);

    virtual void contextMenuEvent(QContextMenuEvent* event);

    virtual void fontChange(const QFont&);
    virtual void focusInEvent(QFocusEvent* event);
    virtual void focusOutEvent(QFocusEvent* event);
    virtual void keyPressEvent(QKeyEvent* event);
    virtual void leaveEvent(QEvent* event);
    virtual void mouseDoubleClickEvent(QMouseEvent* event);
    virtual void mousePressEvent(QMouseEvent* event);
    virtual void mouseReleaseEvent(QMouseEvent* event);
    virtual void mouseMoveEvent(QMouseEvent* event);
    virtual void extendSelection(const QPoint& pos);
    virtual void wheelEvent(QWheelEvent* event);

    virtual bool focusNextPrevChild(bool next);

    // drag and drop
    virtual void dragEnterEvent(QDragEnterEvent* event);
    virtual void dropEvent(QDropEvent* event);
    void doDrag();
    enum DragState { diNone, diPending, diDragging };

    struct DragInfo {
        DragState       state;
        QPoint          start;
        QDrag*          dragObject;
    } _dragInfo;

    // classifies the 'ch' into one of three categories
    // and returns a character to indicate which category it is in
    //
    //     - A space (returns ' ')
    //     - Part of a word (returns 'a')
    //     - Other characters (returns the input character)
    QChar charClass(const Character& ch) const;

    void clearImage();

    void mouseTripleClickEvent(QMouseEvent* event);

    // reimplemented
    virtual void inputMethodEvent(QInputMethodEvent* event);
    virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;

protected slots:

    void scrollBarPositionChanged(int value);
    void blinkTextEvent();
    void blinkCursorEvent();

private slots:

    void unmaskBell();
    void swapFGBGColors();
    void tripleClickTimeout();  // resets possibleTripleClick
    void viewScrolledByUser();

    void dropMenuPasteActionTriggered();

    void dropMenuCdActionTriggered();

private:
    // -- Drawing helpers --

    // divides the part of the display specified by 'rect' into
    // fragments according to their colors and styles and calls
    // drawTextFragment() or drawPrinterFriendlyTextFragment()
    // to draw the fragments
    void drawContents(QPainter& painter, const QRect& rect);
    // draw a transparent rectangle over the line of the current match
    void drawCurrentResultRect(QPainter& painter);
    // draws a section of text, all the text in this section
    // has a common color and style
    void drawTextFragment(QPainter& painter, const QRect& rect,
                          const QString& text, const Character* style);

    void drawPrinterFriendlyTextFragment(QPainter& painter, const QRect& rect,
                                         const QString& text, const Character* style);
    // draws the background for a text fragment
    // if useOpacitySetting is true then the color's alpha value will be set to
    // the display's transparency (set with setOpacity()), otherwise the background
    // will be drawn fully opaque
    void drawBackground(QPainter& painter, const QRect& rect, const QColor& color,
                        bool useOpacitySetting);
    // draws the cursor character
    void drawCursor(QPainter& painter, const QRect& rect , const QColor& foregroundColor,
                    const QColor& backgroundColor , bool& invertColors);
    // draws the characters or line graphics in a text fragment
    void drawCharacters(QPainter& painter, const QRect& rect,  const QString& text,
                        const Character* style, bool invertCharacterColor);
    // draws a string of line graphics
    void drawLineCharString(QPainter& painter, int x, int y,
                            const QString& str, const Character* attributes);

    // draws the preedit string for input methods
    void drawInputMethodPreeditString(QPainter& painter , const QRect& rect);

    // --

    // maps an area in the character image to an area on the widget
    QRect imageToWidget(const QRect& imageArea) const;

    // maps a point on the widget to the position ( ie. line and column )
    // of the character at that point.
    void getCharacterPosition(const QPoint& widgetPoint, int& line, int& column) const;

    // the area where the preedit string for input methods will be draw
    QRect preeditRect() const;

    // shows a notification window in the middle of the widget indicating the terminal's
    // current size in columns and lines
    void showResizeNotification();

    // scrolls the image by a number of lines.
    // 'lines' may be positive ( to scroll the image down )
    // or negative ( to scroll the image up )
    // 'region' is the part of the image to scroll - currently only
    // the top, bottom and height of 'region' are taken into account,
    // the left and right are ignored.
    void scrollImage(int lines , const QRect& region);

    void calcGeometry();
    void propagateSize();
    void updateImageSize();
    void makeImage();

    void paintFilters(QPainter& painter);

    // returns a region covering all of the areas of the widget which contain
    // a hotspot
    QRegion hotSpotRegion() const;

    // returns the position of the cursor in columns and lines
    QPoint cursorPosition() const;

    // redraws the cursor
    void updateCursor();

    bool handleShortcutOverrideEvent(QKeyEvent* event);

    void doPaste(QString text, bool appendReturn);

    void processMidButtonClick(QMouseEvent* event);

    QPoint findLineStart(const QPoint &pnt);
    QPoint findLineEnd(const QPoint &pnt);

    // the window onto the terminal screen which this display
    // is currently showing.
    QPointer<ScreenWindow> _screenWindow;

    bool _bellMasked;

    QGridLayout* _gridLayout;

    bool _fixedFont; // has fixed pitch
    int  _fontHeight;     // height
    int  _fontWidth;     // width
    int  _fontAscent;     // ascend
    bool _boldIntense;   // Whether intense colors should be rendered with bold font

    int _leftMargin;    // offset
    int _topMargin;    // offset

    int _lines;      // the number of lines that can be displayed in the widget
    int _columns;    // the number of columns that can be displayed in the widget

    int _usedLines;  // the number of lines that are actually being used, this will be less
    // than 'lines' if the character image provided with setImage() is smaller
    // than the maximum image size which can be displayed

    int _usedColumns; // the number of columns that are actually being used, this will be less
    // than 'columns' if the character image provided with setImage() is smaller
    // than the maximum image size which can be displayed

    QRect _contentRect;
    Character* _image; // [lines][columns]
    // only the area [usedLines][usedColumns] in the image contains valid data

    int _imageSize;
    QVector<LineProperty> _lineProperties;

    ColorEntry _colorTable[TABLE_COLORS];
    uint _randomSeed;

    bool _resizing;
    bool _showTerminalSizeHint;
    bool _bidiEnabled;
    bool _mouseMarks;

    QPoint  _iPntSel; // initial selection point
    QPoint  _pntSel; // current selection point
    QPoint  _tripleSelBegin; // help avoid flicker
    int     _actSel; // selection state
    bool    _wordSelectionMode;
    bool    _lineSelectionMode;
    bool    _preserveLineBreaks;
    bool    _columnSelectionMode;

    bool _autoCopySelectedText;
    Enum::MiddleClickPasteModeEnum _middleClickPasteMode;

    QScrollBar* _scrollBar;
    Enum::ScrollBarPositionEnum _scrollbarLocation;
    bool _scrollFullPage;
    QString     _wordCharacters;
    int         _bellMode;

    bool _allowBlinkingText;  // allow text to blink
    bool _allowBlinkingCursor;  // allow cursor to blink
    bool _textBlinking;   // text is blinking, hide it when drawing
    bool _cursorBlinking;     // cursor is blinking, hide it when drawing
    bool _hasTextBlinker; // has characters to blink
    QTimer* _blinkTextTimer;
    QTimer* _blinkCursorTimer;

    bool _underlineLinks;     // Underline URL and hosts on mouse hover
    bool _openLinksByDirectClick;     // Open URL and hosts by single mouse click
    bool _isFixedSize; // columns/lines are locked.

    bool _ctrlRequiredForDrag; // require Ctrl key for drag selected text

    Enum::TripleClickModeEnum _tripleClickMode;
    bool _possibleTripleClick;  // is set in mouseDoubleClickEvent and deleted
    // after QApplication::doubleClickInterval() delay

    QLabel* _resizeWidget;
    QTimer* _resizeTimer;

    bool _flowControlWarningEnabled;

    //widgets related to the warning message that appears when the user presses Ctrl+S to suspend
    //terminal output - informing them what has happened and how to resume output
    QLabel* _outputSuspendedLabel;

    uint _lineSpacing;

    QSize _size;

    QRgb _blendColor;

    ColorSchemeWallpaper::Ptr _wallpaper;

    // list of filters currently applied to the display.  used for links and
    // search highlight
    TerminalImageFilterChain* _filterChain;
    QRegion _mouseOverHotspotArea;

    Enum::CursorShapeEnum _cursorShape;

    // cursor color. If it is invalid (by default) then the foreground
    // color of the character under the cursor is used
    QColor _cursorColor;

    struct InputMethodData {
        QString preeditString;
        QRect previousPreeditRect;
    };
    InputMethodData _inputMethodData;

    bool _antialiasText;   // do we anti-alias or not

    bool _printerFriendly; // are we currently painting to a printer in black/white mode

    //the delay in milliseconds between redrawing blinking text
    static const int TEXT_BLINK_DELAY = 500;

    //the duration of the size hint in milliseconds
    static const int SIZE_HINT_DURATION = 1000;

    SessionController* _sessionController;

    bool _trimTrailingSpaces;   // trim trailing spaces in selected text
    bool _mouseWheelZoom;   // enable mouse wheel zooming or not

    int _margin;      // the contents margin
    bool _centerContents;   // center the contents between margins

    friend class TerminalDisplayAccessible;
};

class AutoScrollHandler : public QObject
{
    Q_OBJECT

public:
    explicit AutoScrollHandler(QWidget* parent);
protected:
    virtual void timerEvent(QTimerEvent* event);
    virtual bool eventFilter(QObject* watched, QEvent* event);
private:
    QWidget* widget() const {
        return static_cast<QWidget*>(parent());
    }
    int _timerId;
};
}

#endif // TERMINALDISPLAY_H