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.
900 lines
24 KiB
900 lines
24 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2005 Christoph Cullmann <cullmann@kde.org>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License version 2 as published by the Free Software Foundation.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "katesession.h"
|
|
|
|
#include "kateapp.h"
|
|
#include "katemainwindow.h"
|
|
#include "katedocmanager.h"
|
|
|
|
#include <kstandarddirs.h>
|
|
#include <tdelocale.h>
|
|
#include <kdebug.h>
|
|
#include <kdirwatch.h>
|
|
#include <kinputdialog.h>
|
|
#include <kiconloader.h>
|
|
#include <tdemessagebox.h>
|
|
#include <kmdcodec.h>
|
|
#include <kstdguiitem.h>
|
|
#include <kpushbutton.h>
|
|
#include <tdepopupmenu.h>
|
|
|
|
#include <tqdir.h>
|
|
#include <tqfile.h>
|
|
#include <tqlabel.h>
|
|
#include <tqlayout.h>
|
|
#include <tqvbox.h>
|
|
#include <tqhbox.h>
|
|
#include <tqdatetime.h>
|
|
#include <tqmap.h>
|
|
|
|
#include <unistd.h>
|
|
#include <time.h>
|
|
|
|
// 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()
|
|
{
|
|
if (m_config)
|
|
{
|
|
delete m_config;
|
|
}
|
|
}
|
|
|
|
//------------------------------------
|
|
void KateSession::setSessionName(const TQString &sessionName)
|
|
{
|
|
m_sessionName = sessionName.isEmpty() ? i18n(KS_UNNAMED) : sessionName;
|
|
}
|
|
|
|
//------------------------------------
|
|
bool KateSession::isStillVolatile() const
|
|
{
|
|
return m_filename.isEmpty() && m_sessionName == i18n(KS_UNNAMED);
|
|
}
|
|
|
|
//------------------------------------
|
|
void KateSession::load(bool includeGUIInfo)
|
|
{
|
|
if (m_config)
|
|
{
|
|
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))
|
|
{
|
|
// 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)
|
|
{
|
|
TQString urlStr = m_config->readEntry(TQString("URL_%1").arg(i));
|
|
if (!urlStr.isEmpty())
|
|
{
|
|
// Filter out empty URLs
|
|
m_documents.append(urlStr);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_filename = TQString::null;
|
|
}
|
|
if (m_sessionName.isEmpty())
|
|
{
|
|
m_sessionName = i18n(KS_UNNAMED);
|
|
}
|
|
|
|
// Update all current documents if necessary
|
|
if (includeGUIInfo)
|
|
{
|
|
activate();
|
|
}
|
|
}
|
|
|
|
//------------------------------------
|
|
void KateSession::save(bool saveGUIInfo, bool setReadOnly)
|
|
{
|
|
if (m_readOnly && !setReadOnly)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// create a new session filename if needed
|
|
if (m_filename.isEmpty())
|
|
{
|
|
createFilename();
|
|
}
|
|
|
|
// save session config info
|
|
if (!m_config)
|
|
{
|
|
m_config = new KSimpleConfig(m_filename);
|
|
}
|
|
|
|
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);
|
|
|
|
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]);
|
|
}
|
|
|
|
// save GUI elements info
|
|
if (saveGUIInfo)
|
|
{
|
|
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)
|
|
{
|
|
m_config->setGroup(TQString("MainWindow%1").arg(i));
|
|
KateApp::self()->mainWindow(i)->saveProperties(m_config);
|
|
}
|
|
}
|
|
|
|
m_config->sync();
|
|
}
|
|
|
|
//------------------------------------
|
|
void KateSession::activate()
|
|
{
|
|
if (KateDocManager::self()->documents() > 0)
|
|
{
|
|
KateDocManager::self()->closeAllDocuments();
|
|
}
|
|
|
|
Kate::Document::setOpenErrorDialogsActivated(false);
|
|
if (m_config)
|
|
{
|
|
KateApp::self()->documentManager()->restoreDocumentList(m_config);
|
|
|
|
// load main windows info, if it exists
|
|
if (m_config->hasGroup(KS_OPEN_MAINWINDOWS))
|
|
{
|
|
m_config->setGroup(KS_OPEN_MAINWINDOWS);
|
|
int mwCount = m_config->readUnsignedNumEntry(KS_COUNT, 1);
|
|
for (int i = 0; i < mwCount; ++i)
|
|
{
|
|
if (i >= (int)KateApp::self()->mainWindows())
|
|
{
|
|
KateApp::self()->newMainWindow(m_config, TQString("MainWindow%1").arg(i));
|
|
}
|
|
else
|
|
{
|
|
m_config->setGroup(TQString("MainWindow%1").arg(i));
|
|
KateApp::self()->mainWindow(i)->readProperties(m_config);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Kate::Document::setOpenErrorDialogsActivated(true);
|
|
}
|
|
|
|
//------------------------------------
|
|
void KateSession::createFilename()
|
|
{
|
|
// 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
|
|
|
|
|
|
//BEGIN KateSessionManager
|
|
//------------------------------------
|
|
KateSessionManager *KateSessionManager::ksm_instance = NULL;
|
|
|
|
//------------------------------------
|
|
KateSessionManager* KateSessionManager::self()
|
|
{
|
|
if (!KateSessionManager::ksm_instance)
|
|
{
|
|
KateSessionManager::ksm_instance = new KateSessionManager();
|
|
}
|
|
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))
|
|
{
|
|
// 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)
|
|
{
|
|
TQString urlStr = m_config->readEntry(TQString("URL_%1").arg(i));
|
|
if (!urlStr.isEmpty() && TDEGlobal::dirs()->exists(urlStr))
|
|
{
|
|
// Filter out empty URLs or non existing sessions
|
|
m_sessions.append(new KateSession(*this, TQString::null, urlStr));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 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]));
|
|
}
|
|
}
|
|
sessionsCount = (int)m_sessions.count();
|
|
if (sessionsCount == 0) // In the worst case, there is no valid session at all
|
|
{
|
|
m_sessions.append(new KateSession(*this, TQString::null, TQString::null));
|
|
}
|
|
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()
|
|
}
|
|
|
|
//------------------------------------
|
|
KateSessionManager::~KateSessionManager()
|
|
{
|
|
if (m_config)
|
|
{
|
|
delete m_config;
|
|
}
|
|
m_sessions.clear();
|
|
}
|
|
|
|
//------------------------------------
|
|
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)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------
|
|
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)
|
|
{
|
|
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();
|
|
}
|
|
|
|
//------------------------------------
|
|
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)
|
|
{
|
|
const TQString &filename = m_sessions[i]->getSessionFilename();
|
|
if (filename != TQString::null && TQFile::exists(filename))
|
|
{
|
|
TQFile::remove(filename);
|
|
}
|
|
}
|
|
|
|
m_sessions.clear();
|
|
m_activeSessionId = INVALID_SESSION;
|
|
}
|
|
|
|
if (!m_config)
|
|
{
|
|
m_config = new KSimpleConfig(m_configFile);
|
|
}
|
|
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();
|
|
}
|
|
|
|
//------------------------------------
|
|
const int KateSessionManager::getStartupOption()
|
|
{
|
|
updateSessionOptions(SO_STARTUP);
|
|
return m_startupOption;
|
|
}
|
|
|
|
//------------------------------------
|
|
const int KateSessionManager::getSwitchOption()
|
|
{
|
|
updateSessionOptions(SO_SWITCH);
|
|
return m_switchOption;
|
|
}
|
|
|
|
//------------------------------------
|
|
void KateSessionManager::setSwitchOption(int option)
|
|
{
|
|
m_switchOption = (option == SWITCH_DISCARD || option == SWITCH_SAVE) ? option : SWITCH_ASK;
|
|
saveSessionOptions(SO_SWITCH);
|
|
emit switchOptionChanged();
|
|
}
|
|
|
|
//------------------------------------
|
|
const TQString& KateSessionManager::getSessionName(int sessionId)
|
|
{
|
|
if (sessionId < 0 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return TQString::null;
|
|
}
|
|
|
|
return m_sessions[sessionId]->getSessionName();
|
|
}
|
|
|
|
//------------------------------------
|
|
KateSession* KateSessionManager::getSessionFromId(int sessionId)
|
|
{
|
|
if (sessionId < 0 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return m_sessions[sessionId];
|
|
}
|
|
|
|
//------------------------------------
|
|
int KateSessionManager::getSessionIdFromName(const TQString &name)
|
|
{
|
|
if (name.isEmpty())
|
|
return INVALID_SESSION;
|
|
|
|
for (int i = 0; i < (int)m_sessions.count(); ++i)
|
|
{
|
|
if (m_sessions[i]->getSessionName() == name)
|
|
return i;
|
|
}
|
|
|
|
return INVALID_SESSION;
|
|
}
|
|
|
|
//------------------------------------
|
|
bool KateSessionManager::activateSession(int sessionId, bool saveCurr)
|
|
{
|
|
if (sessionId < 0 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (sessionId == m_activeSessionId)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
int oldSessionId = m_activeSessionId;
|
|
if (m_activeSessionId != INVALID_SESSION)
|
|
{
|
|
// Do this only if a session has already been activated earlier,
|
|
if (KateApp::self()->activeMainWindow())
|
|
{
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
m_activeSessionId = sessionId;
|
|
m_sessions[sessionId]->activate();
|
|
m_lastSessionId = INVALID_SESSION;
|
|
emit sessionActivated(m_activeSessionId, oldSessionId);
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------
|
|
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;
|
|
}
|
|
|
|
//------------------------------------
|
|
int KateSessionManager::cloneSession(int sessionId, const TQString &sessionName, bool activate, bool deleteCurr)
|
|
{
|
|
if (sessionId < 0 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return INVALID_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 KateSessionManager::restoreLastSession()
|
|
{
|
|
if (m_activeSessionId != INVALID_SESSION)
|
|
{
|
|
return false;
|
|
}
|
|
return activateSession(m_lastSessionId, false);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionManager::saveSession(int sessionId, bool saveGUIInfo, bool setReadOnly)
|
|
{
|
|
if (sessionId < 0 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return;
|
|
}
|
|
m_sessions[sessionId]->save(saveGUIInfo, setReadOnly);
|
|
emit sessionSaved(sessionId);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
bool KateSessionManager::deleteSession(int sessionId, int actSessId)
|
|
{
|
|
if (sessionId < 0 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 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();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionManager::swapSessionsPosition(int sessionId1, int sessionId2)
|
|
{
|
|
if (sessionId1 < 0 || sessionId1 >= (int)m_sessions.count() ||
|
|
sessionId2 < 0 || sessionId2 >= (int)m_sessions.count() ||
|
|
sessionId1 == sessionId2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int idxMin, idxMax;
|
|
if (sessionId1 < sessionId2)
|
|
{
|
|
idxMin = sessionId1;
|
|
idxMax = sessionId2;
|
|
}
|
|
else
|
|
{
|
|
idxMin = sessionId2;
|
|
idxMax = sessionId1;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
emit sessionsSwapped(idxMin, idxMax);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionManager::moveSessionForward(int sessionId)
|
|
{
|
|
if (sessionId < 0 || sessionId >= ((int)m_sessions.count() - 1))
|
|
{
|
|
return;
|
|
}
|
|
|
|
swapSessionsPosition(sessionId, sessionId + 1);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionManager::moveSessionBackward(int sessionId)
|
|
{
|
|
if (sessionId < 1 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return;
|
|
}
|
|
|
|
swapSessionsPosition(sessionId, sessionId - 1);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionManager::renameSession(int sessionId, const TQString &newSessionName)
|
|
{
|
|
if (sessionId < 0 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_sessions[sessionId]->setSessionName(newSessionName);
|
|
emit sessionRenamed(sessionId);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionManager::setSessionReadOnlyStatus(int sessionId, bool readOnly)
|
|
{
|
|
if (sessionId < 0 || sessionId >= (int)m_sessions.count())
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_sessions[sessionId]->setReadOnly(readOnly);
|
|
// Session is saved one last time when making it read only
|
|
saveSession(sessionId, sessionId == m_activeSessionId, true);
|
|
}
|
|
//END KateSessionManager
|
|
|
|
|
|
//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)
|
|
{
|
|
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_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);
|
|
|
|
connect (m_listview, TQT_SIGNAL(selectionChanged()), this, TQT_SLOT(slotSelectionChanged()));
|
|
connect (m_listview, TQT_SIGNAL(executed(TQListViewItem*)), this, TQT_SLOT(slotUser2()));
|
|
|
|
TQPtrList<KateSession> &sessions = KateSessionManager::self()->getSessionsList();
|
|
for (int idx = sessions.count()-1; idx >= 0; --idx)
|
|
{
|
|
new KateSessionChooserItem(m_listview, sessions[idx]->getSessionName(),
|
|
TQString("%1").arg(sessions[idx]->getDocCount()), idx);
|
|
}
|
|
|
|
setResult(RESULT_NO_OP);
|
|
slotSelectionChanged(); // update button status
|
|
}
|
|
|
|
//-------------------------------------------
|
|
int KateSessionChooser::getSelectedSessionId()
|
|
{
|
|
KateSessionChooserItem *selectedItem = dynamic_cast<KateSessionChooserItem*>(m_listview->selectedItem());
|
|
if (!selectedItem)
|
|
return KateSessionManager::INVALID_SESSION;
|
|
|
|
return selectedItem->getSessionId();
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionChooser::slotUser1()
|
|
{
|
|
done(RESULT_QUIT_KATE);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionChooser::slotUser2()
|
|
{
|
|
done(RESULT_OPEN_EXISTING);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionChooser::slotUser3()
|
|
{
|
|
done(RESULT_OPEN_NEW);
|
|
}
|
|
|
|
//-------------------------------------------
|
|
void KateSessionChooser::slotSelectionChanged()
|
|
{
|
|
enableButton(KDialogBase::User2, m_listview->selectedItem());
|
|
}
|
|
//END KateSessionChooser
|
|
|
|
#include "katesession.moc"
|