diff options
Diffstat (limited to 'kate/app/katesession.cpp')
| -rw-r--r-- | kate/app/katesession.cpp | 1351 |
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; |