Merge branch 'katesessions': add Kate session panel.

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;