path: root/kate/app/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
/**
 * An object representing a Kate's session.
 */
class KateSession
{
	public:

		/**
		 * create a new session and read the config from fileName if it exists
		 * @param manager the session manager handling this session
		 * @param sessionName session name
		 * @param fileName file where session config is saved to/restored from
		 */
		KateSession(const KateSessionManager &manager, const TQString &sessionName, const TQString &fileName);

		/**
		 * duplicate an existing session into a new one with the given new name.
		 * If the existing session is read-only, the new one will *not* be read-only by default
		 * @param session the existing session 
		 * @param newSessionName the name of the new session
		 */
		KateSession(const KateSession &session, const TQString &newSessionName);

		/**
		 * Destructor
		 */
		~KateSession();

		/**
		* @return the session name
		*/
		const TQString& getSessionName() const { return m_sessionName; }

		/**
		* Set the new session name
		* @param sessionName the new session name
		*/
		void setSessionName(const TQString &sessionName);

		/**
		* @return whether the session is read only or not
		*/
		bool isReadOnly() const { return m_readOnly; }

		/**
		* Set session read only status
		* @param readOnly if true, the session status can not be modified
		*/
		void setReadOnly(bool readOnly) { m_readOnly = readOnly; }

		/**
		* @return the session filename if available, otherwise the null string
		*/
		const TQString& getSessionFilename() const { return m_filename; }

		/**
		* @return whether the session is still volatile, i.e. it has never
		*         been saved and never been named
		*/
		bool isStillVolatile() const;
		
		/**
		* @return the number of documents in the session
		*/
		int getDocCount() const { return m_documents.count(); }

		/**
		 * Load session info from the saved file
		 * @param includeGUIInfo if true, also load the information about the GUI elements
		 */
		void load(bool includeGUIInfo);
		
		/**
		 * Save session info
		 * @param saveGUIInfo if true, save also the information about the GUI elements
		 * @param setReadOnly necessary to save a session that has to be turned to read only
		 */
		void save(bool saveGUIInfo, bool setReadOnly = false);

		/**
		 * Activate the session
		 */
		void activate();


	private:

		friend class KateViewSpace;

		/**
		* @return the session config object
		*/
		TDEConfig* getConfig() const { return m_config; }
    
 		/**
		* create a new filename for a session object
		*/
		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.
/**
 * The Kate session manager. It takes care of storing and retrieving each session object
 * as well as providing methods to operate on them.
 *
 * @note The Kate session manager takes ownership of each session object it handles.
 */
//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
    };
		
		/**
		 * get a pointer to the unique KateSessionManager instance.
		 * If the manager does not exist yet, create it.
		 */
		static KateSessionManager* self();

		/**
		 * Destructor
		 */
		~KateSessionManager();

		/**
		 * Save session manager info
		 * @param saveSessions true  = sessions info will be saved
		 *                     false = all sessions will be discarded
		 */
		void saveConfig(bool saveSessions);
		
		/**
		 * @return the session startup option
		 * The function checks the config file to see if there was any value update 
		 */
		const int getStartupOption();
		
		/**
		 * @return the session switch option
		 * The function checks the config file to see if there was any value update 
		 */
		const int getSwitchOption();
		
		/**
		 * Set the new session switch preference
		 * @param option the new option value. Defaults to SWITCH_ASK if the value is invalid.
		 * @emit switchOptionChanged
		 */
		void setSwitchOption(int option);
		
		/**
		 * @return the session files folder name
		 */
		const TQString& getBaseDir() const { return m_baseDir; }
		
		/**
		 * @return the number of existing sessions
		 */
		int getSessionCount() const { return m_sessions.count(); }
		
		/**
		 * @return the active session id
		 */
		int getActiveSessionId() const { return m_activeSessionId; }

		/**
		 * @return the active session name
		 */
		const TQString& getActiveSessionName() /*FIXME const*/ { return m_sessions[m_activeSessionId]->getSessionName(); }

		/**
		 * @param sessionId the id of the session of interest
		 * @return the name of the specified session
		 */
		const TQString& getSessionName(int sessionId) /*FIXME const*/;

		/**
		 * @return a reference to the active session
		 */
		KateSession* getActiveSession() { return m_sessions[m_activeSessionId]; }

		/**
		 * @param sessionId the id of the session to return
		 * @return a reference to the specified session
		 */
		KateSession* getSessionFromId(int sessionId);

    /**
     * Return the session id of the first session whose name matches the
     * provided one. In case multiple sessions share the same name,
     * the id of the first one found will be returned.
     * @param name the session name to look for
     * @return the session id of the matching session if it is found,
     *         otherwise KateSessionManager::INVALID_SESSION.
     */
    int getSessionIdFromName(const TQString &name);

		/**
		 * @return a reference to the sessions list
		 */
		TQPtrList<KateSession>& getSessionsList() { return m_sessions; }

		/**
		 * Activate the selected session.
		 * @param sessionId the id of the session to activate
		 * @param saveCurr if true, save the current session before activating the new one
		 * @return whether the session was activated or not
		 * @emit sessionActivated
		 */
		bool activateSession(int sessionId, bool saveCurr = true);

		/**
		 * Create a new session and activate it
		 * @param sessionName new session name
		 * @param saveCurr if true, save the current session before activating the new one
		 * @return the id of the newly created session
		 * @emit sessionCreated
     * @emit sessionDeleted  (only when leaving an unstored and unnamed session)
		 */
		int newSession(const TQString &sessionName = TQString::null, bool saveCurr = true);

		/**
		 * Create a new session and activate it if required
		 * @param sessionId the id of the session to clone
		 * @param sessionName the new session name
		 * @param activate if true, activate the new session after creation
		 * @param deleteCurr if true, delete the current session after switching
		 * @return the id of the newly created session
		 * @emit sessionCreated
		 */
		int cloneSession(int sessionId, const TQString &sessionName = TQString::null, 
		                 bool activate = true, bool deleteCurr = false);

		/**
		 * Restore the current active session to the last saved state
		 */
		void reloadActiveSession() { m_sessions[m_activeSessionId]->load(true); }

    /**
     * Restore the last saved session. Can only be used before
     * any other session has been activated, i.e. on Kate's startup
     * @return whether the session was activated or not
     */
    bool restoreLastSession();

		/**
		 * Saves the active session
     * @emit sessionSaved (through invoked "void saveSession(int)" method)
		 */
		void saveActiveSession() { saveSession(m_activeSessionId); }

		/**
		 * Save the specified session
		 * @param sessionId the id of the session to save
     * @emit sessionSaved
     */
		void saveSession(int sessionId) { saveSession(sessionId, sessionId == m_activeSessionId); }

		/**
		 * Delete the specified session
		 * @param sessionId the id of the session to delete
		 * @param actSessId the id of the next session to activate.
		 *        If INVALID_SESSION or invalid, create a new empty session.
		 *        This is only meaningful when deleting the current active session.
     * @return whether the session has been deleted or not
     * @emit sessionDeleted
		 */
		bool deleteSession(int sessionId, int actSessId);

		/**
		 * Move the specified session forward in the session list (by one position)
		 * @param sessionId the id of the session to move
     */
		void moveSessionForward(int sessionId);

		/**
		 * Move the specified session backward in the session list (by one position)
		 * @param sessionId the id of the session to move
     */
		void moveSessionBackward(int sessionId);

		/**
		 * Rename the specified session
		 * @param sessionId the id of the session to rename
		 * @param newSessionName the new session name
     * @emit sessionRenamed
     */
		void renameSession(int sessionId, const TQString &newSessionName);

		/**
		 * Set the read only status of the specified session
		 * @param sessionId the id of the session to modify
		 * @param readOnly the new read only status
		 */
		void setSessionReadOnlyStatus(int sessionId, bool readOnly);

  signals:
		/**
		 * Emitted when the session switch option has been set/changed
		 */
		void switchOptionChanged();
		
		/**
		 * Emitted once a session has been activated
		 * @param newSessionId the id of the previous active session
		 * @param oldSessionId the id of the new active session
		 */
		void sessionActivated(int newSessionId, int oldSessionId);

		/**
		 * Emitted once a session has been created
		 * @param sessionId the id of the new session
		 */
		void sessionCreated(int sessionId);

		/**
		 * Emitted once a session has been saved
		 * @param sessionId the id of the saved session
		 */
		void sessionSaved(int sessionId);

		/**
		 * Emitted once a session has been deleted
		 * @param sessionId the id of the deleted session
		 */
		void sessionDeleted(int sessionId);

		/**
		 * Emitted once the position of the two sessions have been swapped
		 * @param sessionIdMin the smallest id of the session couple
		 * @param sessionIdMax the biggest id of the session couple
		 */
		void sessionsSwapped(int sessionIdMin, int sessionIdMax);

		/**
		 * Emitted once a session has been renamed
		 * @param sessionId the id of the new session
		 */
		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
    };
		
		/**
		 * Updated the session startup and switch options
		 * @param optionType specifies which options needs to be updated
     */
		void updateSessionOptions(int optionType);
		
		/**
		 * Save the session startup and switch options to the config file
		 * @param optionType specifies which options needs to be saved
     */
		void saveSessionOptions(int optionType);
		
		/**
		 * Swap the position of the two specified sessions in the session list
		 * @param sessionId1 the id of the first session
		 * @param sessionId2 the id of the second session
		 * @emit sessionsSwapped
		 */
		void swapSessionsPosition(int sessionId1, int sessionId2);

		/**
		 * Save the specified session
		 * @param sessionId the id of the session to save
		 * @param saveGUIInfo if true, save also the information about the GUI elements
		 * @param setReadOnly necessary to save a session that has to be turned to read only
     * @emit sessionSaved
     */
		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