SessionController.h

Go to the documentation of this file.

/*
    Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
    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 SESSIONCONTROLLER_H
#define SESSIONCONTROLLER_H

// Qt
#include <QtCore/QList>
#include <QtCore/QSet>
#include <QtCore/QPointer>
#include <QtCore/QString>
#include <QtCore/QHash>

// KDE
#include <KIcon>
#include <KXMLGUIClient>

// Konsole
#include "ViewProperties.h"
#include "Profile.h"

namespace KIO
{
class Job;
}

class QAction;
class QTextCodec;
class QKeyEvent;
class QTimer;

class KCodecAction;
class KUrl;
class KJob;
class KAction;
class KActionMenu;

namespace Konsole
{
class Session;
class SessionGroup;
class ScreenWindow;
class TerminalDisplay;
class IncrementalSearchBar;
class ProfileList;
class UrlFilter;
class RegExpFilter;
class EditProfileDialog;

// SaveHistoryTask
class TerminalCharacterDecoder;

typedef QPointer<Session> SessionPtr;

class KONSOLEPRIVATE_EXPORT SessionController : public ViewProperties , public KXMLGUIClient
{
    Q_OBJECT

public:
    enum CopyInputToEnum {
        CopyInputToAllTabsMode = 0 ,

        CopyInputToSelectedTabsMode = 1 ,

        CopyInputToNoneMode = 2
    };

    SessionController(Session* session , TerminalDisplay* view, QObject* parent);
    ~SessionController();

    QPointer<Session> session() {
        return _session;
    }
    QPointer<TerminalDisplay>  view()    {
        return _view;
    }

    QString userTitle() const;

    bool isValid() const;

    void setSearchStartTo(int line);

    void setSearchStartToWindowCurrentLine();

    void setSearchBar(IncrementalSearchBar* searchBar);
    IncrementalSearchBar* searchBar() const;

    void setShowMenuAction(QAction* action);

    EditProfileDialog* profileDialogPointer();

    // reimplemented
    virtual KUrl url() const;
    virtual QString currentDir() const;
    virtual void rename();
    virtual bool confirmClose() const;
    virtual bool confirmForceClose() const;

    // Reimplemented to watch for events happening to the view
    virtual bool eventFilter(QObject* watched , QEvent* event);

    static QSet<SessionController*> allControllers() {
        return _allControllers;
    }

signals:
    void focused(SessionController* controller);

    void rawTitleChanged();

    void currentDirectoryChanged(const QString& dir);

public slots:
    void openUrl(const KUrl& url);

    void setupPrimaryScreenSpecificActions(bool use);

    void selectionChanged(const QString& selectedText);

    void closeSession();

    void increaseFontSize();

    void decreaseFontSize();

private slots:
    // menu item handlers
    void openBrowser();
    void copy();
    void paste();
    void selectAll();
    void pasteFromX11Selection(); // shortcut only
    void copyInputActionsTriggered(QAction* action);
    void copyInputToAllTabs();
    void copyInputToSelectedTabs();
    void copyInputToNone();
    void editCurrentProfile();
    void changeCodec(QTextCodec* codec);
    void enableSearchBar(bool showSearchBar);
    void searchHistory(bool showSearchBar);
    void searchBarEvent();
    void searchFrom();
    void findNextInHistory();
    void findPreviousInHistory();
    void changeSearchMatch();
    void print_screen();
    void saveHistory();
    void showHistoryOptions();
    void clearHistory();
    void clearHistoryAndReset();
    void monitorActivity(bool monitor);
    void monitorSilence(bool monitor);
    void renameSession();
    void switchProfile(Profile::Ptr profile);
    void handleWebShortcutAction();
    void configureWebShortcuts();
    void sendSignal(QAction* action);

    // other
    void prepareSwitchProfileMenu();
    void updateCodecAction();
    void showDisplayContextMenu(const QPoint& position);
    void movementKeyFromSearchBarReceived(QKeyEvent *event);
    void sessionStateChanged(int state);
    void sessionTitleChanged();
    void searchTextChanged(const QString& text);
    void searchCompleted(bool success);
    void searchClosed(); // called when the user clicks on the
    // history search bar's close button

    void interactionHandler();
    void snapshot(); // called periodically as the user types
    // to take a snapshot of the state of the
    // foreground process in the terminal

    void requireUrlFilterUpdate();
    void highlightMatches(bool highlight);
    void scrollBackOptionsChanged(int mode , int lines);
    void sessionResizeRequest(const QSize& size);
    void trackOutput(QKeyEvent* event);  // move view to end of current output
    // when a key press occurs in the
    // display area

    void updateSearchFilter();

    void zmodemDownload();
    void zmodemUpload();

    /* Returns true if called within a KPart; false if called within Konsole. */
    bool isKonsolePart() const;

    // update actions related with selected text
    void updateCopyAction(const QString& selectedText);
    void updateWebSearchMenu();

private:
    // begins the search
    // text - pattern to search for
    // direction - value from SearchHistoryTask::SearchDirection enum to specify
    //             the search direction
    void beginSearch(const QString& text , int direction);
    QRegExp regexpFromSearchBarOptions();
    bool reverseSearchChecked() const;
    void setupCommonActions();
    void setupExtraActions();
    void removeSearchFilter(); // remove and delete the current search filter if set
    void setFindNextPrevEnabled(bool enabled);
    void listenForScreenWindowUpdates();

private:
    void updateSessionIcon();

    QPointer<Session>         _session;
    QPointer<TerminalDisplay> _view;
    SessionGroup*               _copyToGroup;

    ProfileList* _profileList;

    KIcon      _sessionIcon;
    QString    _sessionIconName;
    int        _previousState;

    UrlFilter*      _viewUrlFilter;
    RegExpFilter*   _searchFilter;

    KAction* _copyInputToAllTabsAction;

    KAction* _findAction;
    KAction* _findNextAction;
    KAction* _findPreviousAction;

    QTimer* _interactionTimer;

    bool _urlFilterUpdateRequired;

    int _searchStartLine;
    int _prevSearchResultLine;
    QPointer<IncrementalSearchBar> _searchBar;

    KCodecAction* _codecAction;

    KActionMenu* _switchProfileMenu;
    KActionMenu* _webSearchMenu;

    bool _listenForScreenWindowUpdates;
    bool _preventClose;

    bool _keepIconUntilInteraction;

    QString _selectedText;

    QAction* _showMenuAction;

    static QSet<SessionController*> _allControllers;
    static int _lastControllerId;
    static const KIcon _activityIcon;
    static const KIcon _silenceIcon;
    static const KIcon _broadcastIcon;

    QStringList _bookmarkValidProgramsToClear;

    bool _isSearchBarEnabled;
    QWeakPointer<EditProfileDialog> _editProfileDialog;

    QString _searchText;
};
inline bool SessionController::isValid() const
{
    return !_session.isNull() && !_view.isNull();
}

class SessionTask : public QObject
{
    Q_OBJECT

public:
    explicit SessionTask(QObject* parent = 0);

    void setAutoDelete(bool enable);
    bool autoDelete() const;

    void addSession(Session* session);

    virtual void execute() = 0;

signals:
    void completed(bool success);

protected:
    QList< SessionPtr > sessions() const;

private:
    bool _autoDelete;
    QList< SessionPtr > _sessions;
};

class SaveHistoryTask : public SessionTask
{
    Q_OBJECT

public:
    explicit SaveHistoryTask(QObject* parent = 0);
    virtual ~SaveHistoryTask();

    virtual void execute();

private slots:
    void jobDataRequested(KIO::Job* job , QByteArray& data);
    void jobResult(KJob* job);

private:
    class SaveJob // structure to keep information needed to process
        // incoming data requests from jobs
    {
    public:
        SessionPtr session; // the session associated with a history save job
        int lastLineFetched; // the last line processed in the previous data request
        // set this to -1 at the start of the save job

        TerminalCharacterDecoder* decoder;  // decoder used to convert terminal characters
        // into output
    };

    QHash<KJob*, SaveJob> _jobSession;
};

//class SearchHistoryThread;
class SearchHistoryTask : public SessionTask
{
    Q_OBJECT

public:
    enum SearchDirection {
        ForwardsSearch,
        BackwardsSearch
    };

    explicit SearchHistoryTask(QObject* parent = 0);

    void addScreenWindow(Session* session , ScreenWindow* searchWindow);

    void setRegExp(const QRegExp& regExp);
    QRegExp regExp() const;

    void setSearchDirection(SearchDirection direction);
    SearchDirection searchDirection() const;

    void setStartLine(int startLine);

    virtual void execute();

private:
    typedef QPointer<ScreenWindow> ScreenWindowPtr;

    void executeOnScreenWindow(SessionPtr session , ScreenWindowPtr window);
    void highlightResult(ScreenWindowPtr window , int position);

    QMap< SessionPtr , ScreenWindowPtr > _windows;
    QRegExp _regExp;
    SearchDirection _direction;
    int _startLine;

    //static QPointer<SearchHistoryThread> _thread;
};
}

#endif //SESSIONCONTROLLER_H