TDE
/
tdebase
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdebase
0
0
Fork 0
Code Issues Releases Wiki Activity

Added initial version of new KateSession and KateSessionManager. The old version of the same classes is still the default for the time being.

Browse Source 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/2/head
Michele Calgaro 9 years ago
parent 2eb6191799
commit f0f642f6b2
2 changed files with 373 additions and 1 deletions
Show Stats Download Patch File Download Diff File

265
kate/app/katesession.cpp
Unescape View File

@ -48,6 +48,271 @@
#include <unistd.h>
#include <time.h>
// 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_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_SESSIONS_LIST = "Sessions list";
}
KateSession::KateSession(const TQString &sessionName, const TQString &filename, bool isFullName) :
m_sessionName(sessionName), m_filename(filename), m_isFullName(isFullName),
m_readOnly(false), m_docCount(0), m_documents(), m_config(NULL)
{
if (m_isFullName && 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 name
if (m_sessionName.isEmpty())
{
m_sessionName = m_config->readEntry(KS_NAME, i18n(KS_UNNAMED));
}
// Read only
m_readOnly = m_config->readBoolEntry(KS_READONLY, false);
m_config->setReadOnly(m_readOnly);
// Document list
if (m_config->hasGroup(KS_DOCLIST))
{
// Read new style document list (from TDE R14.1.0)
m_config->setGroup(KS_DOCLIST);
m_docCount = m_config->readNumEntry(KS_DOCCOUNT, 0);
for (int i=0; i<m_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);
m_docCount = m_config->readNumEntry(KS_COUNT, 0);
for (int i=0; i<m_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);
}
}
}
// Update document count again, in case empty URLs were found
m_docCount = static_cast<int>(m_documents.count());
}
if (m_sessionName.isEmpty())
{
m_sessionName = i18n(KS_UNNAMED);
}
if (m_docCount == 0)
{
m_documents.clear();
}
}
//------------------------------------
KateSession::~KateSession()
{
if (m_config)
{
delete m_config;
}
}
//------------------------------------
void KateSession::setSessionName(const TQString &sessionName)
{
m_sessionName = sessionName;
if (m_sessionName.isEmpty())
{
m_sessionName = i18n(KS_UNNAMED);
}
}
//------------------------------------
void KateSession::setReadOnly(bool readOnly)
{
if (!m_readOnly && readOnly)
{
// When a session is turned read only, make sure the current
// status is first saved to disk
save();
}
m_readOnly = readOnly;
if (m_config)
{
m_config->setReadOnly(m_readOnly);
}
}
//------------------------------------
void KateSession::save()
{
if (m_readOnly)
return;
if (!m_isFullName)
{
// create a new session filename
int s = time(0);
TQCString tname;
TQString tmpName;
while (true)
{
tname.setNum(s++);
KMD5 md5(tname);
tmpName = m_filename + TQString("%1.katesession").arg(md5.hexDigest().data());
if (!TDEGlobal::dirs()->exists(tmpName))
{
m_filename = tmpName;
m_isFullName = true;
break;
}
}
}
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_docCount);
for (int i=0; i<m_docCount; ++i)
{
m_config->writeEntry(TQString("URL_%1").arg(i), m_documents[i]);
}
m_config->sync();
}
//------------------------------------
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_sessionsCount(0), m_sessions(), m_config(NULL)
{
m_sessions.setAutoDelete(true);
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);
m_sessionsCount = m_config->readNumEntry(KSM_SESSIONS_COUNT, 0);
for (int i=0; i<m_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(TQString::null, urlStr, true));
}
}
}
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(TQString::null, m_baseDir+sessionDir[i], true));
}
}
m_sessionsCount = static_cast<int>(m_sessions.count());
}
//------------------------------------
KateSessionManager::~KateSessionManager()
{
saveConfig();
if (m_config)
{
delete m_config;
}
if (!m_sessions.isEmpty())
{
m_sessions.clear();
}
}
//------------------------------------
void KateSessionManager::saveConfig()
{
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_sessionsCount);
for (int i=0; i<m_sessionsCount; ++i)
{
// Save the session first, to make sure a new session has an associated file
m_sessions[i]->save();
m_config->writeEntry(TQString("URL_%1").arg(i), m_sessions[i]->getSessionFilename());
}
m_config->sync();
}
//------------------------------------
//------------------------------------
//------------------------------------
//------------------------------------
// Michele - to be removed with OldKateSession
bool operator<( const OldKateSession::Ptr& a, const OldKateSession::Ptr& b )
{
return a->sessionName().lower() < b->sessionName().lower();

109
kate/app/katesession.h
Unescape View File

@ -27,9 +27,11 @@
#include <tdeaction.h>
#include <tqobject.h>
#include <tqptrlist.h>
#include <tqvaluelist.h>
#include <tqstringlist.h>
class OldKateSessionManager;
class OldKateSessionManager; // Michele - to be removed with OldKateSession
class KDirWatch;
class TDEListView;
@ -37,6 +39,111 @@ class KPushButton;
class TQCheckBox;
class KateSession
{
public:
/**
* create a new session and read the config from fileName if it exists
* @param sessionName session name
* @param fileName file where session config is saved to/restored from
* @param isFullName true -> filename is a full filename, used to load/save the session configuration
* false -> filename is a folder name. This is used for new unsaved sessions
* to inject the location where the configuration file should be saved
*/
KateSession(const TQString &sessionName, const TQString &fileName, bool isFullName);
/**
* Destructor
*/
~KateSession();
/**
* Returns the session name
*/
const TQString& getSessionName() const { return m_sessionName; }
/**
* Set the new session name
* @param sessionName the new session name
*/
void setSessionName(const TQString &sessionName);
/**
* Returns whether the session is read only or not
*/
bool isReadOnly() const { return m_readOnly; }
/**
* Set session read only status
* @param readOnly if true, the session config can not be saved to file
*/
void setReadOnly(bool readOnly);
/**
* Returns the session filename
*/
const TQString& getSessionFilename() const { return m_filename; }
/**
* Save session info
* @return true if the session config is saved, false otherwise
*/
void save();
private:
TQString m_sessionName;
TQString m_filename;
bool m_isFullName; // true -> m_filename is a full filename
// false -> m_filename is a folder name.
bool m_readOnly;
int m_docCount; // number of documents in the session
TQStringList m_documents; // document URLs
KSimpleConfig *m_config; // session config
};
//------------------------------------
class KateSessionManager
{
public:
/**
* get a pointer to the unique KateSessionManager instance.
* If the manager does not exist yet, create it.
*/
static KateSessionManager* self();
/**
* Destructor
*/
~KateSessionManager();
/**
* Save session manager info
*/
void saveConfig();
private:
KateSessionManager();
TQString m_baseDir; // folder where session files are stored
TQString m_configFile; // file where the session list config is stored
int m_sessionsCount; // number of sessions
TQPtrList<KateSession> m_sessions; // session list
KSimpleConfig *m_config; // session manager config
static KateSessionManager *ksm_instance; // the only KateSessionManager instance
};
//------------------------------------
//------------------------------------
//------------------------------------
class OldKateSession : public TDEShared
{
public:

Write Preview
Loading…
Cancel
Save