Session.h

Go to the documentation of this file.

/*
    This file is part of Konsole, an X terminal.

    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
    Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
    Copyright 2009 by Thomas Dreibholz <dreibh@iem.uni-due.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 SESSION_H
#define SESSION_H

// Qt
#include <QtCore/QStringList>
#include <QtCore/QHash>
//#include <QtCore/QByteRef>
#include <QtCore/QUuid>
#include <QtCore/QSize>
#include <QtCore/QProcess>
#include <QWidget>

// KDE
#include <KUrl>

// Konsole
#include "konsole_export.h"

class QColor;

class KConfigGroup;
class KProcess;

namespace Konsole
{
class Emulation;
class Pty;
class ProcessInfo;
class TerminalDisplay;
class ZModemDialog;
class HistoryType;

enum Modifier {
#ifdef Q_OS_MAC
    ACCEL = Qt::META
#else
    ACCEL = Qt::CTRL
#endif
};

class KONSOLEPRIVATE_EXPORT Session : public QObject
{
    Q_OBJECT
    Q_CLASSINFO("D-Bus Interface", "org.kde.konsole.Session")

public:
    Q_PROPERTY(QString name READ nameTitle)
    Q_PROPERTY(int processId READ processId)
    Q_PROPERTY(QString keyBindings READ keyBindings WRITE setKeyBindings)
    Q_PROPERTY(QSize size READ size WRITE setSize)

    explicit Session(QObject* parent = 0);
    ~Session();

    void openTeletype(int masterFd);

    bool isRunning() const;

    void addView(TerminalDisplay* widget);
    void removeView(TerminalDisplay* widget);

    QList<TerminalDisplay*> views() const;

    Emulation*  emulation() const;

    int sessionId() const;

    enum TabTitleContext {
        LocalTabTitle,
        RemoteTabTitle
    };

    bool isRemote();

    void setTabTitleFormat(TabTitleContext context , const QString& format);
    QString tabTitleFormat(TabTitleContext context) const;

    QStringList arguments() const;
    QString program() const;

    void setArguments(const QStringList& arguments);
    void setProgram(const QString& program);

    QString initialWorkingDirectory() {
        return _initialWorkingDir;
    }

    void setInitialWorkingDirectory(const QString& dir);

    QString currentWorkingDirectory();

    void setHistoryType(const HistoryType& type);
    const HistoryType& historyType() const;
    void clearHistory();

    void setKeyBindings(const QString& name);
    QString keyBindings() const;

    enum TitleRole {
        NameRole,
        DisplayedTitleRole
    };

    QString userTitle() const;

    QString nameTitle() const {
        return title(Session::NameRole);
    }
    QString getDynamicTitle();

    void setIconName(const QString& iconName);
    QString iconName() const;

    KUrl getUrl();

    void setIconText(const QString& iconText);
    QString iconText() const;

    void setTitle(TitleRole role , const QString& title);

    QString title(TitleRole role) const;

    void setAddToUtmp(bool);

    void setAutoClose(bool close);

    bool autoClose() const;

    bool isForegroundProcessActive();

    QString foregroundProcessName();

    QSize size();
    void setSize(const QSize& size);

    QSize preferredSize() const;

    void setPreferredSize(const QSize & size);

    void setDarkBackground(bool darkBackground);

    void refresh();

    void startZModem(const QString& rz, const QString& dir, const QStringList& list);
    void cancelZModem();
    bool isZModemBusy() {
        return _zmodemBusy;
    }

    enum UserTitleChange {
        IconNameAndWindowTitle = 0,
        IconName               = 1,
        WindowTitle            = 2,
        TextColor              = 10,
        BackgroundColor        = 11,
        SessionName            = 30,  // Non-standard
        SessionIcon            = 32,  // Non-standard
        ProfileChange          = 50   // this clashes with Xterm's font change command
    };

    // Sets the text codec used by this sessions terminal emulation.
    void setCodec(QTextCodec* codec);

    // session management
    void saveSession(KConfigGroup& group);
    void restoreSession(KConfigGroup& group);

    void sendSignal(int signal);

public slots:

    void run();

    Q_SCRIPTABLE QStringList environment() const;

    Q_SCRIPTABLE void setEnvironment(const QStringList& environment);

    void addEnvironmentEntry(const QString& entry);

    //Q_SCRIPTABLE void close(); // This cause the menu issues bko 185466
    void close();

    bool closeInNormalWay();

    bool closeInForceWay();

    void setUserTitle(int what , const QString& caption);

    Q_SCRIPTABLE void setMonitorActivity(bool);

    Q_SCRIPTABLE bool isMonitorActivity() const;

    Q_SCRIPTABLE void setMonitorSilence(bool);

    Q_SCRIPTABLE bool isMonitorSilence() const;

    Q_SCRIPTABLE void setMonitorSilenceSeconds(int seconds);

    Q_SCRIPTABLE void setFlowControlEnabled(bool enabled);

    Q_SCRIPTABLE bool flowControlEnabled() const;

    Q_SCRIPTABLE void sendText(const QString& text) const;

    Q_SCRIPTABLE void runCommand(const QString& command) const;

    Q_SCRIPTABLE void sendMouseEvent(int buttons, int column, int line, int eventType);

    Q_SCRIPTABLE int processId() const;

    Q_SCRIPTABLE int foregroundProcessId();

    Q_SCRIPTABLE bool setCodec(QByteArray codec);

    Q_SCRIPTABLE QByteArray codec();

    Q_SCRIPTABLE void setTitle(int role, const QString& title);

    Q_SCRIPTABLE QString title(int role) const;

    Q_SCRIPTABLE QString shellSessionId() const;

    Q_SCRIPTABLE void setTabTitleFormat(int context, const QString& format);

    Q_SCRIPTABLE QString tabTitleFormat(int context) const;

    Q_SCRIPTABLE void setHistorySize(int lines);

    Q_SCRIPTABLE int historySize() const;

signals:

    void started();

    void finished();

    void titleChanged();

    void stateChanged(int state);

    void currentDirectoryChanged(const QString& dir);

    void bellRequest(const QString& message);

    void changeTabTextColorRequest(int);

    void changeBackgroundColorRequest(const QColor&);
    void changeForegroundColorRequest(const QColor&);

    void openUrlRequest(const QString& url);

    void zmodemDetected();

    void resizeRequest(const QSize& size);

    void profileChangeCommandReceived(const QString& text);

    void flowControlEnabledChanged(bool enabled);

    void primaryScreenInUse(bool use);

    void selectionChanged(const QString& text);

private slots:
    void done(int, QProcess::ExitStatus);

    void fireZModemDetected();

    void onReceiveBlock(const char* buffer, int len);
    void silenceTimerDone();
    void activityTimerDone();

    void onViewSizeChange(int height, int width);

    void activityStateSet(int);

    //automatically detach views from sessions when view is destroyed
    void viewDestroyed(QObject* view);

    void zmodemReadStatus();
    void zmodemReadAndSendBlock();
    void zmodemReceiveBlock(const char* data, int len);
    void zmodemFinished();

    void updateFlowControlState(bool suspended);
    void updateWindowSize(int lines, int columns);

    // signal relayer
    void onPrimaryScreenInUse(bool use);

private:
    // checks that the binary 'program' is available and can be executed
    // returns the binary name if available or an empty string otherwise
    static QString checkProgram(const QString& program);

    void updateTerminalSize();
    WId windowId() const;
    bool kill(int signal);
    // print a warning message in the terminal.  This is used
    // if the program fails to start, or if the shell exits in
    // an unsuccessful manner
    void terminalWarning(const QString& message);
    ProcessInfo* getProcessInfo();
    void updateSessionProcessInfo();
    bool updateForegroundProcessInfo();
    ProcessInfo* updateWorkingDirectory();

    QUuid            _uniqueIdentifier; // SHELL_SESSION_ID

    Pty*          _shellProcess;
    Emulation*    _emulation;

    QList<TerminalDisplay*> _views;

    // monitor activity & silence
    bool           _monitorActivity;
    bool           _monitorSilence;
    bool           _notifiedActivity;
    int            _silenceSeconds;
    QTimer*        _silenceTimer;
    QTimer*        _activityTimer;

    bool           _autoClose;
    bool           _closePerUserRequest;

    QString        _nameTitle;
    QString        _displayTitle;
    QString        _userTitle;

    QString        _localTabTitleFormat;
    QString        _remoteTabTitleFormat;

    QString        _iconName;
    QString        _iconText; // not actually used
    bool           _addToUtmp;
    bool           _flowControlEnabled;

    QString        _program;
    QStringList    _arguments;

    QStringList    _environment;
    int            _sessionId;

    QString        _initialWorkingDir;
    QString        _currentWorkingDir;

    ProcessInfo*   _sessionProcessInfo;
    ProcessInfo*   _foregroundProcessInfo;
    int            _foregroundPid;

    // ZModem
    bool           _zmodemBusy;
    KProcess*      _zmodemProc;
    ZModemDialog*  _zmodemProgress;

    bool _hasDarkBackground;

    QSize _preferredSize;

    static int lastSessionId;
};

class SessionGroup : public QObject
{
    Q_OBJECT

public:
    explicit SessionGroup(QObject* parent);
    ~SessionGroup();

    void addSession(Session* session);
    void removeSession(Session* session);

    QList<Session*> sessions() const;

    void setMasterStatus(Session* session , bool master);
    bool masterStatus(Session* session) const;

    enum MasterMode {
        CopyInputToAll = 1
    };

    void setMasterMode(int mode);
    int masterMode() const;

private slots:
    void sessionFinished();
    void forwardData(const char* data, int size);

private:
    QList<Session*> masters() const;

    // maps sessions to their master status
    QHash<Session*, bool> _sessions;

    int _masterMode;
};
}

#endif