path: root/kate/app/katesession.h

/* This file is part of the KDE project
   Copyright (C) 2005 Christoph Cullmann <[email protected]>

   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>

class OldKateSessionManager;  // Michele - to be removed with OldKateSession

class KDirWatch;
class TDEListView;
class KPushButton;

class TQCheckBox;

class KateSession
{
  public:

    /**
     * create a new session and read the config from fileName if it exists
     * @param sessionName session name
     * @param fileName file where session config is saved to/restored from
     * @param isFullName true  -> filename is a full filename, used to load/save the session configuration
     *                   false -> filename is a folder name. This is used for new unsaved sessions
     *                            to inject the location where the configuration file should be saved
     */
    KateSession(const TQString &sessionName, const TQString &fileName, bool isFullName);

    /**
     * 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 config can not be saved to file
     */
		void setReadOnly(bool readOnly);

		/**
     * @return the session filename
     */
		const TQString& getSessionFilename() const { return m_filename; }

    /**
     * Save session info
     * @param saveDocList if true, save also the information about the documents currently open
     */
	  void save(bool saveDocList);

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

  private:
    TQString       m_sessionName;
    TQString       m_filename;
    bool           m_isFullName;   // true  -> m_filename is a full filename
                                   // false -> m_filename is a folder name.
    bool           m_readOnly;
    int	 					 m_docCount;		 // number of documents in the session
    TQStringList   m_documents;    // document URLs
    KSimpleConfig *m_config;       // session config

};


//------------------------------------
class KateSessionManager
{
  public:

    /**
     * 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
     */
	  void saveConfig();

    /**
     * @return the active session id
     */
	  int getActiveSessionId() const { return m_activeSessionId; }

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

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

    /**
     * Activates 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
     */
    bool activateSession(int sessionId, bool saveCurr = true);

  private:
    KateSessionManager();

    TQString m_baseDir;       					// folder where session files are stored
    TQString m_configFile;     					// file where the session list config is stored
    int m_sessionsCount;	     					// number of sessions
    int m_activeSessionId;              // index of the active session
    TQPtrList<KateSession> m_sessions;  // session list
    KSimpleConfig *m_config;        		// session manager config

		static KateSessionManager *ksm_instance;  // the only KateSessionManager instance
};





//------------------------------------
//------------------------------------
//------------------------------------
class OldKateSession  : public TDEShared
{
  public:
    /**
     * Define a Shared-Pointer type
     */
    typedef TDESharedPtr<OldKateSession> Ptr;

  public:
    /**
     * create a session from given file
     * @param fileName session filename, relative
     * @param name session name
     * @param manager pointer to the manager
     */
    OldKateSession (OldKateSessionManager *manager, const TQString &fileName, const TQString &name);

    /**
     * init the session object, after construction or create
     */
    void init ();

    /**
     * destruct me
     */
    ~OldKateSession ();

    /**
     * session filename, absolute, calculated out of relative filename + session dir
     * @return absolute path to session file
     */
    TQString sessionFile () const;

    /**
     * relative session filename
     * @return relative filename for this session
     */
    const TQString &sessionFileRelative () const { return m_sessionFileRel; }

    /**
     * session name
     * @return name for this session
     */
    const TQString &sessionName () const { return m_sessionName; }

    /**
     * is this a valid session? if not, don't use any session if this is
     * the active one
     */
    bool isNew () const { return m_sessionName.isEmpty(); }

    /**
     * create the session file, if not existing
     * @param name name for this session
     * @param force force to create new file
     * @return true if created, false if no creation needed
     */
    bool create (const TQString &name, bool force = false);

    /**
     * rename this session
     * @param name new name
     * @return success
     */
    bool rename (const TQString &name);

    /**
     * config to read
     * on first access, will create the config object, delete will be done automagic
     * return 0 if we have no file to read config from atm
     * @return config to read from
     */
    TDEConfig *configRead ();

    /**
     * config to write
     * on first access, will create the config object, delete will be done automagic
     * return 0 if we have no file to write config to atm
     * @return config to write from
     */
    TDEConfig *configWrite ();

    /**
     * count of documents in this session
     * @return documents count
     */
    unsigned int documents () const { return m_documents; }

  private:
    /**
     * session filename, in local location we can write to
     * relative filename to the session dirs :)
     */
    TQString m_sessionFileRel;

    /**
     * session name, extracted from the file, to display to the user
     */
    TQString m_sessionName;

    /**
     * number of document of this session
     */
    unsigned int m_documents;

    /**
     * OldKateSessionMananger
     */
    OldKateSessionManager *m_manager;

    /**
     * simpleconfig to read from
     */
    KSimpleConfig *m_readConfig;

    /**
     * simpleconfig to write to
     */
    KSimpleConfig *m_writeConfig;
};

typedef TQValueList<OldKateSession::Ptr> OldKateSessionList;

class OldKateSessionManager : public TQObject
{
  Q_OBJECT

  public:
    OldKateSessionManager(TQObject *parent);
    ~OldKateSessionManager();

    /**
     * allow access to this :)
     * @return instance of the session manager
     */
    static OldKateSessionManager *self();

    /**
     * allow access to the session list
     * kept up to date by watching the dir
     */
    inline OldKateSessionList & sessionList () { updateSessionList (); return m_sessionList; }

    /**
     * activate a session
     * first, it will look if a session with this name exists in list
     * if yes, it will use this session, else it will create a new session file
     * @param session session to activate
     * @param closeLast try to close last session or not?
     * @param saveLast try to save last session or not?
     * @param loadNew load new session stuff?
     */
    void activateSession (OldKateSession::Ptr session, bool closeLast = true, bool saveLast = true, bool loadNew = true);

    /**
     * create a new session
     * @param name session name
     */
    OldKateSession::Ptr createSession (const TQString &name);

    /**
     * return session with given name
     * if no existing session matches, create new one with this name
     * @param name session name
     */
    OldKateSession::Ptr giveSession (const TQString &name);

    /**
     * save current session
     * for sessions without filename: save nothing
     * @param tryAsk should we ask user if needed?
     * @param rememberAsLast remember this session as last used?
     * @return success
     */
    bool saveActiveSession (bool tryAsk = false, bool rememberAsLast = false);

    /**
     * return the current active session
     * sessionFile == empty means we have no session around for this instance of kate
     * @return session active atm
     */
    inline OldKateSession::Ptr activeSession () { return m_activeSession; }

    /**
     * session dir
     * @return global session dir
     */
    inline const TQString &sessionsDir () const { return m_sessionsDir; }

    /**
     * initial session chooser, on app start
     * @return success, if false, app should exit
     */
    bool chooseSession ();

  public slots:
    /**
     * try to start a new session
     * asks user first for name
     */
    void sessionNew ();

    /**
     * try to open a existing session
     */
    void sessionOpen ();

    /**
     * try to save current session
     */
    void sessionSave ();

    /**
     * try to save as current session
     */
    void sessionSaveAs ();

    /**
     * show dialog to manage our sessions
     */
    void sessionManage ();

  private slots:
    void dirty (const TQString &path);

  public:
    /**
     * trigger update of session list
     */
    void updateSessionList ();

  private:
    /**
     * absolute path to dir in home dir where to store the sessions
     */
    TQString m_sessionsDir;

    /**
     * list of current available sessions
     */
    OldKateSessionList m_sessionList;

    /**
     * current active session
     */
    OldKateSession::Ptr m_activeSession;
};

class OldKateSessionChooser : public KDialogBase
{
  Q_OBJECT

  public:
    OldKateSessionChooser (TQWidget *parent, const TQString &lastSession);
    ~OldKateSessionChooser ();

    OldKateSession::Ptr selectedSession ();

    bool reopenLastSession ();

    enum {
      resultQuit = TQDialog::Rejected,
      resultOpen,
      resultNew,
      resultNone
    };

  protected slots:
    /**
     * open session
     */
    void slotUser1 ();

    /**
     * new session
     */
    void slotUser2 ();

    /**
     * quit kate
     */
    void slotUser3 ();

    /**
     * selection has changed
     */
    void selectionChanged ();

  private:
    TDEListView *m_sessions;
    TQCheckBox *m_useLast;
};

class OldKateSessionOpenDialog : public KDialogBase
{
  Q_OBJECT

  public:
    OldKateSessionOpenDialog (TQWidget *parent);
    ~OldKateSessionOpenDialog ();

    OldKateSession::Ptr selectedSession ();

    enum {
      resultOk,
      resultCancel
    };

  protected slots:
    /**
     * cancel pressed
     */
    void slotUser1 ();

    /**
     * ok pressed
     */
    void slotUser2 ();

  private:
    TDEListView *m_sessions;
};

class OldKateSessionManageDialog : public KDialogBase
{
  Q_OBJECT

  public:
    OldKateSessionManageDialog (TQWidget *parent);
    ~OldKateSessionManageDialog ();

  protected slots:
    /**
     * close pressed
     */
    void slotUser1 ();

    /**
     * selection has changed
     */
    void selectionChanged ();

    /**
     * try to rename session
     */
    void rename ();

    /**
     * try to delete session
     */
    void del ();

  private:
    /**
     * update our list
     */
    void updateSessionList ();

  private:
    TDEListView *m_sessions;
    KPushButton *m_rename;
    KPushButton *m_del;
};

class OldKateSessionsAction : public TDEActionMenu
{
  Q_OBJECT

  public:
    OldKateSessionsAction(const TQString& text, TQObject* parent = 0, const char* name = 0);
    ~OldKateSessionsAction (){;};

  public  slots:
    void slotAboutToShow();

    void openSession (int i);
};

#endif