katesession.h

/* This file is part of the KDE project
   Copyright (C) 2005 Christoph Cullmann <cullmann@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/
 
#ifndef __KATE_SESSION_H__
#define __KATE_SESSION_H__
 
#include "katemain.h"
 
#include <kdialogbase.h>
#include <ksimpleconfig.h>
#include <ksharedptr.h>
#include <tdeaction.h>
 
#include <tqobject.h>
#include <tqptrlist.h>
#include <tqvaluelist.h>
#include <tqstringlist.h>
#include <tdelistview.h>
 
class KateViewSpace;
class KDirWatch;
class KPushButton;
class TDEListView;
class TQCheckBox;
class KateSessionManager;
 
 
//BEGIN KateSession
class KateSession
{
    public:
 
        KateSession(const KateSessionManager &manager, const TQString &sessionName, const TQString &fileName);
 
        KateSession(const KateSession &session, const TQString &newSessionName);
 
        ~KateSession();
 
        const TQString& getSessionName() const { return m_sessionName; }
 
        void setSessionName(const TQString &sessionName);
 
        bool isReadOnly() const { return m_readOnly; }
 
        void setReadOnly(bool readOnly) { m_readOnly = readOnly; }
 
        const TQString& getSessionFilename() const { return m_filename; }
 
        bool isStillVolatile() const;
        
        int getDocCount() const { return m_documents.count(); }
 
        void load(bool includeGUIInfo);
        
        void save(bool saveGUIInfo, bool setReadOnly = false);
 
        void activate();
 
 
    private:
 
        friend class KateViewSpace;
 
        TDEConfig* getConfig() const { return m_config; }
    
        void createFilename();
 
    const KateSessionManager &m_manager;  // The session manager that handles this session
        TQString       m_sessionName;
        TQString       m_filename;
        bool           m_readOnly;
        TQStringList   m_documents;           // document URLs
        KSimpleConfig *m_config;              // session config
 
};
//END KateSession
 
 
//BEGIN KateSessionManager
//FIXME (advanced - multiple main windows or multiple Kate instances)
//There should be only one session manager regardless of how many main windows of Kate are open.
//Changes should propagate to all session panels. Different Kate main windows should run different
//sessions. If the user switches to a session already opened in another Kate window, the other window
//should be brought up to the screen (eventually ask user confirmation first).
//This would allow a safe use of multiple Kate main windows/instances without overwriting session information
//among them. Currently the last instance/main window to be closed will overwrite the information previously
//saved by other Kate instances.
//FIXME update the sessions.list file when switching to another session or to a new session
//
//FIXME create new unnamed session, choose 'save' as session switch option. Exit Kate. 
//      Session is saved without asking for a name
//FIXME improve getStartupOption/getSwitchOption/setSwitchOption using new signal
//      KateApp::optionsChanged()
//FIXME add kdDebug statement to ease debugging
class KateSessionManager : public TQObject
{
  TQ_OBJECT
 
    public:
 
    enum
    {
      INVALID_SESSION = -1
    };
 
    // Session options on Kate startup
    enum 
    {
      STARTUP_NEW = 0,    // New session
      STARTUP_LAST,       // Use last session
      STARTUP_MANUAL      // Manually choose a session
    };
        
    // Session options on session switch or Kate shutdown
    enum 
    {
      SWITCH_DISCARD = 0, // Don't save current session
      SWITCH_SAVE,        // Save current session
      SWITCH_ASK          // Ask user what to do
    };
        
        static KateSessionManager* self();
 
        ~KateSessionManager();
 
        void saveConfig(bool saveSessions);
        
        const int getStartupOption();
        
        const int getSwitchOption();
        
        void setSwitchOption(int option);
        
        const TQString& getBaseDir() const { return m_baseDir; }
        
        int getSessionCount() const { return m_sessions.count(); }
        
        int getActiveSessionId() const { return m_activeSessionId; }
 
        const TQString& getActiveSessionName() /*FIXME const*/ { return m_sessions[m_activeSessionId]->getSessionName(); }
 
        const TQString& getSessionName(int sessionId) /*FIXME const*/;
 
        KateSession* getActiveSession() { return m_sessions[m_activeSessionId]; }
 
        KateSession* getSessionFromId(int sessionId);
 
    int getSessionIdFromName(const TQString &name);
 
        TQPtrList<KateSession>& getSessionsList() { return m_sessions; }
 
        bool activateSession(int sessionId, bool saveCurr = true);
 
        int newSession(const TQString &sessionName = TQString::null, bool saveCurr = true);
 
        int cloneSession(int sessionId, const TQString &sessionName = TQString::null, 
                         bool activate = true, bool deleteCurr = false);
 
        void reloadActiveSession() { m_sessions[m_activeSessionId]->load(true); }
 
    bool restoreLastSession();
 
        void saveActiveSession() { saveSession(m_activeSessionId); }
 
        void saveSession(int sessionId) { saveSession(sessionId, sessionId == m_activeSessionId); }
 
        bool deleteSession(int sessionId, int actSessId);
 
        void moveSessionForward(int sessionId);
 
        void moveSessionBackward(int sessionId);
 
        void renameSession(int sessionId, const TQString &newSessionName);
 
        void setSessionReadOnlyStatus(int sessionId, bool readOnly);
 
  signals:
        void switchOptionChanged();
        
        void sessionActivated(int newSessionId, int oldSessionId);
 
        void sessionCreated(int sessionId);
 
        void sessionSaved(int sessionId);
 
        void sessionDeleted(int sessionId);
 
        void sessionsSwapped(int sessionIdMin, int sessionIdMax);
 
        void sessionRenamed(int sessionId);
 
 
    protected:
        KateSessionManager();
 
    // Session options on Kate startup
    enum 
    {
      SO_STARTUP = 0,     // session startup option only
      SO_SWITCH,          // session switch option only
      SO_ALL,             // session startup and switch options
    };
        
        void updateSessionOptions(int optionType);
        
        void saveSessionOptions(int optionType);
        
        void swapSessionsPosition(int sessionId1, int sessionId2);
 
        void saveSession(int sessionId, bool saveGUIInfo, bool setReadOnly = false);
 
 
        TQString m_baseDir;                         // folder where session files are stored
        TQString m_configFile;                      // file where the session list config is stored
        int m_activeSessionId;              // id of the active session
    int m_lastSessionId;                // id of the last active session before closing Kate
        TQPtrList<KateSession> m_sessions;  // session list
        KSimpleConfig *m_config;                // session manager config
        int m_startupOption;                // session option on Kate startup
        int m_switchOption;                 // session option on session switch or Kate shutdown
        
        static KateSessionManager *ksm_instance;  // the only KateSessionManager instance
};
//END KateSessionManager
 
 
//BEGIN KateSessionChooserItem
class KateSessionChooserItem : public TDEListViewItem
{
  public:
    KateSessionChooserItem(TQListView *listview, const TQString &sessionName, const TQString &nDoc, int sessionId)
      : TDEListViewItem(listview, sessionName, nDoc), m_sessionId(sessionId) {}
 
        int  getSessionId() { return m_sessionId; }
        void setSessionId(int sessionId) { m_sessionId = sessionId; }
 
    protected:
    int m_sessionId;
};
//END KateSessionChooserItem
 
 
//BEGIN KateSessionChooser
//FIXME create one single KateSessionChooser and reuse it all the time
class KateSessionChooser : public KDialogBase
{
    TQ_OBJECT
 
    public:
        enum Result
        {
            RESULT_NO_OP = TQDialog::Rejected,
            RESULT_OPEN_EXISTING,
            RESULT_OPEN_NEW,
            RESULT_QUIT_KATE
        };
 
        KateSessionChooser(TQWidget *parent);
     ~KateSessionChooser() {}
 
        int getSelectedSessionId();  // return the session id of the selected session
 
    protected slots:
 
        void slotUser1();   // open existing session
        void slotUser2();   // open new session
        void slotUser3();   // quit kate
        void slotSelectionChanged();  // list selection has changed
 
    protected:
        TDEListView *m_listview;
};
//END KateSessionChooser
 
#endif