summaryrefslogtreecommitdiffstats
path: root/kate/app/katesession.cpp
diff options
context:
space:
mode:
authorMichele Calgaro <michele.calgaro@yahoo.it>2017-09-15 23:37:24 +0900
committerMichele Calgaro <michele.calgaro@yahoo.it>2017-09-15 23:37:24 +0900
commit73e2d6bc1c5d0d5ec4783b44f50a4d5d81d27afc (patch)
tree6979c1670fa6f7a82a8b502be8c10cdacc7c5210 /kate/app/katesession.cpp
parentcd2fc7ba9120fac49ebe6ceaee51bc8eaf802d05 (diff)
parent6131095c14221ddbd16805059a9f3b3fc6c58225 (diff)
downloadtdebase-73e2d6bc1c5d0d5ec4783b44f50a4d5d81d27afc.tar.gz
tdebase-73e2d6bc1c5d0d5ec4783b44f50a4d5d81d27afc.zip
Merge branch 'katesessions': add Kate session panel.
Diffstat (limited to 'kate/app/katesession.cpp')
-rw-r--r--kate/app/katesession.cpp1351
1 files changed, 667 insertions, 684 deletions
diff --git a/kate/app/katesession.cpp b/kate/app/katesession.cpp
index 2c0057bf8..4b973214b 100644
--- a/kate/app/katesession.cpp
+++ b/kate/app/katesession.cpp
@@ -1,4 +1,6 @@
/* 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
@@ -17,7 +19,6 @@
*/
#include "katesession.h"
-#include "katesession.moc"
#include "kateapp.h"
#include "katemainwindow.h"
@@ -27,7 +28,6 @@
#include <tdelocale.h>
#include <kdebug.h>
#include <kdirwatch.h>
-#include <tdelistview.h>
#include <kinputdialog.h>
#include <kiconloader.h>
#include <tdemessagebox.h>
@@ -37,884 +37,867 @@
#include <tdepopupmenu.h>
#include <tqdir.h>
+#include <tqfile.h>
#include <tqlabel.h>
#include <tqlayout.h>
#include <tqvbox.h>
#include <tqhbox.h>
-#include <tqcheckbox.h>
#include <tqdatetime.h>
#include <tqmap.h>
#include <unistd.h>
#include <time.h>
-bool operator<( const KateSession::Ptr& a, const KateSession::Ptr& b )
+// FIXME general: need to keep doc list and current session's m_documents in synchro
+// all the time (doc open, doc closed, doc renamed).
+// To be done when doc list software is developed
+
+// String constants
+namespace
+{
+ // Kate session
+ const char *KS_COUNT = "Count";
+ const char *KS_DOCCOUNT = "Document count";
+ const char *KS_DOCLIST = "Document list";
+ const char *KS_GENERAL = "General";
+ const char *KS_NAME = "Name";
+ const char *KS_OPENDOC = "Open Documents";
+ const char *KS_READONLY = "ReadOnly";
+ const char *KS_OPEN_MAINWINDOWS = "Open MainWindows";
+ const char *KS_UNNAMED = "Unnamed";
+
+ // Kate session manager
+ const char *KSM_DIR = "kate/sessions";
+ const char *KSM_FILE = "sessions.list";
+ const char *KSM_SESSIONS_COUNT = "Sessions count";
+ const char *KSM_LAST_SESSION_ID = "Last session id";
+ const char *KSM_SESSIONS_LIST = "Sessions list";
+
+ // Kate app
+ const char *KAPP_GENERAL = "General";
+ const char *KAPP_LAST_SESSION = "Last Session";
+ const char *KAPP_STARTUP_SESSION = "Startup Session";
+ const char *KAPP_NEW = "new";
+ const char *KAPP_LAST = "last";
+ const char *KAPP_MANUAL = "manual";
+ const char *KAPP_SESSION_EXIT = "Session Exit";
+ const char *KAPP_DISCARD = "discard";
+ const char *KAPP_SAVE = "save";
+ const char *KAPP_ASK = "ask";
+}
+
+//BEGIN Kate session
+KateSession::KateSession(const KateSessionManager &manager, const TQString &sessionName,
+ const TQString &fileName) :
+ m_manager(manager), m_sessionName(sessionName), m_filename(fileName),
+ m_readOnly(false), m_documents(), m_config(NULL)
+{
+ load(false);
+}
+
+//------------------------------------
+KateSession::KateSession(const KateSession &session, const TQString &newSessionName) :
+ m_manager(session.m_manager), m_sessionName(newSessionName), m_filename(),
+ m_readOnly(false), m_documents(session.m_documents), m_config(NULL)
+{
+ createFilename();
+ if (session.m_config)
+ {
+ m_config = new KSimpleConfig(m_filename);
+ session.m_config->copyTo(m_filename, m_config);
+ m_config->sync();
+ }
+}
+
+//------------------------------------
+KateSession::~KateSession()
{
- return a->sessionName().lower() < b->sessionName().lower();
+ if (m_config)
+ {
+ delete m_config;
+ }
}
-KateSession::KateSession (KateSessionManager *manager, const TQString &fileName, const TQString &name)
- : m_sessionFileRel (fileName)
- , m_sessionName (name)
- , m_documents (0)
- , m_manager (manager)
- , m_readConfig (0)
- , m_writeConfig (0)
+//------------------------------------
+void KateSession::setSessionName(const TQString &sessionName)
{
- init ();
+ m_sessionName = sessionName.isEmpty() ? i18n(KS_UNNAMED) : sessionName;
+}
+
+//------------------------------------
+bool KateSession::isStillVolatile() const
+{
+ return m_filename.isEmpty() && m_sessionName == i18n(KS_UNNAMED);
}
-void KateSession::init ()
+//------------------------------------
+void KateSession::load(bool includeGUIInfo)
{
- // given file exists, use it to load some stuff ;)
- if (!m_sessionFileRel.isEmpty() && TDEGlobal::dirs()->exists(sessionFile ()))
+ if (m_config)
{
- KSimpleConfig config (sessionFile (), true);
-
- if (m_sessionName.isEmpty())
+ delete m_config;
+ }
+
+ if (TDEGlobal::dirs()->exists(m_filename))
+ {
+ // Create config object if the session file already exists
+ m_config = new KSimpleConfig(m_filename, m_readOnly);
+ m_config->setGroup(KS_GENERAL);
+ // Session general properties
+ m_sessionName = m_config->readEntry(KS_NAME, i18n(KS_UNNAMED));
+ m_readOnly = m_config->readBoolEntry(KS_READONLY, false);
+ // Document list
+ if (m_config->hasGroup(KS_DOCLIST))
{
- // get the name out of the file
- if (m_sessionFileRel == "default.katesession")
- m_sessionName = i18n("Default Session");
- else
+ // Read new style document list (from TDE R14.1.0)
+ m_config->setGroup(KS_DOCLIST);
+ int docCount = m_config->readNumEntry(KS_DOCCOUNT, 0);
+ for (int i = 0; i < docCount; ++i)
{
- config.setGroup ("General");
- m_sessionName = config.readEntry ("Name", i18n ("Unnamed Session"));
+ TQString urlStr = m_config->readEntry(TQString("URL_%1").arg(i));
+ if (!urlStr.isEmpty())
+ {
+ // Filter out empty URLs
+ m_documents.append(urlStr);
+ }
}
}
-
- // get the document count
- config.setGroup ("Open Documents");
- m_documents = config.readUnsignedNumEntry("Count", 0);
-
- return;
- }
-
- // filename not empty, create the file
- // anders: When will this ever happen???
- if (!m_sessionFileRel.isEmpty())
- {
- kdDebug(13001)<<"Kate::Session: initializing unexisting file!"<<endl;
- // uhh, no name given
- if (m_sessionName.isEmpty())
+ else
{
- if (m_sessionFileRel == "default.katesession")
- m_sessionName = i18n("Default Session");
- else
- m_sessionName = i18n("Session (%1)").arg(TQTime::currentTime().toString(Qt::LocalDate));
+ // Create document list from old session configuration
+ // to effortlessly import existing sessions
+ m_config->setGroup(KS_OPENDOC);
+ int docCount = m_config->readNumEntry(KS_COUNT, 0);
+ for (int i = 0; i < docCount; ++i)
+ {
+ m_config->setGroup(TQString("Document %1").arg(i));
+ TQString urlStr = m_config->readEntry("URL");
+ if (!urlStr.isEmpty())
+ {
+ // Filter out empty URLs
+ m_documents.append(urlStr);
+ }
+ }
}
-
- // create the file, write name to it!
- KSimpleConfig config (sessionFile ());
- config.setGroup ("General");
- config.writeEntry ("Name", m_sessionName);
-
- config.sync ();
}
-}
-
-KateSession::~KateSession ()
-{
- delete m_readConfig;
- delete m_writeConfig;
-}
-
-TQString KateSession::sessionFile () const
-{
- return m_manager->sessionsDir() + "/" + m_sessionFileRel;
-}
-
-bool KateSession::create (const TQString &name, bool force)
-{
- if (!force && (name.isEmpty() || !m_sessionFileRel.isEmpty()))
- return false;
-
- delete m_writeConfig;
- m_writeConfig = 0;
-
- delete m_readConfig;
- m_readConfig = 0;
-
- m_sessionName = name;
-
- // get a usable filename
- int s = time(0);
- TQCString tname;
- while (true)
+ else
{
- tname.setNum (s++);
- KMD5 md5 (tname);
- m_sessionFileRel = TQString ("%1.katesession").arg (md5.hexDigest().data());
-
- if (!TDEGlobal::dirs()->exists(sessionFile ()))
- break;
+ m_filename = TQString::null;
+ }
+ if (m_sessionName.isEmpty())
+ {
+ m_sessionName = i18n(KS_UNNAMED);
+ }
+
+ // Update all current documents if necessary
+ if (includeGUIInfo)
+ {
+ activate();
}
-
- // create the file, write name to it!
- KSimpleConfig config (sessionFile ());
- config.setGroup ("General");
- config.writeEntry ("Name", m_sessionName);
- config.sync ();
-
- // reinit ourselfs ;)
- init ();
-
- return true;
-}
-
-bool KateSession::rename (const TQString &name)
-{
- if (name.isEmpty () || m_sessionFileRel.isEmpty() || m_sessionFileRel == "default.katesession")
- return false;
-
- m_sessionName = name;
-
- TDEConfig config (sessionFile (), false, false);
- config.setGroup ("General");
- config.writeEntry ("Name", m_sessionName);
- config.sync ();
-
- return true;
-}
-
-TDEConfig *KateSession::configRead ()
-{
- if (m_sessionFileRel.isEmpty())
- return 0;
-
- if (m_readConfig)
- return m_readConfig;
-
- return m_readConfig = new KSimpleConfig (sessionFile (), true);
-}
-
-TDEConfig *KateSession::configWrite ()
-{
- if (m_sessionFileRel.isEmpty())
- return 0;
-
- if (m_writeConfig)
- return m_writeConfig;
-
- m_writeConfig = new KSimpleConfig (sessionFile ());
- m_writeConfig->setGroup ("General");
- m_writeConfig->writeEntry ("Name", m_sessionName);
-
- return m_writeConfig;
-}
-
-KateSessionManager::KateSessionManager (TQObject *parent)
- : TQObject (parent)
- , m_sessionsDir (locateLocal( "data", "kate/sessions"))
- , m_activeSession (new KateSession (this, "", ""))
-{
- kdDebug() << "LOCAL SESSION DIR: " << m_sessionsDir << endl;
-
- // create dir if needed
- TDEGlobal::dirs()->makeDir (m_sessionsDir);
-}
-
-KateSessionManager::~KateSessionManager()
-{
-}
-
-KateSessionManager *KateSessionManager::self()
-{
- return KateApp::self()->sessionManager ();
-}
-
-void KateSessionManager::dirty (const TQString &)
-{
- updateSessionList ();
}
-void KateSessionManager::updateSessionList ()
+//------------------------------------
+void KateSession::save(bool saveGUIInfo, bool setReadOnly)
{
- m_sessionList.clear ();
-
- // Let's get a list of all session we have atm
- TQDir dir (m_sessionsDir, "*.katesession");
-
- bool foundDefault = false;
- for (unsigned int i=0; i < dir.count(); ++i)
+ if (m_readOnly && !setReadOnly)
{
- KateSession *session = new KateSession (this, dir[i], "");
- m_sessionList.append (session);
+ return;
+ }
- kdDebug () << "FOUND SESSION: " << session->sessionName() << " FILE: " << session->sessionFile() << endl;
+ // create a new session filename if needed
+ if (m_filename.isEmpty())
+ {
+ createFilename();
+ }
- if (!foundDefault && (dir[i] == "default.katesession"))
- foundDefault = true;
+ // save session config info
+ if (!m_config)
+ {
+ m_config = new KSimpleConfig(m_filename);
}
- // add default session, if not there
- if (!foundDefault)
- m_sessionList.append (new KateSession (this, "default.katesession", i18n("Default Session")));
+ if (m_config->hasGroup(KS_GENERAL))
+ {
+ m_config->deleteGroup(KS_GENERAL);
+ }
+ m_config->setGroup(KS_GENERAL);
+ m_config->writeEntry(KS_NAME, m_sessionName);
+ m_config->writeEntry(KS_READONLY, m_readOnly);
- qHeapSort(m_sessionList);
-}
+ if (m_config->hasGroup(KS_DOCLIST))
+ {
+ m_config->deleteGroup(KS_DOCLIST);
+ }
+ m_config->setGroup(KS_DOCLIST);
+ m_config->writeEntry(KS_DOCCOUNT, m_documents.count());
+ for (int i = 0; i < (int)m_documents.count(); ++i)
+ {
+ m_config->writeEntry(TQString("URL_%1").arg(i), m_documents[i]);
+ }
-void KateSessionManager::activateSession (KateSession::Ptr session, bool closeLast, bool saveLast, bool loadNew)
-{
- // don't reload.
- // ### comparing the pointers directly is b0rk3d :(
- if ( ! session->sessionName().isEmpty() && session->sessionName() == m_activeSession->sessionName() )
- return;
- // try to close last session
- if (closeLast)
+ // save GUI elements info
+ if (saveGUIInfo)
{
- if (KateApp::self()->activeMainWindow())
+ KateDocManager::self()->saveDocumentList(m_config);
+ // save main windows info
+ int mwCount = KateApp::self()->mainWindows();
+ m_config->setGroup(KS_OPEN_MAINWINDOWS);
+ m_config->writeEntry(KS_COUNT, mwCount);
+ for (int i = 0; i < mwCount; ++i)
{
- if (!KateApp::self()->activeMainWindow()->queryClose_internal())
- return;
+ m_config->setGroup(TQString("MainWindow%1").arg(i));
+ KateApp::self()->mainWindow(i)->saveProperties(m_config);
}
}
- // save last session or not?
- if (saveLast)
- saveActiveSession (true);
+ m_config->sync();
+}
- // really close last
- if (closeLast)
+//------------------------------------
+void KateSession::activate()
+{
+ if (KateDocManager::self()->documents() > 0)
{
- KateDocManager::self()->closeAllDocuments ();
+ KateDocManager::self()->closeAllDocuments();
}
-
- // set the new session
- m_activeSession = session;
-
- if (loadNew)
+
+ Kate::Document::setOpenErrorDialogsActivated(false);
+ if (m_config)
{
- // open the new session
- Kate::Document::setOpenErrorDialogsActivated (false);
-
- TDEConfig *sc = activeSession()->configRead();
-
- if (sc)
- KateApp::self()->documentManager()->restoreDocumentList (sc);
-
- // if we have no session config object, try to load the default
- // (anonymous/unnamed sessions)
- if ( ! sc )
- sc = new KSimpleConfig( sessionsDir() + "/default.katesession" );
-
- // window config
- if (sc)
+ KateApp::self()->documentManager()->restoreDocumentList(m_config);
+
+ // load main windows info, if it exists
+ if (m_config->hasGroup(KS_OPEN_MAINWINDOWS))
{
- TDEConfig *c = KateApp::self()->config();
- c->setGroup("General");
-
- if (c->readBoolEntry("Restore Window Configuration", true))
+ m_config->setGroup(KS_OPEN_MAINWINDOWS);
+ int mwCount = m_config->readUnsignedNumEntry(KS_COUNT, 1);
+ for (int i = 0; i < mwCount; ++i)
{
- // a new, named session, read settings of the default session.
- if ( ! sc->hasGroup("Open MainWindows") )
- sc = new KSimpleConfig( sessionsDir() + "/default.katesession" );
-
- sc->setGroup ("Open MainWindows");
- unsigned int wCount = sc->readUnsignedNumEntry("Count", 1);
-
- for (unsigned int i=0; i < wCount; ++i)
+ if (i >= (int)KateApp::self()->mainWindows())
{
- if (i >= KateApp::self()->mainWindows())
- {
- KateApp::self()->newMainWindow(sc, TQString ("MainWindow%1").arg(i));
- }
- else
- {
- sc->setGroup(TQString ("MainWindow%1").arg(i));
- KateApp::self()->mainWindow(i)->readProperties (sc);
- }
+ KateApp::self()->newMainWindow(m_config, TQString("MainWindow%1").arg(i));
}
-
- if (wCount > 0)
+ else
{
- while (wCount < KateApp::self()->mainWindows())
- {
- KateMainWindow *w = KateApp::self()->mainWindow(KateApp::self()->mainWindows()-1);
- KateApp::self()->removeMainWindow (w);
- delete w;
- }
+ m_config->setGroup(TQString("MainWindow%1").arg(i));
+ KateApp::self()->mainWindow(i)->readProperties(m_config);
}
}
}
-
- Kate::Document::setOpenErrorDialogsActivated (true);
}
+ Kate::Document::setOpenErrorDialogsActivated(true);
}
-KateSession::Ptr KateSessionManager::createSession (const TQString &name)
+//------------------------------------
+void KateSession::createFilename()
{
- KateSession::Ptr s = new KateSession (this, "", "");
- s->create (name);
-
- return s;
+ // create a new session filename if needed
+ if (!m_filename.isEmpty())
+ {
+ return;
+ }
+
+ int s = time(0);
+ TQCString tname;
+ TQString tmpName;
+ while (true)
+ {
+ tname.setNum(s++);
+ KMD5 md5(tname);
+ tmpName = m_manager.getBaseDir() + TQString("%1.katesession").arg(md5.hexDigest().data());
+ if (!TDEGlobal::dirs()->exists(tmpName))
+ {
+ m_filename = tmpName;
+ break;
+ }
+ }
}
+//END Kate session
-KateSession::Ptr KateSessionManager::giveSession (const TQString &name)
-{
- if (name.isEmpty())
- return new KateSession (this, "", "");
- updateSessionList();
+//BEGIN KateSessionManager
+//------------------------------------
+KateSessionManager *KateSessionManager::ksm_instance = NULL;
- for (unsigned int i=0; i < m_sessionList.count(); ++i)
+//------------------------------------
+KateSessionManager* KateSessionManager::self()
+{
+ if (!KateSessionManager::ksm_instance)
{
- if (m_sessionList[i]->sessionName() == name)
- return m_sessionList[i];
+ KateSessionManager::ksm_instance = new KateSessionManager();
}
-
- return createSession (name);
-}
-
-bool KateSessionManager::saveActiveSession (bool tryAsk, bool rememberAsLast)
-{
- if (tryAsk)
+ return KateSessionManager::ksm_instance;
+}
+
+//------------------------------------
+KateSessionManager::KateSessionManager() :
+ m_baseDir(locateLocal("data", KSM_DIR)+"/"), m_configFile(m_baseDir + KSM_FILE),
+ m_activeSessionId(INVALID_SESSION), m_lastSessionId(INVALID_SESSION), m_sessions(),
+ m_config(NULL), m_startupOption(STARTUP_NEW), m_switchOption(SWITCH_DISCARD)
+{
+ // Session startup and switch options
+ updateSessionOptions(SO_ALL);
+
+ // Sessions configuration
+ m_sessions.setAutoDelete(true);
+ int sessionsCount = 0;
+ if (TDEGlobal::dirs()->exists(m_configFile))
{
- // app config
- TDEConfig *c = KateApp::self()->config();
- c->setGroup("General");
-
- TQString sesExit (c->readEntry ("Session Exit", "save"));
-
- if (sesExit == "discard")
- return true;
-
- if (sesExit == "ask")
+ // Read new style configuration (from TDE R14.1.0)
+ m_config = new KSimpleConfig(m_configFile);
+ m_config->setGroup(KSM_SESSIONS_LIST);
+ sessionsCount = m_config->readNumEntry(KSM_SESSIONS_COUNT, 0);
+ m_lastSessionId = m_config->readNumEntry(KSM_LAST_SESSION_ID, INVALID_SESSION);
+ for (int i = 0; i < sessionsCount; ++i)
{
- KDialogBase* dlg = new KDialogBase(i18n ("Save Session?")
- , KDialogBase::Yes | KDialogBase::No
- , KDialogBase::Yes, KDialogBase::No
- );
-
- bool dontAgain = false;
- int res = KMessageBox::createKMessageBox(dlg, TQMessageBox::Question,
- i18n("Save current session?"), TQStringList(),
- i18n("Do not ask again"), &dontAgain, KMessageBox::Notify);
-
- // remember to not ask again with right setting
- if (dontAgain)
+ TQString urlStr = m_config->readEntry(TQString("URL_%1").arg(i));
+ if (!urlStr.isEmpty() && TDEGlobal::dirs()->exists(urlStr))
{
- c->setGroup("General");
-
- if (res == KDialogBase::No)
- c->writeEntry ("Session Exit", "discard");
- else
- c->writeEntry ("Session Exit", "save");
+ // Filter out empty URLs or non existing sessions
+ m_sessions.append(new KateSession(*this, TQString::null, urlStr));
}
-
- if (res == KDialogBase::No)
- return true;
}
}
-
- TDEConfig *sc = activeSession()->configWrite();
-
- if (!sc)
- return false;
-
- KateDocManager::self()->saveDocumentList (sc);
-
- sc->setGroup ("Open MainWindows");
- sc->writeEntry ("Count", KateApp::self()->mainWindows ());
-
- // save config for all windows around ;)
- for (unsigned int i=0; i < KateApp::self()->mainWindows (); ++i )
+ else
{
- sc->setGroup(TQString ("MainWindow%1").arg(i));
- KateApp::self()->mainWindow(i)->saveProperties (sc);
+ // Create sessions list from session files
+ // to effortlessly import existing sessions
+ TQDir sessionDir(m_baseDir, "*.katesession");
+ for (unsigned int i = 0; i < sessionDir.count(); ++i)
+ {
+ m_sessions.append(new KateSession(*this, TQString::null, m_baseDir+sessionDir[i]));
+ }
}
-
- sc->sync();
-
- if (rememberAsLast)
+ sessionsCount = (int)m_sessions.count();
+ if (sessionsCount == 0) // In the worst case, there is no valid session at all
{
- TDEConfig *c = KateApp::self()->config();
- c->setGroup("General");
- c->writeEntry ("Last Session", activeSession()->sessionFileRelative());
- c->sync ();
+ m_sessions.append(new KateSession(*this, TQString::null, TQString::null));
}
-
- return true;
+ if (m_lastSessionId < 0 || m_lastSessionId >= (int)m_sessions.count())
+ {
+ m_lastSessionId = 0; // Invalid last session was detected. Use first in the list
+ }
+
+ //NOTE do not activate any session in the KateSessionManager costructor
+ // since Kate's main window may not be ready yet. The initial session
+ // will be activated by KateApp::startupKate() or KateApp::restoreKate()
}
-bool KateSessionManager::chooseSession ()
+//------------------------------------
+KateSessionManager::~KateSessionManager()
{
- bool success = true;
-
- // app config
- TDEConfig *c = KateApp::self()->config();
- c->setGroup("General");
-
- // get last used session, default to default session
- TQString lastSession (c->readEntry ("Last Session", "default.katesession"));
- TQString sesStart (c->readEntry ("Startup Session", "manual"));
-
- // uhh, just open last used session, show no chooser
- if (sesStart == "last")
+ if (m_config)
{
- activateSession (new KateSession (this, lastSession, ""), false, false);
- return success;
+ delete m_config;
}
+ m_sessions.clear();
+}
- // start with empty new session
- if (sesStart == "new")
+//------------------------------------
+void KateSessionManager::updateSessionOptions(int optionType)
+{
+ // Session startup and switch options
+ TDEConfig *kateCfg = KateApp::self()->config();
+ kateCfg->setGroup(KAPP_GENERAL);
+
+ if (optionType == SO_STARTUP || optionType == SO_ALL)
{
- activateSession (new KateSession (this, "", ""), false, false);
- return success;
+ if (kateCfg->hasKey(KAPP_LAST_SESSION))
+ {
+ // Delete no longer used entry (pre R14.1.0)
+ kateCfg->deleteEntry(KAPP_LAST_SESSION);
+ }
+ TQString startupOption(kateCfg->readEntry(KAPP_STARTUP_SESSION, KAPP_MANUAL));
+ if (startupOption == KAPP_LAST)
+ {
+ m_startupOption = STARTUP_LAST;
+ }
+ else if (startupOption == KAPP_NEW)
+ {
+ m_startupOption = STARTUP_NEW;
+ }
+ else // startupOption == "manual"
+ {
+ m_startupOption = STARTUP_MANUAL;
+ }
}
+
+ if (optionType == SO_SWITCH || optionType == SO_ALL)
+ {
+ TQString switchOption(kateCfg->readEntry(KAPP_SESSION_EXIT, KAPP_ASK));
+ if (switchOption == KAPP_DISCARD)
+ {
+ m_switchOption = SWITCH_DISCARD;
+ }
+ else if (switchOption == KAPP_SAVE)
+ {
+ m_switchOption = SWITCH_SAVE;
+ }
+ else // switchOption == "ask"
+ {
+ m_switchOption = SWITCH_ASK;
+ }
+ }
+}
- KateSessionChooser *chooser = new KateSessionChooser (0, lastSession);
-
- bool retry = true;
- int res = 0;
- while (retry)
+//------------------------------------
+void KateSessionManager::saveSessionOptions(int optionType)
+{
+ TDEConfig *kateCfg = KateApp::self()->config();
+ kateCfg->setGroup(KAPP_GENERAL);
+ if (optionType == SO_STARTUP || optionType == SO_ALL)
+ {
+ if (m_startupOption == STARTUP_LAST)
+ {
+ kateCfg->writeEntry(KAPP_STARTUP_SESSION, KAPP_LAST);
+ }
+ else if (m_startupOption == STARTUP_NEW)
+ {
+ kateCfg->writeEntry(KAPP_STARTUP_SESSION, KAPP_NEW);
+ }
+ else // m_startupOption == STARTUP_MANUAL
+ {
+ kateCfg->writeEntry(KAPP_STARTUP_SESSION, KAPP_MANUAL);
+ }
+ }
+
+ if (optionType == SO_SWITCH || optionType == SO_ALL)
{
- res = chooser->exec ();
+ if (m_switchOption == SWITCH_DISCARD)
+ {
+ kateCfg->writeEntry(KAPP_SESSION_EXIT, KAPP_DISCARD);
+ }
+ else if (m_switchOption == SWITCH_SAVE)
+ {
+ kateCfg->writeEntry(KAPP_SESSION_EXIT, KAPP_SAVE);
+ }
+ else // m_switchOption == SWITCH_ASK
+ {
+ kateCfg->writeEntry(KAPP_SESSION_EXIT, KAPP_ASK);
+ }
+ }
+ kateCfg->sync();
+}
- switch (res)
+//------------------------------------
+void KateSessionManager::saveConfig(bool saveSessions)
+{
+ // Session startup and switch options
+ updateSessionOptions(SO_ALL);
+ saveSessionOptions(SO_ALL);
+
+ // Sessions configuration
+ if (!saveSessions)
+ {
+ // delete all session files if they exist
+ for (int i = 0; i < (int)m_sessions.count(); ++i)
{
- case KateSessionChooser::resultOpen:
+ const TQString &filename = m_sessions[i]->getSessionFilename();
+ if (filename != TQString::null && TQFile::exists(filename))
{
- KateSession::Ptr s = chooser->selectedSession ();
-
- if (!s)
- {
- KMessageBox::error (chooser, i18n("No session selected to open."), i18n ("No Session Selected"));
- break;
- }
-
- activateSession (s, false, false);
- retry = false;
- break;
+ TQFile::remove(filename);
}
-
- // exit the app lateron
- case KateSessionChooser::resultQuit:
- success = false;
- retry = false;
- break;
-
- default:
- activateSession (new KateSession (this, "", ""), false, false);
- retry = false;
- break;
}
+
+ m_sessions.clear();
+ m_activeSessionId = INVALID_SESSION;
}
-
- // write back our nice boolean :)
- if (success && chooser->reopenLastSession ())
+
+ if (!m_config)
{
- c->setGroup("General");
-
- if (res == KateSessionChooser::resultOpen)
- c->writeEntry ("Startup Session", "last");
- else if (res == KateSessionChooser::resultNew)
- c->writeEntry ("Startup Session", "new");
-
- c->sync ();
+ m_config = new KSimpleConfig(m_configFile);
}
-
- delete chooser;
-
- return success;
+ if (m_config->hasGroup(KSM_SESSIONS_LIST))
+ {
+ m_config->deleteGroup(KSM_SESSIONS_LIST);
+ }
+ m_config->setGroup(KSM_SESSIONS_LIST);
+ m_config->writeEntry(KSM_SESSIONS_COUNT, m_sessions.count());
+ m_config->writeEntry(KSM_LAST_SESSION_ID, m_activeSessionId);
+ for (int i = 0; i < (int)m_sessions.count(); ++i)
+ {
+ saveSession(i, false, false);
+ m_config->writeEntry(TQString("URL_%1").arg(i), m_sessions[i]->getSessionFilename());
+ }
+ m_config->sync();
}
-void KateSessionManager::sessionNew ()
+//------------------------------------
+const int KateSessionManager::getStartupOption()
{
- activateSession (new KateSession (this, "", ""));
+ updateSessionOptions(SO_STARTUP);
+ return m_startupOption;
}
-void KateSessionManager::sessionOpen ()
+//------------------------------------
+const int KateSessionManager::getSwitchOption()
{
- KateSessionOpenDialog *chooser = new KateSessionOpenDialog (0);
+ updateSessionOptions(SO_SWITCH);
+ return m_switchOption;
+}
- int res = chooser->exec ();
+//------------------------------------
+void KateSessionManager::setSwitchOption(int option)
+{
+ m_switchOption = (option == SWITCH_DISCARD || option == SWITCH_SAVE) ? option : SWITCH_ASK;
+ saveSessionOptions(SO_SWITCH);
+ emit switchOptionChanged();
+}
- if (res == KateSessionOpenDialog::resultCancel)
+//------------------------------------
+const TQString& KateSessionManager::getSessionName(int sessionId)
+{
+ if (sessionId < 0 || sessionId >= (int)m_sessions.count())
{
- delete chooser;
- return;
+ return TQString::null;
}
- KateSession::Ptr s = chooser->selectedSession ();
-
- if (s)
- activateSession (s);
-
- delete chooser;
+ return m_sessions[sessionId]->getSessionName();
}
-void KateSessionManager::sessionSave ()
+//------------------------------------
+KateSession* KateSessionManager::getSessionFromId(int sessionId)
{
- // if the active session is valid, just save it :)
- if (saveActiveSession ())
- return;
-
- bool ok = false;
- TQString name = KInputDialog::getText (i18n("Specify Name for Current Session"), i18n("Session name:"), "", &ok);
-
- if (!ok)
- return;
-
- if (name.isEmpty())
+ if (sessionId < 0 || sessionId >= (int)m_sessions.count())
{
- KMessageBox::error (0, i18n("To save a new session, you must specify a name."), i18n ("Missing Session Name"));
- return;
+ return NULL;
}
- activeSession()->create (name);
- saveActiveSession ();
+ return m_sessions[sessionId];
}
-void KateSessionManager::sessionSaveAs ()
+//------------------------------------
+int KateSessionManager::getSessionIdFromName(const TQString &name)
{
- bool ok = false;
- TQString name = KInputDialog::getText (i18n("Specify New Name for Current Session"), i18n("Session name:"), "", &ok);
-
- if (!ok)
- return;
-
if (name.isEmpty())
+ return INVALID_SESSION;
+
+ for (int i = 0; i < (int)m_sessions.count(); ++i)
{
- KMessageBox::error (0, i18n("To save a session, you must specify a name."), i18n ("Missing Session Name"));
- return;
+ if (m_sessions[i]->getSessionName() == name)
+ return i;
}
- activeSession()->create (name, true);
- saveActiveSession ();
+ return INVALID_SESSION;
}
-
-void KateSessionManager::sessionManage ()
+//------------------------------------
+bool KateSessionManager::activateSession(int sessionId, bool saveCurr)
{
- KateSessionManageDialog *dlg = new KateSessionManageDialog (0);
-
- dlg->exec ();
-
- delete dlg;
-}
+ if (sessionId < 0 || sessionId >= (int)m_sessions.count())
+ {
+ return false;
+ }
-//BEGIN CHOOSER DIALOG
+ if (sessionId == m_activeSessionId)
+ {
+ return true;
+ }
-class KateSessionChooserItem : public TQListViewItem
-{
- public:
- KateSessionChooserItem (TDEListView *lv, KateSession::Ptr s)
- : TQListViewItem (lv, s->sessionName())
- , session (s)
+ int oldSessionId = m_activeSessionId;
+ if (m_activeSessionId != INVALID_SESSION)
+ {
+ // Do this only if a session has already been activated earlier,
+ if (KateApp::self()->activeMainWindow())
{
- TQString docs;
- docs.setNum (s->documents());
- setText (1, docs);
+ // First check if all documents can be closed safely
+ if (!KateApp::self()->activeMainWindow()->queryClose_internal())
+ return false;
+ }
+ if (saveCurr)
+ {
+ saveSession(m_activeSessionId, true);
+ }
+ else
+ {
+ // Delete current session before activating the new one
+ const TQString &filename = m_sessions[m_activeSessionId]->getSessionFilename();
+ if (filename != TQString::null && TQFile::exists(filename))
+ {
+ TQFile::remove(filename);
+ }
+ m_sessions.remove(m_activeSessionId); // this also deletes the KateSession item since auto-deletion is enabled
+ m_activeSessionId = INVALID_SESSION;
+ if (sessionId > oldSessionId)
+ {
+ --sessionId;
+ }
+ emit sessionDeleted(oldSessionId);
+ oldSessionId = INVALID_SESSION;
}
-
- KateSession::Ptr session;
-};
-
-KateSessionChooser::KateSessionChooser (TQWidget *parent, const TQString &lastSession)
- : KDialogBase ( parent
- , ""
- , true
- , i18n ("Session Chooser")
- , KDialogBase::User1 | KDialogBase::User2 | KDialogBase::User3
- , KDialogBase::User2
- , true
- , KStdGuiItem::quit ()
- , KGuiItem (i18n ("Open Session"), "document-open")
- , KGuiItem (i18n ("New Session"), "document-new")
- )
-{
- TQHBox *page = new TQHBox (this);
- page->setMinimumSize (400, 200);
- setMainWidget(page);
-
- TQHBox *hb = new TQHBox (page);
- hb->setSpacing (KDialog::spacingHint());
-
- TQLabel *label = new TQLabel (hb);
- label->setPixmap (UserIcon("sessionchooser"));
- label->setFrameStyle (TQFrame::Panel | TQFrame::Sunken);
-
- TQVBox *vb = new TQVBox (hb);
- vb->setSpacing (KDialog::spacingHint());
-
- m_sessions = new TDEListView (vb);
- m_sessions->addColumn (i18n("Session Name"));
- m_sessions->addColumn (i18n("Open Documents"));
- m_sessions->setResizeMode (TQListView::AllColumns);
- m_sessions->setSelectionMode (TQListView::Single);
- m_sessions->setAllColumnsShowFocus (true);
-
- connect (m_sessions, TQT_SIGNAL(selectionChanged()), this, TQT_SLOT(selectionChanged()));
- connect (m_sessions, TQT_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint &, int)), this, TQT_SLOT(slotUser2()));
-
- KateSessionList &slist (KateSessionManager::self()->sessionList());
- for (unsigned int i=0; i < slist.count(); ++i)
- {
- KateSessionChooserItem *item = new KateSessionChooserItem (m_sessions, slist[i]);
-
- if (slist[i]->sessionFileRelative() == lastSession)
- m_sessions->setSelected (item, true);
}
- m_useLast = new TQCheckBox (i18n ("&Always use this choice"), vb);
-
- setResult (resultNone);
-
- // trigger action update
- selectionChanged ();
+ m_activeSessionId = sessionId;
+ m_sessions[sessionId]->activate();
+ m_lastSessionId = INVALID_SESSION;
+ emit sessionActivated(m_activeSessionId, oldSessionId);
+ return true;
}
-KateSessionChooser::~KateSessionChooser ()
+//------------------------------------
+int KateSessionManager::newSession(const TQString &sessionName, bool saveCurr)
{
+ m_sessions.append(new KateSession(*this, sessionName, TQString::null));
+ int newSessionId = m_sessions.count() - 1;
+ emit sessionCreated(newSessionId);
+ activateSession(newSessionId, saveCurr);
+ return newSessionId;
}
-KateSession::Ptr KateSessionChooser::selectedSession ()
+//------------------------------------
+int KateSessionManager::cloneSession(int sessionId, const TQString &sessionName, bool activate, bool deleteCurr)
{
- KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
-
- if (!item)
- return 0;
+ if (sessionId < 0 || sessionId >= (int)m_sessions.count())
+ {
+ return INVALID_SESSION;
+ }
- return item->session;
+ m_sessions.append(new KateSession(*m_sessions[sessionId], sessionName));
+ int newSessionId = m_sessions.count() - 1;
+ emit sessionCreated(newSessionId);
+
+ // If cloning the active session, the new session will contain the current status
+ // and the original session will be restored to the last saved state (save as... functionality)
+ saveSession(newSessionId, sessionId == m_activeSessionId);
+ if (sessionId == m_activeSessionId)
+ {
+ reloadActiveSession();
+ }
+
+ if (activate)
+ {
+ activateSession(newSessionId, m_activeSessionId != INVALID_SESSION && !deleteCurr);
+ }
+ return newSessionId;
}
-bool KateSessionChooser::reopenLastSession ()
+//------------------------------------
+bool KateSessionManager::restoreLastSession()
{
- return m_useLast->isChecked ();
+ if (m_activeSessionId != INVALID_SESSION)
+ {
+ return false;
+ }
+ return activateSession(m_lastSessionId, false);
}
-void KateSessionChooser::slotUser2 ()
+//-------------------------------------------
+void KateSessionManager::saveSession(int sessionId, bool saveGUIInfo, bool setReadOnly)
{
- done (resultOpen);
+ if (sessionId < 0 || sessionId >= (int)m_sessions.count())
+ {
+ return;
+ }
+ m_sessions[sessionId]->save(saveGUIInfo, setReadOnly);
+ emit sessionSaved(sessionId);
}
-void KateSessionChooser::slotUser3 ()
+//-------------------------------------------
+bool KateSessionManager::deleteSession(int sessionId, int actSessId)
{
- done (resultNew);
-}
+ if (sessionId < 0 || sessionId >= (int)m_sessions.count())
+ {
+ return false;
+ }
-void KateSessionChooser::slotUser1 ()
-{
- done (resultQuit);
-}
+ // delete session file if it exists
+ const TQString &filename = m_sessions[sessionId]->getSessionFilename();
+ if (filename != TQString::null && TQFile::exists(filename))
+ {
+ TQFile::remove(filename);
+ }
+ // delete session
+ m_sessions.remove(sessionId); // this also deletes the KateSession item since auto-deletion is enabled
+ if (m_activeSessionId > sessionId)
+ {
+ --m_activeSessionId;
+ }
+ else if (m_activeSessionId == sessionId)
+ {
+ m_activeSessionId = INVALID_SESSION;
+ }
+ emit sessionDeleted(sessionId);
+ if (m_activeSessionId == INVALID_SESSION)
+ {
+ if (m_sessions.count() > 0 && actSessId >= 0 && actSessId < (int)m_sessions.count())
+ {
+ activateSession(actSessId, false);
+ }
+ else
+ {
+ newSession();
+ }
+ }
-void KateSessionChooser::selectionChanged ()
-{
- enableButton (KDialogBase::User2, m_sessions->selectedItem ());
+ return true;
}
-//END CHOOSER DIALOG
-
-//BEGIN OPEN DIALOG
-
-KateSessionOpenDialog::KateSessionOpenDialog (TQWidget *parent)
- : KDialogBase ( parent
- , ""
- , true
- , i18n ("Open Session")
- , KDialogBase::User1 | KDialogBase::User2
- , KDialogBase::User2
- , false
- , KStdGuiItem::cancel ()
- , KGuiItem( i18n("&Open"), "document-open")
- )
+//-------------------------------------------
+void KateSessionManager::swapSessionsPosition(int sessionId1, int sessionId2)
{
- TQHBox *page = new TQHBox (this);
- page->setMinimumSize (400, 200);
- setMainWidget(page);
-
- TQHBox *hb = new TQHBox (page);
-
- TQVBox *vb = new TQVBox (hb);
-
- m_sessions = new TDEListView (vb);
- m_sessions->addColumn (i18n("Session Name"));
- m_sessions->addColumn (i18n("Open Documents"));
- m_sessions->setResizeMode (TQListView::AllColumns);
- m_sessions->setSelectionMode (TQListView::Single);
- m_sessions->setAllColumnsShowFocus (true);
-
- connect (m_sessions, TQT_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint &, int)), this, TQT_SLOT(slotUser2()));
+ if (sessionId1 < 0 || sessionId1 >= (int)m_sessions.count() ||
+ sessionId2 < 0 || sessionId2 >= (int)m_sessions.count() ||
+ sessionId1 == sessionId2)
+ {
+ return;
+ }
- KateSessionList &slist (KateSessionManager::self()->sessionList());
- for (unsigned int i=0; i < slist.count(); ++i)
+ int idxMin, idxMax;
+ if (sessionId1 < sessionId2)
+ {
+ idxMin = sessionId1;
+ idxMax = sessionId2;
+ }
+ else
{
- new KateSessionChooserItem (m_sessions, slist[i]);
+ idxMin = sessionId2;
+ idxMax = sessionId1;
}
- setResult (resultCancel);
-}
+ KateSession *sessMax = m_sessions.take(idxMax);
+ KateSession *sessMin = m_sessions.take(idxMin);
+ m_sessions.insert(idxMin, sessMax);
+ m_sessions.insert(idxMax, sessMin);
+ if (m_activeSessionId == sessionId1)
+ {
+ m_activeSessionId = sessionId2;
+ }
+ else if (m_activeSessionId == sessionId2)
+ {
+ m_activeSessionId = sessionId1;
+ }
-KateSessionOpenDialog::~KateSessionOpenDialog ()
-{
+ emit sessionsSwapped(idxMin, idxMax);
}
-KateSession::Ptr KateSessionOpenDialog::selectedSession ()
+//-------------------------------------------
+void KateSessionManager::moveSessionForward(int sessionId)
{
- KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
-
- if (!item)
- return 0;
+ if (sessionId < 0 || sessionId >= ((int)m_sessions.count() - 1))
+ {
+ return;
+ }
- return item->session;
+ swapSessionsPosition(sessionId, sessionId + 1);
}
-void KateSessionOpenDialog::slotUser1 ()
+//-------------------------------------------
+void KateSessionManager::moveSessionBackward(int sessionId)
{
- done (resultCancel);
-}
+ if (sessionId < 1 || sessionId >= (int)m_sessions.count())
+ {
+ return;
+ }
-void KateSessionOpenDialog::slotUser2 ()
-{
- done (resultOk);
+ swapSessionsPosition(sessionId, sessionId - 1);
}
-//END OPEN DIALOG
-
-//BEGIN MANAGE DIALOG
-
-KateSessionManageDialog::KateSessionManageDialog (TQWidget *parent)
- : KDialogBase ( parent
- , ""
- , true
- , i18n ("Manage Sessions")
- , KDialogBase::User1
- , KDialogBase::User1
- , false
- , KStdGuiItem::close ()
- )
+//-------------------------------------------
+void KateSessionManager::renameSession(int sessionId, const TQString &newSessionName)
{
- TQHBox *page = new TQHBox (this);
- page->setMinimumSize (400, 200);
- setMainWidget(page);
-
- TQHBox *hb = new TQHBox (page);
- hb->setSpacing (KDialog::spacingHint());
-
- m_sessions = new TDEListView (hb);
- m_sessions->addColumn (i18n("Session Name"));
- m_sessions->addColumn (i18n("Open Documents"));
- m_sessions->setResizeMode (TQListView::AllColumns);
- m_sessions->setSelectionMode (TQListView::Single);
- m_sessions->setAllColumnsShowFocus (true);
-
- connect (m_sessions, TQT_SIGNAL(selectionChanged()), this, TQT_SLOT(selectionChanged()));
-
- updateSessionList ();
-
- TQWidget *vb = new TQWidget (hb);
- TQVBoxLayout *vbl = new TQVBoxLayout (vb);
- vbl->setSpacing (KDialog::spacingHint());
-
- m_rename = new KPushButton (i18n("&Rename..."), vb);
- connect (m_rename, TQT_SIGNAL(clicked()), this, TQT_SLOT(rename()));
- vbl->addWidget (m_rename);
-
- m_del = new KPushButton (KStdGuiItem::del (), vb);
- connect (m_del, TQT_SIGNAL(clicked()), this, TQT_SLOT(del()));
- vbl->addWidget (m_del);
-
- vbl->addStretch ();
+ if (sessionId < 0 || sessionId >= (int)m_sessions.count())
+ {
+ return;
+ }
- // trigger action update
- selectionChanged ();
+ m_sessions[sessionId]->setSessionName(newSessionName);
+ emit sessionRenamed(sessionId);
}
-KateSessionManageDialog::~KateSessionManageDialog ()
+//-------------------------------------------
+void KateSessionManager::setSessionReadOnlyStatus(int sessionId, bool readOnly)
{
-}
+ if (sessionId < 0 || sessionId >= (int)m_sessions.count())
+ {
+ return;
+ }
-void KateSessionManageDialog::slotUser1 ()
-{
- done (0);
+ m_sessions[sessionId]->setReadOnly(readOnly);
+ // Session is saved one last time when making it read only
+ saveSession(sessionId, sessionId == m_activeSessionId, true);
}
+//END KateSessionManager
-void KateSessionManageDialog::selectionChanged ()
+//BEGIN KateSessionChooser
+//-------------------------------------------
+KateSessionChooser::KateSessionChooser(TQWidget *parent)
+ : KDialogBase(parent, "", true, i18n("Session Chooser"),
+ KDialogBase::User1 | KDialogBase::User2 | KDialogBase::User3, KDialogBase::User2,
+ true, KStdGuiItem::quit(), KGuiItem(i18n("Open Session"), "document-open"),
+ KGuiItem(i18n("New Session"), "document-new")), m_listview(NULL)
{
- KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
+ TQHBox *page = new TQHBox(this);
+ page->setMinimumSize(400, 200);
+ setMainWidget(page);
- m_rename->setEnabled (item && item->session->sessionFileRelative() != "default.katesession");
- m_del->setEnabled (item && item->session->sessionFileRelative() != "default.katesession");
-}
+ TQHBox *hb = new TQHBox(page);
+ hb->setSpacing(KDialog::spacingHint());
-void KateSessionManageDialog::rename ()
-{
- KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
+ TQLabel *label = new TQLabel(hb);
+ label->setPixmap(UserIcon("sessionchooser"));
+ label->setFrameStyle (TQFrame::Panel | TQFrame::Sunken);
- if (!item || item->session->sessionFileRelative() == "default.katesession")
- return;
+ TQVBox *vb = new TQVBox(hb);
+ vb->setSpacing (KDialog::spacingHint());
- bool ok = false;
- TQString name = KInputDialog::getText (i18n("Specify New Name for Session"), i18n("Session name:"), item->session->sessionName(), &ok);
+ m_listview = new TDEListView(vb);
+ m_listview->addColumn(i18n("Session Name"));
+ m_listview->addColumn(i18n("Open Documents"));
+ m_listview->setSelectionMode(TQListView::Single);
+ m_listview->setAllColumnsShowFocus(true);
+ m_listview->setSorting(-1);
+ m_listview->setResizeMode(TQListView::LastColumn);
- if (!ok)
- return;
+ connect (m_listview, TQT_SIGNAL(selectionChanged()), this, TQT_SLOT(slotSelectionChanged()));
+ connect (m_listview, TQT_SIGNAL(executed(TQListViewItem*)), this, TQT_SLOT(slotUser2()));
- if (name.isEmpty())
+ TQPtrList<KateSession> &sessions = KateSessionManager::self()->getSessionsList();
+ for (int idx = sessions.count()-1; idx >= 0; --idx)
{
- KMessageBox::error (0, i18n("To save a session, you must specify a name."), i18n ("Missing Session Name"));
- return;
+ new KateSessionChooserItem(m_listview, sessions[idx]->getSessionName(),
+ TQString("%1").arg(sessions[idx]->getDocCount()), idx);
}
- item->session->rename (name);
- updateSessionList ();
+ setResult(RESULT_NO_OP);
+ slotSelectionChanged(); // update button status
}
-void KateSessionManageDialog::del ()
+//-------------------------------------------
+int KateSessionChooser::getSelectedSessionId()
{
- KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
+ KateSessionChooserItem *selectedItem = dynamic_cast<KateSessionChooserItem*>(m_listview->selectedItem());
+ if (!selectedItem)
+ return KateSessionManager::INVALID_SESSION;
- if (!item || item->session->sessionFileRelative() == "default.katesession")
- return;
-
- TQFile::remove (item->session->sessionFile());
- KateSessionManager::self()->updateSessionList ();
- updateSessionList ();
+ return selectedItem->getSessionId();
}
-void KateSessionManageDialog::updateSessionList ()
+//-------------------------------------------
+void KateSessionChooser::slotUser1()
{
- m_sessions->clear ();
-
- KateSessionList &slist (KateSessionManager::self()->sessionList());
- for (unsigned int i=0; i < slist.count(); ++i)
- {
- new KateSessionChooserItem (m_sessions, slist[i]);
- }
+ done(RESULT_QUIT_KATE);
}
-//END MANAGE DIALOG
-
-
-KateSessionsAction::KateSessionsAction(const TQString& text, TQObject* parent, const char* name )
- : TDEActionMenu(text, parent, name)
+//-------------------------------------------
+void KateSessionChooser::slotUser2()
{
- connect(popupMenu(),TQT_SIGNAL(aboutToShow()),this,TQT_SLOT(slotAboutToShow()));
+ done(RESULT_OPEN_EXISTING);
}
-void KateSessionsAction::slotAboutToShow()
+//-------------------------------------------
+void KateSessionChooser::slotUser3()
{
- popupMenu()->clear ();
-
- KateSessionList &slist (KateSessionManager::self()->sessionList());
- for (unsigned int i=0; i < slist.count(); ++i)
- {
- popupMenu()->insertItem (
- slist[i]->sessionName(),
- this, TQT_SLOT (openSession (int)), 0,
- i );
- }
+ done(RESULT_OPEN_NEW);
}
-void KateSessionsAction::openSession (int i)
+//-------------------------------------------
+void KateSessionChooser::slotSelectionChanged()
{
- KateSessionList &slist (KateSessionManager::self()->sessionList());
+ enableButton(KDialogBase::User2, m_listview->selectedItem());
+}
+//END KateSessionChooser
- if ((uint)i >= slist.count())
- return;
+#include "katesession.moc"
- KateSessionManager::self()->activateSession(slist[(uint)i]);
-}
// kate: space-indent on; indent-width 2; replace-tabs on; mixed-indent off;