Screen.h

Go to the documentation of this file.

/*
    This file is part of Konsole, KDE's terminal.

    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 SCREEN_H
#define SCREEN_H

// Qt
#include <QtCore/QRect>
#include <QtCore/QSet>
#include <QtCore/QVector>
#include <QtCore/QBitArray>
#include <QtCore/QVarLengthArray>

// Konsole
#include "Character.h"

#define MODE_Origin    0
#define MODE_Wrap      1
#define MODE_Insert    2
#define MODE_Screen    3
#define MODE_Cursor    4
#define MODE_NewLine   5
#define MODES_SCREEN   6

namespace Konsole
{
class TerminalCharacterDecoder;
class TerminalDisplay;
class HistoryType;
class HistoryScroll;

class Screen
{
public:
    Screen(int lines, int columns);
    ~Screen();

    // VT100/2 Operations
    // Cursor Movement

    void cursorUp(int n);
    void cursorDown(int n);
    void cursorLeft(int n);
    void cursorRight(int n);
    void setCursorY(int y);
    void setCursorX(int x);
    void setCursorYX(int y, int x);
    void setMargins(int topLine , int bottomLine);
    int topMargin() const;
    int bottomMargin() const;

    void setDefaultMargins();

    void newLine();
    void nextLine();

    void index();
    void reverseIndex();

    void scrollUp(int n);
    void scrollDown(int n);
    void toStartOfLine();
    void backspace();
    void tab(int n = 1);
    void backtab(int n);

    // Editing

    void eraseChars(int n);
    void deleteChars(int n);
    void insertChars(int n);
    void deleteLines(int n);
    void insertLines(int n);
    void clearTabStops();
    void changeTabStop(bool set);

    void resetMode(int mode);
    void setMode(int mode);
    void saveMode(int mode);
    void restoreMode(int mode);
    bool getMode(int mode) const;

    void saveCursor();
    void restoreCursor();

    void clearEntireScreen();
    void clearToEndOfScreen();
    void clearToBeginOfScreen();
    void clearEntireLine();
    void clearToEndOfLine();
    void clearToBeginOfLine();

    void helpAlign();

    void setRendition(int rendition);
    void resetRendition(int rendition);

    void setForeColor(int space, int color);
    void setBackColor(int space, int color);
    void setDefaultRendition();

    int  getCursorX() const;
    int  getCursorY() const;

    void clear();
    void home();
    void reset(bool clearScreen = true);

    void displayCharacter(unsigned short c);

    void resizeImage(int new_lines, int new_columns);

    void getImage(Character* dest , int size , int startLine , int endLine) const;

    QVector<LineProperty> getLineProperties(int startLine , int endLine) const;

    int getLines() const {
        return _lines;
    }
    int getColumns() const {
        return _columns;
    }
    int getHistLines() const;
    void setScroll(const HistoryType& , bool copyPreviousScroll = true);
    const HistoryType& getScroll() const;
    bool hasScroll() const;

    void setSelectionStart(const int column, const int line, const bool blockSelectionMode);

    void setSelectionEnd(const int column, const int line);

    void getSelectionStart(int& column , int& line) const;

    void getSelectionEnd(int& column , int& line) const;

    void clearSelection();

    bool isSelected(const int column, const int line) const;

    QString selectedText(bool preserveLineBreaks, bool trimTrailingSpaces = false) const;

    QString text(int startIndex, int endIndex, bool preserveLineBreaks, bool trimTrailingSpaces = false) const;

    void writeLinesToStream(TerminalCharacterDecoder* decoder, int fromLine, int toLine) const;

    void writeSelectionToStream(TerminalCharacterDecoder* decoder , bool
                                preserveLineBreaks = true,
                                bool trimTrailingSpaces = false) const;

    void checkSelection(int from, int to);

    void setLineProperty(LineProperty property , bool enable);

    int scrolledLines() const;

    QRect lastScrolledRegion() const;

    void resetScrolledLines();

    int droppedLines() const;

    void resetDroppedLines();

    static void fillWithDefaultChar(Character* dest, int count);

    void setCurrentTerminalDisplay(TerminalDisplay* display) {
        _currentTerminalDisplay = display;
    }

    TerminalDisplay* currentTerminalDisplay() {
        return _currentTerminalDisplay;
    }

    QSet<ushort> usedExtendedChars() const {
        QSet<ushort> result;
        for (int i = 0; i < _lines; ++i) {
            const ImageLine& il = _screenLines[i];
            for (int j = 0; j < _columns; ++j) {
                if (il[j].rendition & RE_EXTENDED_CHAR) {
                    result << il[j].character;
                }
            }
        }
        return result;
    }

    static const Character DefaultChar;

private:
    //copies a line of text from the screen or history into a stream using a
    //specified character decoder.  Returns the number of lines actually copied,
    //which may be less than 'count' if (start+count) is more than the number of characters on
    //the line
    //
    //line - the line number to copy, from 0 (the earliest line in the history) up to
    //         history->getLines() + lines - 1
    //start - the first column on the line to copy
    //count - the number of characters on the line to copy
    //decoder - a decoder which converts terminal characters (an Character array) into text
    //appendNewLine - if true a new line character (\n) is appended to the end of the line
    int  copyLineToStream(int line,
                          int start,
                          int count,
                          TerminalCharacterDecoder* decoder,
                          bool appendNewLine,
                          bool preserveLineBreaks,
                          bool trimTrailingSpaces) const;

    //fills a section of the screen image with the character 'c'
    //the parameters are specified as offsets from the start of the screen image.
    //the loc(x,y) macro can be used to generate these values from a column,line pair.
    void clearImage(int loca, int loce, char c);

    //move screen image between 'sourceBegin' and 'sourceEnd' to 'dest'.
    //the parameters are specified as offsets from the start of the screen image.
    //the loc(x,y) macro can be used to generate these values from a column,line pair.
    //
    //NOTE: moveImage() can only move whole lines
    void moveImage(int dest, int sourceBegin, int sourceEnd);
    // scroll up 'i' lines in current region, clearing the bottom 'i' lines
    void scrollUp(int from, int i);
    // scroll down 'i' lines in current region, clearing the top 'i' lines
    void scrollDown(int from, int i);

    //when we handle scroll commands, we need to know which screenwindow will scroll
    TerminalDisplay* _currentTerminalDisplay;

    void addHistLine();

    void initTabStops();

    void updateEffectiveRendition();
    void reverseRendition(Character& p) const;

    bool isSelectionValid() const;
    // copies text from 'startIndex' to 'endIndex' to a stream
    // startIndex and endIndex are positions generated using the loc(x,y) macro
    void writeToStream(TerminalCharacterDecoder* decoder, int startIndex,
                       int endIndex, bool preserveLineBreaks = true, bool trimTrailingSpaces = false) const;
    // copies 'count' lines from the screen buffer into 'dest',
    // starting from 'startLine', where 0 is the first line in the screen buffer
    void copyFromScreen(Character* dest, int startLine, int count) const;
    // copies 'count' lines from the history buffer into 'dest',
    // starting from 'startLine', where 0 is the first line in the history
    void copyFromHistory(Character* dest, int startLine, int count) const;

    // screen image ----------------
    int _lines;
    int _columns;

    typedef QVector<Character> ImageLine;      // [0..columns]
    ImageLine*          _screenLines;    // [lines]
    int _screenLinesSize;                // _screenLines.size()

    int _scrolledLines;
    QRect _lastScrolledRegion;

    int _droppedLines;

    QVarLengthArray<LineProperty, 64> _lineProperties;

    // history buffer ---------------
    HistoryScroll* _history;

    // cursor location
    int _cuX;
    int _cuY;

    // cursor color and rendition info
    CharacterColor _currentForeground;
    CharacterColor _currentBackground;
    quint8 _currentRendition;

    // margins ----------------
    int _topMargin;
    int _bottomMargin;

    // states ----------------
    int _currentModes[MODES_SCREEN];
    int _savedModes[MODES_SCREEN];

    // ----------------------------

    QBitArray _tabStops;

    // selection -------------------
    int _selBegin; // The first location selected.
    int _selTopLeft;    // TopLeft Location.
    int _selBottomRight;    // Bottom Right Location.
    bool _blockSelectionMode;  // Column selection mode

    // effective colors and rendition ------------
    CharacterColor _effectiveForeground; // These are derived from
    CharacterColor _effectiveBackground; // the cu_* variables above
    quint8 _effectiveRendition;          // to speed up operation

    class SavedState
    {
    public:
        SavedState()
            : cursorColumn(0), cursorLine(0), rendition(0) {}

        int cursorColumn;
        int cursorLine;
        quint8 rendition;
        CharacterColor foreground;
        CharacterColor background;
    };
    SavedState _savedState;

    // last position where we added a character
    int _lastPos;
};
}

#endif // SCREEN_H