You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
803 lines
21 KiB
803 lines
21 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2015-2016 Michele Calgaro <micheleDOTcalgaro__AT__yahooDOTit>
|
|
partially based on previous work from
|
|
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)
|
|
//There should be only one session manager regardless of how many instances of Kate are running.
|
|
//Changes should propagate to all session panels. Different Kate instances should run different
|
|
//sessions. If the user switches to a session already opened in another Kate instance, the current
|
|
//session should be saved and then the focus switched to the other instance.
|
|
//This would allow a safe use of multiple Kate instances without overwriting session information
|
|
//among them. Currently the last instance 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
|
|
class KateSessionManager : public TQObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
|
|
enum
|
|
{
|
|
INVALID_SESSION = -1
|
|
};
|
|
|
|
/**
|
|
* get a pointer to the unique KateSessionManager instance.
|
|
* If the manager does not exist yet, create it.
|
|
*/
|
|
static KateSessionManager* self();
|
|
|
|
/**
|
|
* Destructor
|
|
*/
|
|
~KateSessionManager();
|
|
|
|
/**
|
|
* @return the session files folder name
|
|
*/
|
|
const TQString& getBaseDir() const { return m_baseDir; }
|
|
|
|
/**
|
|
* @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
|
|
* @return the id of the newly created session
|
|
* @emit sessionCreated
|
|
*/
|
|
int cloneSession(int sessionId, const TQString &sessionName = TQString::null, bool activate = true);
|
|
|
|
/**
|
|
* 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 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();
|
|
|
|
/**
|
|
* Save session manager info
|
|
* @param saveSessions if true, all sessions will be saved again
|
|
*/
|
|
void saveConfig(bool saveSessions);
|
|
|
|
/**
|
|
* 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
|
|
|
|
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
|
|
|
|
|
|
|
|
|
|
//------------------------------------
|
|
//------------------------------------
|
|
//------------------------------------
|
|
class OldKateSessionManager;
|
|
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 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
|