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
{
  Q_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
{
    Q_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