diff options
Diffstat (limited to 'kate/app')
| -rw-r--r-- | kate/app/CMakeLists.txt | 4 | ||||
| -rw-r--r-- | kate/app/Makefile.am | 2 | ||||
| -rw-r--r-- | kate/app/kateapp.cpp | 152 | ||||
| -rw-r--r-- | kate/app/kateapp.h | 24 | ||||
| -rw-r--r-- | kate/app/kateappIface.cpp | 11 | ||||
| -rw-r--r-- | kate/app/kateexternaltools.cpp | 1 | ||||
| -rw-r--r-- | kate/app/katefileselector.cpp | 1 | ||||
| -rw-r--r-- | kate/app/katemain.h | 1 | ||||
| -rw-r--r-- | kate/app/katemainwindow.cpp | 127 | ||||
| -rw-r--r-- | kate/app/katemainwindow.h | 49 | ||||
| -rw-r--r-- | kate/app/katesavemodifieddialog.cpp | 1 | ||||
| -rw-r--r-- | kate/app/katesession.cpp | 1351 | ||||
| -rw-r--r-- | kate/app/katesession.h | 828 | ||||
| -rw-r--r-- | kate/app/katesessionpanel.cpp | 771 | ||||
| -rw-r--r-- | kate/app/katesessionpanel.h | 174 | ||||
| -rw-r--r-- | kate/app/kateviewmanager.cpp | 1 | ||||
| -rw-r--r-- | kate/app/kateviewspace.cpp | 11 |
17 files changed, 2378 insertions, 1131 deletions
diff --git a/kate/app/CMakeLists.txt b/kate/app/CMakeLists.txt index 7adea8ea3..77908ffcf 100644 --- a/kate/app/CMakeLists.txt +++ b/kate/app/CMakeLists.txt @@ -38,8 +38,8 @@ set( ${target}_SRCS kbookmarkhandler.cpp katedocmanageriface.skel kateappIface.cpp kateappIface.skel katedocmanageriface.cpp kateexternaltools.cpp katesavemodifieddialog.cpp kateviewspacecontainer.cpp - katemwmodonhddialog.cpp katesession.cpp katemdi.cpp - katetabwidget.cpp + katemwmodonhddialog.cpp katesession.cpp katesessionpanel.cpp + katemdi.cpp katetabwidget.cpp ) tde_add_library( ${target} SHARED AUTOMOC diff --git a/kate/app/Makefile.am b/kate/app/Makefile.am index de2258630..c50f68562 100644 --- a/kate/app/Makefile.am +++ b/kate/app/Makefile.am @@ -10,7 +10,7 @@ libkateinterfaces_la_SOURCES = kateapp.cpp kateconfigdialog.cpp kateconfigplugin katemailfilesdialog.cpp kbookmarkhandler.cpp \ katedocmanageriface.skel kateappIface.cpp kateappIface.skel katedocmanageriface.cpp \ kateexternaltools.cpp katesavemodifieddialog.cpp kateviewspacecontainer.cpp \ - katemwmodonhddialog.cpp katesession.cpp katemdi.cpp katetabwidget.cpp + katemwmodonhddialog.cpp katesession.cpp katesessionpanel.cpp katemdi.cpp katetabwidget.cpp libkateinterfaces_la_LIBADD = ../interfaces/libkateinterfacesprivate.la $(LIB_TDEUTILS) ../utils/libkateutils.la diff --git a/kate/app/kateapp.cpp b/kate/app/kateapp.cpp index 9cba61cc6..18251ee09 100644 --- a/kate/app/kateapp.cpp +++ b/kate/app/kateapp.cpp @@ -75,7 +75,7 @@ KateApp::KateApp (TDECmdLineArgs *args) m_pluginManager = new KatePluginManager (TQT_TQOBJECT(this)); // session manager up - m_sessionManager = new KateSessionManager (TQT_TQOBJECT(this)); + m_sessionManager = KateSessionManager::self(); // application dcop interface m_obj = new KateAppDCOPIface (this); @@ -83,6 +83,8 @@ KateApp::KateApp (TDECmdLineArgs *args) kdDebug()<<"Setting KATE_PID: '"<<getpid()<<"'"<<endl; ::setenv( "KATE_PID", TQString(TQString("%1").arg(getpid())).latin1(), 1 ); + connect(this, TQT_SIGNAL(aboutToQuit()), this, TQT_SLOT(slotAboutToQuit())); + // handle restore different if (isRestored()) { @@ -105,14 +107,10 @@ KateApp::KateApp (TDECmdLineArgs *args) KateApp::~KateApp () { - // cu dcop interface - delete m_obj; - - // cu plugin manager - delete m_pluginManager; - - // delete this now, or we crash - delete m_docManager; + delete m_obj; // cu dcop interface + delete m_pluginManager; // cu plugin manager + delete m_sessionManager; // delete session manager + delete m_docManager; // delete document manager. Do this now, or we crash } KateApp *KateApp::self () @@ -139,25 +137,22 @@ TQString KateApp::kateVersion (bool fullVersion) return fullVersion ? TQString ("2.5.%1").arg(KDE::versionMajor()) : TQString ("%1.%2").arg(2.5); } -void KateApp::restoreKate () +void KateApp::restoreKate() { // restore the nice files ;) we need it - Kate::Document::setOpenErrorDialogsActivated (false); - - // activate again correct session!!! - sessionConfig()->setGroup("General"); - TQString lastSession (sessionConfig()->readEntry ("Last Session", "default.katesession")); - sessionManager()->activateSession (new KateSession (sessionManager(), lastSession, ""), false, false, false); + Kate::Document::setOpenErrorDialogsActivated(false); - m_docManager->restoreDocumentList (sessionConfig()); + // restore last session + sessionManager()->restoreLastSession(); + m_docManager->restoreDocumentList(sessionConfig()); - Kate::Document::setOpenErrorDialogsActivated (true); + Kate::Document::setOpenErrorDialogsActivated(true); // restore all windows ;) for (int n=1; TDEMainWindow::canBeRestored(n); n++) newMainWindow(sessionConfig(), TQString ("%1").arg(n)); - // oh, no mainwindow, create one, should not happen, but make sure ;) + // no mainwindow, create one, should not happen, but make sure ;) if (mainWindows() == 0) newMainWindow (); @@ -165,21 +160,60 @@ void KateApp::restoreKate () // TDEStartupInfo::setNewStartupId( activeMainWindow(), startupId()); } -bool KateApp::startupKate () +bool KateApp::startupKate() { - // user specified session to open - if (m_args->isSet ("start")) + if (m_args->isSet("start")) { - sessionManager()->activateSession (sessionManager()->giveSession (TQString::fromLocal8Bit(m_args->getOption("start"))), false, false); + // the user has specified the session to open. If the session does not exist, + // a new session with the specified name will be created + TQCString sessName = m_args->getOption("start"); + int sessId = sessionManager()->getSessionIdFromName(sessName); + if (sessId != KateSessionManager::INVALID_SESSION) + { + sessionManager()->activateSession(sessId); + } + else + { + sessionManager()->newSession(sessName); + } } else { - // let the user choose session if possible - if (!sessionManager()->chooseSession ()) + // check Kate session startup options + int startupOption = sessionManager()->getStartupOption(); + if (startupOption == KateSessionManager::STARTUP_NEW) { - // we will exit kate now, notify the rest of the world we are done - TDEStartupInfo::appStarted (startupId()); - return false; + sessionManager()->newSession(); + } + else if (startupOption == KateSessionManager::STARTUP_LAST) + { + sessionManager()->restoreLastSession(); + } + else // startupOption == KateSessionManager::STARTUP_MANUAL + { + KateSessionChooser *chooser = new KateSessionChooser(NULL); + int result = chooser->exec(); + switch (result) + { + case KateSessionChooser::RESULT_OPEN_NEW: + sessionManager()->newSession(); + break; + + case KateSessionChooser::RESULT_OPEN_EXISTING: + if (!m_sessionManager->activateSession(chooser->getSelectedSessionId())) + { + // Open a new session in case of error + sessionManager()->newSession(); + } + break; + + default: // KateSessionChooser::RESULT_QUIT_KATE: + // Kate will exit now and notify it is done + TDEStartupInfo::appStarted(startupId()); + return false; + break; + } + delete chooser; } } @@ -267,13 +301,11 @@ bool KateApp::startupKate () return true; } -void KateApp::shutdownKate (KateMainWindow *win) +void KateApp::shutdownKate(KateMainWindow *win) { - if (!win->queryClose_internal()) + if (!win->queryClose_internal() || !query_session_close()) return; - sessionManager()->saveActiveSession(true, true); - // detach the dcopClient dcopClient()->detach(); @@ -284,6 +316,60 @@ void KateApp::shutdownKate (KateMainWindow *win) quit (); } +bool KateApp::query_session_close() +{ + bool saveSessions = false; + int switchOption = m_sessionManager->getSwitchOption(); + if (switchOption == KateSessionManager::SWITCH_SAVE) + { + saveSessions = true; + } + else if (switchOption == KateSessionManager::SWITCH_ASK) + { + KDialogBase *dlg = new KDialogBase(i18n("Save Sessions"), + KDialogBase::Yes | KDialogBase::No | KDialogBase::Cancel, + KDialogBase::Cancel, KDialogBase::Cancel, NULL, NULL, true, false, + KStdGuiItem::save(), KStdGuiItem::del(), KStdGuiItem::cancel()); + bool dontAgain = false; + int res = KMessageBox::createKMessageBox(dlg, TQMessageBox::Warning, + i18n("<p>Do you want to save the existing sessions?<p>!!NOTE!!" + "<p>All existing sessions will be removed " + "if you choose \"Delete\""), TQStringList(), + i18n("Do not ask again"), &dontAgain, KMessageBox::Notify); + if (res == KDialogBase::Cancel) + { + return false; + } + if (dontAgain) + { + if (res == KDialogBase::No) + { + m_sessionManager->setSwitchOption(KateSessionManager::SWITCH_DISCARD); + } + else + { + m_sessionManager->setSwitchOption(KateSessionManager::SWITCH_SAVE); + } + } + if (res == KDialogBase::Yes) + { + saveSessions = true; + } + } + + if (saveSessions) + { + m_sessionManager->saveActiveSession(); + } + m_sessionManager->saveConfig(saveSessions); + return true; +} + +void KateApp::reparse_config() +{ + emit optionsChanged(); +} + KatePluginManager *KateApp::pluginManager() { return m_pluginManager; @@ -294,7 +380,7 @@ KateDocManager *KateApp::documentManager () return m_docManager; } -KateSessionManager *KateApp::sessionManager () +KateSessionManager* KateApp::sessionManager() { return m_sessionManager; } diff --git a/kate/app/kateapp.h b/kate/app/kateapp.h index 05d09a7fe..f421df5a7 100644 --- a/kate/app/kateapp.h +++ b/kate/app/kateapp.h @@ -100,7 +100,7 @@ class KDE_EXPORT KateApp : public TDEApplication * shutdown kate application * @param win mainwindow which is used for dialogs */ - void shutdownKate (KateMainWindow *win); + void shutdownKate(KateMainWindow *win); /** * application should exit @@ -108,8 +108,26 @@ class KDE_EXPORT KateApp : public TDEApplication */ bool shouldExit () { return m_shouldExit; } + /** + * to be called when the application is about to quit + * @return should we exit? + */ + bool query_session_close(); + + /** + * called after the config dialog has been closed. The application + * can parse the new configuration and take appropriate actions if required + */ + void reparse_config(); + + signals: + /** + * Emitted when the configuration has or may have been changed + */ + void optionsChanged(); + /** - * other accessors for global unique instances + * other accessors for global unique instances */ public: /** @@ -128,7 +146,7 @@ class KDE_EXPORT KateApp : public TDEApplication * accessor to session manager * @return session manager instance */ - KateSessionManager *sessionManager (); + KateSessionManager *sessionManager(); /** * window management diff --git a/kate/app/kateappIface.cpp b/kate/app/kateappIface.cpp index 259e48b89..bc06f1b78 100644 --- a/kate/app/kateappIface.cpp +++ b/kate/app/kateappIface.cpp @@ -23,6 +23,8 @@ #include "katedocmanager.h" #include "katemainwindow.h" +// FIXME: review Kate's DCOP interface for session management when the new session code is ready + KateAppDCOPIface::KateAppDCOPIface (KateApp *app) : DCOPObject ("KateApplication") , m_app (app) { @@ -89,16 +91,15 @@ bool KateAppDCOPIface::openInput (TQString text) return m_app->openInput (text); } -bool KateAppDCOPIface::activateSession (TQString session) +bool KateAppDCOPIface::activateSession(TQString session) { - m_app->sessionManager()->activateSession (m_app->sessionManager()->giveSession (session)); - + m_app->sessionManager()->activateSession(m_app->sessionManager()->getSessionIdFromName(session)); return true; } -const TQString & KateAppDCOPIface::session() const +const TQString& KateAppDCOPIface::session() const { - return m_app->sessionManager()->activeSession()->sessionName(); + return m_app->sessionManager()->getActiveSessionName(); } // kate: space-indent on; indent-width 2; replace-tabs on; diff --git a/kate/app/kateexternaltools.cpp b/kate/app/kateexternaltools.cpp index f23ef3934..3bb21c934 100644 --- a/kate/app/kateexternaltools.cpp +++ b/kate/app/kateexternaltools.cpp @@ -172,7 +172,6 @@ void KateExternalToolsCommand::reload () { config.readListEntry( "mimetypes" ), config.readEntry( "acname", "" ), config.readEntry( "cmdname", "" ) ); - // FIXME test for a command name first! if ( t.hasexec && (!t.cmdname.isEmpty())) { m_list.append("exttool-"+t.cmdname); m_map.insert("exttool-"+t.cmdname,t.acname); diff --git a/kate/app/katefileselector.cpp b/kate/app/katefileselector.cpp index c4b107912..a57115774 100644 --- a/kate/app/katefileselector.cpp +++ b/kate/app/katefileselector.cpp @@ -413,7 +413,6 @@ void KateFileSelector::btnFilterClick() } } -//FIXME crash on shutdown void KateFileSelector::setActiveDocumentDir() { // kdDebug(13001)<<"KateFileSelector::setActiveDocumentDir()"<<endl; diff --git a/kate/app/katemain.h b/kate/app/katemain.h index 374b834cc..24663f58f 100644 --- a/kate/app/katemain.h +++ b/kate/app/katemain.h @@ -60,6 +60,7 @@ class KateConsole; class KateDocManager; class KateFileList; class KateFileSelector; +class KateSessionPanel; class KateMainWindow; class KatePluginIface; class KatePluginManager; diff --git a/kate/app/katemainwindow.cpp b/kate/app/katemainwindow.cpp index 0bcf08883..1a021beb9 100644 --- a/kate/app/katemainwindow.cpp +++ b/kate/app/katemainwindow.cpp @@ -31,6 +31,7 @@ #include "kateapp.h" #include "katefileselector.h" #include "katefilelist.h" +#include "katesessionpanel.h" #include "kategrepdialog.h" #include "katemailfilesdialog.h" #include "katemainwindowiface.h" @@ -217,6 +218,9 @@ void KateMainWindow::setupMainWindow () fileselector = new KateFileSelector( this, m_viewManager, t, "operator"); connect(fileselector->dirOperator(),TQT_SIGNAL(fileSelected(const KFileItem*)),this,TQT_SLOT(fileSelected(const KFileItem*))); + KateMDI::ToolView *st = createToolView("kate_sessionpanel", KMultiTabBar::Left, SmallIcon("view_choose"), i18n("Sessions")); + m_sessionpanel = new KateSessionPanel( this, m_viewManager, st, "sessionpanel"); + // ONLY ALLOW SHELL ACCESS IF ALLOWED ;) if (KateApp::self()->authorize("shell_access")) { @@ -302,14 +306,29 @@ void KateMainWindow::setupActions() slotWindowActivated (); // session actions - new TDEAction(i18n("Menu entry Session->New", "&New"), "document-new", 0, TQT_TQOBJECT(KateSessionManager::self()), TQT_SLOT(sessionNew()), actionCollection(), "sessions_new"); - new TDEAction(i18n("&Open..."), "document-open", 0, TQT_TQOBJECT(KateSessionManager::self()), TQT_SLOT(sessionOpen()), actionCollection(), "sessions_open"); - new TDEAction(i18n("&Save"), "document-save", 0, TQT_TQOBJECT(KateSessionManager::self()), TQT_SLOT(sessionSave()), actionCollection(), "sessions_save"); - new TDEAction(i18n("Save &As..."), "document-save-as", 0, TQT_TQOBJECT(KateSessionManager::self()), TQT_SLOT(sessionSaveAs()), actionCollection(), "sessions_save_as"); - new TDEAction(i18n("&Manage..."), "view_choose", 0, TQT_TQOBJECT(KateSessionManager::self()), TQT_SLOT(sessionManage()), actionCollection(), "sessions_manage"); - - // quick open menu ;) - new KateSessionsAction (i18n("&Quick Open"), actionCollection(), "sessions_list"); + new TDEAction(i18n("&New"), "list-add", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotNewSession()), actionCollection(), "session_new"); + new TDEAction(i18n("&Save"), "document-save", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotSaveSession()), actionCollection(), "session_save"); + new TDEAction(i18n("Save &As..."), "document-save-as", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotSaveSessionAs()), actionCollection(), "session_save_as"); + new TDEAction(i18n("&Rename"), "edit_user", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotRenameSession()), actionCollection(), "session_rename"); + new TDEAction(i18n("&Delete"), "edit-delete", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotDeleteSession()), actionCollection(), "session_delete"); + new TDEAction(i18n("Re&load"), "reload", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotReloadSession()), actionCollection(), "session_reload"); + new TDEAction(i18n("Acti&vate"), "forward", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotActivateSession()), actionCollection(), "session_activate"); + new TDEToggleAction(i18n("Toggle read &only"), "encrypted", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotSessionToggleReadOnly()), actionCollection(), "session_toggle_read_only"); + new TDEAction(i18n("Move &Up"), "go-up", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotSessionMoveUp()), actionCollection(), "session_move_up"); + new TDEAction(i18n("Move Do&wn"), "go-down", 0, + TQT_TQOBJECT(m_sessionpanel), TQT_SLOT(slotSessionMoveDown()), actionCollection(), "session_move_down"); + new KateSessionListActionMenu(this, i18n("Sele&ct session"), actionCollection(), "session_list"); + + connect(m_sessionpanel, TQT_SIGNAL(selectionChanged()), TQT_TQOBJECT(this), TQT_SLOT(slotSelectionChanged())); } KateTabWidget *KateMainWindow::tabWidget () @@ -323,9 +342,9 @@ void KateMainWindow::slotDocumentCloseAll() { } bool KateMainWindow::queryClose_internal() { - uint documentCount=KateDocManager::self()->documents(); + uint documentCount=KateDocManager::self()->documents(); - if ( ! showModOnDiskPrompt() ) + if ( !showModOnDiskPrompt() ) return false; TQPtrList<Kate::Document> modifiedDocuments=KateDocManager::self()->modifiedDocumentList(); @@ -354,23 +373,22 @@ bool KateMainWindow::queryClose() // just test, not close them actually if (KateApp::self()->sessionSaving()) { - return queryClose_internal (); + return queryClose_internal(); } // normal closing of window // allow to close all windows until the last without restrictions - if ( KateApp::self()->mainWindows () > 1 ) + if (KateApp::self()->mainWindows() > 1) + { return true; + } - // last one: check if we can close all documents, try run + // last one: check if we can close all documents and sessions, try run // and save docs if we really close down ! - if ( queryClose_internal () ) + if (queryClose_internal() && KateApp::self()->query_session_close()) { - KateApp::self()->sessionManager()->saveActiveSession(true, true); - // detach the dcopClient KateApp::self()->dcopClient()->detach(); - return true; } @@ -397,7 +415,7 @@ void KateMainWindow::slotNewToolbarConfig() void KateMainWindow::slotFileQuit() { - KateApp::self()->shutdownKate (this); + KateApp::self()->shutdownKate(this); } void KateMainWindow::readOptions () @@ -434,7 +452,7 @@ void KateMainWindow::saveOptions () config->writeEntry("Show Full Path in Title", m_viewManager->getShowFullPath()); config->writeEntry("Sync Konsole", syncKonsole); config->writeEntry("UseInstance", useInstance); - + fileOpenRecent->saveEntries(config, "Recent Files"); fileselector->writeConfig(config, "fileselector"); filelist->writeConfig(config, "Filelist"); @@ -482,7 +500,7 @@ void KateMainWindow::documentMenuAboutToShow() TQListViewItem * item = filelist->firstChild(); while( item ) { // would it be saner to use the screen width as a limit that some random number?? - TQString name = KStringHandler::rsqueeze( ((KateFileListItem *)item)->document()->docName(), 150 ); + TQString name = KStringHandler::rsqueeze( ((KateFileListItem *)item)->document()->docName(), 150 ); Kate::Document* doc = ((KateFileListItem *)item)->document(); documentMenu->insertItem ( doc->isModified() ? i18n("'document name [*]', [*] means modified", "%1 [*]").arg(name) : name, @@ -568,6 +586,9 @@ void KateMainWindow::slotConfigure() dlg->exec(); delete dlg; + + // Inform Kate that options may have been changed + KateApp::self()->reparse_config(); } KURL KateMainWindow::activeDocumentUrl() @@ -820,7 +841,7 @@ void KateMainWindow::updateCaption (Kate::Document *doc) c = m_viewManager->activeView()->getDoc()->url().prettyURL(); } - TQString sessName = KateApp::self()->sessionManager()->activeSession()->sessionName(); + TQString sessName = KateApp::self()->sessionManager()->getActiveSessionName(); if ( !sessName.isEmpty() ) sessName = TQString("%1: ").arg( sessName ); @@ -849,12 +870,68 @@ void KateMainWindow::readProperties(TDEConfig *config) config->setGroup(grp); } -void KateMainWindow::saveGlobalProperties( TDEConfig* sessionConfig ) +//------------------------------------------- +void KateMainWindow::slotSelectionChanged() { - KateDocManager::self()->saveDocumentList (sessionConfig); + TDEActionCollection *mwac = actionCollection(); // Main Window Action Collection + TDEActionPtrList actionList = m_sessionpanel->m_actionCollection->actions(); + TDEActionPtrList::ConstIterator spa_it; + for (spa_it = actionList.begin(); spa_it != actionList.end(); ++spa_it) + { + TDEAction *a = mwac->action((*spa_it)->name()); + TDEToggleAction *ta = dynamic_cast<TDEToggleAction*>(a); + if (ta) + { + ta->setChecked((dynamic_cast<TDEToggleAction*>(*spa_it))->isChecked()); + } + if (a) + { + a->setEnabled((*spa_it)->isEnabled()); + } + } +} - sessionConfig->setGroup("General"); - sessionConfig->writeEntry ("Last Session", KateApp::self()->sessionManager()->activeSession()->sessionFileRelative()); +//------------------------------------------- +void KateMainWindow::activateSession(int sessionId) +{ + if (sessionId < 0 || sessionId == KateApp::self()->sessionManager()->getActiveSessionId()) + { + return; + } + + // Select the required session in the session panel's listview + TQListViewItem *item = m_sessionpanel->m_listview->firstChild(); + int idx = 0; + while (item && idx < sessionId) + { + item = item->nextSibling(); + ++idx; + } + if (idx == sessionId && item) + { + // Required session item found, switch session with consistent behavior + m_sessionpanel->m_listview->setSelected(item, true); + m_sessionpanel->slotActivateSession(); + } +} + +//------------------------------------------- +KateSessionListActionMenu::KateSessionListActionMenu(KateMainWindow *mw, const TQString &text, TQObject *parent, const char *name) + : TDEActionMenu(text, parent, name), m_mainWindow(mw) +{ + connect(popupMenu(), TQT_SIGNAL(aboutToShow()), this, TQT_SLOT(slotAboutToShow())); +} + +//------------------------------------------- +void KateSessionListActionMenu::slotAboutToShow() +{ + popupMenu()->clear(); + + TQPtrList<KateSession> &sessions = KateApp::self()->sessionManager()->getSessionsList(); + for (int idx = 0; idx < (int)sessions.count(); ++idx) + { + popupMenu()->insertItem(sessions[idx]->getSessionName(), m_mainWindow, TQT_SLOT(activateSession(int)), 0, idx); + } } // kate: space-indent on; indent-width 2; replace-tabs on; diff --git a/kate/app/katemainwindow.h b/kate/app/katemainwindow.h index 157b4e57d..aa2a6cee7 100644 --- a/kate/app/katemainwindow.h +++ b/kate/app/katemainwindow.h @@ -68,7 +68,6 @@ class KateMainWindow : public KateMDI::MainWindow, virtual public KParts::PartBa /** * Accessor methodes for interface and child objects */ - public: Kate::MainWindow *mainWindow () { return m_mainWindow; } Kate::ToolViewManager *toolViewManager () { return m_toolViewManager; } @@ -79,7 +78,6 @@ class KateMainWindow : public KateMDI::MainWindow, virtual public KParts::PartBa /** * various methodes to get some little info out of this */ - public: /** Returns the URL of the current document. * anders: I add this for use from the file selector. */ KURL activeDocumentUrl(); @@ -101,14 +99,27 @@ class KateMainWindow : public KateMDI::MainWindow, virtual public KParts::PartBa */ KateTabWidget *tabWidget (); - public: void readProperties(TDEConfig *config); void saveProperties(TDEConfig *config); - void saveGlobalProperties( TDEConfig* sessionConfig ); - public: bool queryClose_internal(); + void openURL (const TQString &name=0L); + + public slots: + /** + * update "Sessions" menu status when selection in session panel has changed + */ + void slotSelectionChanged(); + + /** + * activate the specified session. When there is the need to activate a session + * from the outside (for example from DCOP), using this method assures that + * the session activation is consistent with the behavior of the session panel + * @param sessionId the id of the session to activate + */ + void activateSession(int sessionId); + private: void setupMainWindow(); void setupActions(); @@ -127,11 +138,11 @@ class KateMainWindow : public KateMDI::MainWindow, virtual public KParts::PartBa void dragEnterEvent( TQDragEnterEvent * ); void dropEvent( TQDropEvent * ); + private slots: /** * slots used for actions in the menus/toolbars * or internal signal connections */ - private slots: void newWindow (); void slotConfigure(); @@ -163,18 +174,12 @@ class KateMainWindow : public KateMDI::MainWindow, virtual public KParts::PartBa void pluginHelp(); void slotFullScreen(bool); - public: - void openURL (const TQString &name=0L); - - private slots: void updateGrepDir (bool visible); - + void slotDocumentCloseAll(); + protected: bool event( TQEvent * ); - private slots: - void slotDocumentCloseAll(); - private: static uint uniqueID; uint myID; @@ -198,6 +203,7 @@ class KateMainWindow : public KateMDI::MainWindow, virtual public KParts::PartBa KateFileList *filelist; KateFileSelector *fileselector; + KateSessionPanel *m_sessionpanel; TDEActionMenu* documentOpenWith; @@ -213,6 +219,21 @@ class KateMainWindow : public KateMDI::MainWindow, virtual public KParts::PartBa KateTabWidget *m_tabWidget; }; +class KateSessionListActionMenu : public TDEActionMenu +{ + Q_OBJECT + + public: + KateSessionListActionMenu(KateMainWindow *mw, const TQString &text, TQObject *parent = NULL, const char *name = NULL); + ~KateSessionListActionMenu() {} + + public slots: + void slotAboutToShow(); + + protected: + KateMainWindow *m_mainWindow; +}; + #endif // kate: space-indent on; indent-width 2; replace-tabs on; diff --git a/kate/app/katesavemodifieddialog.cpp b/kate/app/katesavemodifieddialog.cpp index a89fe57f8..9ff79dfb4 100644 --- a/kate/app/katesavemodifieddialog.cpp +++ b/kate/app/katesavemodifieddialog.cpp @@ -156,7 +156,6 @@ KateSaveModifiedDialog::KateSaveModifiedDialog(TQWidget *parent, TQPtrList<Kate: } m_documentRoot->setOpen(true); } else m_documentRoot=0; - //FIXME - Is this the best way? connect(m_list, TQT_SIGNAL(clicked(TQListViewItem *)), TQT_SLOT(slotItemSelected())); connect(m_list, TQT_SIGNAL(doubleClicked(TQListViewItem *)), TQT_SLOT(slotItemSelected())); connect(m_list, TQT_SIGNAL(spacePressed(TQListViewItem *)), TQT_SLOT(slotItemSelected())); 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; diff --git a/kate/app/katesession.h b/kate/app/katesession.h index b62e72a48..665ac867b 100644 --- a/kate/app/katesession.h +++ b/kate/app/katesession.h @@ -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 @@ -27,392 +29,508 @@ #include <tdeaction.h> #include <tqobject.h> +#include <tqptrlist.h> #include <tqvaluelist.h> +#include <tqstringlist.h> +#include <tdelistview.h> -class KateSessionManager; - +class KateViewSpace; class KDirWatch; -class TDEListView; class KPushButton; - +class TDEListView; class TQCheckBox; +class KateSessionManager; -class KateSession : public TDEShared -{ - public: - /** - * Define a Shared-Pointer type - */ - typedef TDESharedPtr<KateSession> Ptr; - - public: - /** - * create a session from given file - * @param fileName session filename, relative - * @param name session name - * @param manager pointer to the manager - */ - KateSession (KateSessionManager *manager, const TQString &fileName, const TQString &name); - - /** - * init the session object, after construction or create - */ - void init (); - - /** - * destruct me - */ - ~KateSession (); - - /** - * session filename, absolute, calculated out of relative filename + session dir - * @return absolute path to session file - */ - TQString sessionFile () const; - - /** - * relative session filename - * @return relative filename for this session - */ - const TQString &sessionFileRelative () const { return m_sessionFileRel; } - - /** - * session name - * @return name for this session - */ - const TQString &sessionName () const { return m_sessionName; } - - /** - * is this a valid session? if not, don't use any session if this is - * the active one - */ - bool isNew () const { return m_sessionName.isEmpty(); } - - /** - * create the session file, if not existing - * @param name name for this session - * @param force force to create new file - * @return true if created, false if no creation needed - */ - bool create (const TQString &name, bool force = false); - - /** - * rename this session - * @param name new name - * @return success - */ - bool rename (const TQString &name); - - /** - * config to read - * on first access, will create the config object, delete will be done automagic - * return 0 if we have no file to read config from atm - * @return config to read from - */ - TDEConfig *configRead (); - - /** - * config to write - * on first access, will create the config object, delete will be done automagic - * return 0 if we have no file to write config to atm - * @return config to write from - */ - TDEConfig *configWrite (); - - /** - * count of documents in this session - * @return documents count - */ - unsigned int documents () const { return m_documents; } - - private: - /** - * session filename, in local location we can write to - * relative filename to the session dirs :) - */ - TQString m_sessionFileRel; - - /** - * session name, extracted from the file, to display to the user - */ - TQString m_sessionName; - - /** - * number of document of this session - */ - unsigned int m_documents; - - /** - * KateSessionMananger - */ - KateSessionManager *m_manager; - - /** - * simpleconfig to read from - */ - KSimpleConfig *m_readConfig; - - /** - * simpleconfig to write to - */ - KSimpleConfig *m_writeConfig; -}; - -typedef TQValueList<KateSession::Ptr> KateSessionList; -class KateSessionManager : public TQObject +//BEGIN KateSession +/** + * An object representing a Kate's session. + */ +class KateSession { - Q_OBJECT + public: + + /** + * create a new session and read the config from fileName if it exists + * @param manager the session manager handling this session + * @param sessionName session name + * @param fileName file where session config is saved to/restored from + */ + KateSession(const KateSessionManager &manager, const TQString &sessionName, const TQString &fileName); + + /** + * duplicate an existing session into a new one with the given new name. + * If the existing session is read-only, the new one will *not* be read-only by default + * @param session the existing session + * @param newSessionName the name of the new session + */ + KateSession(const KateSession &session, const TQString &newSessionName); + + /** + * Destructor + */ + ~KateSession(); + + /** + * @return 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); + + /** + * @return 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 status can not be modified + */ + void setReadOnly(bool readOnly) { m_readOnly = readOnly; } + + /** + * @return the session filename if available, otherwise the null string + */ + const TQString& getSessionFilename() const { return m_filename; } + + /** + * @return whether the session is still volatile, i.e. it has never + * been saved and never been named + */ + bool isStillVolatile() const; + + /** + * @return the number of documents in the session + */ + int getDocCount() const { return m_documents.count(); } + + /** + * Load session info from the saved file + * @param includeGUIInfo if true, also load the information about the GUI elements + */ + void load(bool includeGUIInfo); + + /** + * Save session info + * @param saveGUIInfo if true, save also the information about the GUI elements + * @param setReadOnly necessary to save a session that has to be turned to read only + */ + void save(bool saveGUIInfo, bool setReadOnly = false); + + /** + * Activate the session + */ + void activate(); + + + private: + + friend class KateViewSpace; + + /** + * @return the session config object + */ + TDEConfig* getConfig() const { return m_config; } + + /** + * create a new filename for a session object + */ + void createFilename(); + + const KateSessionManager &m_manager; // The session manager that handles this session + TQString m_sessionName; + TQString m_filename; + bool m_readOnly; + TQStringList m_documents; // document URLs + KSimpleConfig *m_config; // session config - public: - KateSessionManager(TQObject *parent); - ~KateSessionManager(); - - /** - * allow access to this :) - * @return instance of the session manager - */ - static KateSessionManager *self(); - - /** - * allow access to the session list - * kept up to date by watching the dir - */ - inline KateSessionList & sessionList () { updateSessionList (); return m_sessionList; } - - /** - * activate a session - * first, it will look if a session with this name exists in list - * if yes, it will use this session, else it will create a new session file - * @param session session to activate - * @param closeLast try to close last session or not? - * @param saveLast try to save last session or not? - * @param loadNew load new session stuff? - */ - void activateSession (KateSession::Ptr session, bool closeLast = true, bool saveLast = true, bool loadNew = true); - - /** - * create a new session - * @param name session name - */ - KateSession::Ptr createSession (const TQString &name); - - /** - * return session with given name - * if no existing session matches, create new one with this name - * @param name session name - */ - KateSession::Ptr giveSession (const TQString &name); - - /** - * save current session - * for sessions without filename: save nothing - * @param tryAsk should we ask user if needed? - * @param rememberAsLast remember this session as last used? - * @return success - */ - bool saveActiveSession (bool tryAsk = false, bool rememberAsLast = false); - - /** - * return the current active session - * sessionFile == empty means we have no session around for this instance of kate - * @return session active atm - */ - inline KateSession::Ptr activeSession () { return m_activeSession; } - - /** - * session dir - * @return global session dir - */ - inline const TQString &sessionsDir () const { return m_sessionsDir; } - - /** - * initial session chooser, on app start - * @return success, if false, app should exit - */ - bool chooseSession (); - - public slots: - /** - * try to start a new session - * asks user first for name - */ - void sessionNew (); - - /** - * try to open a existing session - */ - void sessionOpen (); - - /** - * try to save current session - */ - void sessionSave (); - - /** - * try to save as current session - */ - void sessionSaveAs (); - - /** - * show dialog to manage our sessions - */ - void sessionManage (); - - private slots: - void dirty (const TQString &path); - - public: - /** - * trigger update of session list - */ - void updateSessionList (); - - private: - /** - * absolute path to dir in home dir where to store the sessions - */ - TQString m_sessionsDir; - - /** - * list of current available sessions - */ - KateSessionList m_sessionList; - - /** - * current active session - */ - KateSession::Ptr m_activeSession; }; - -class KateSessionChooser : public KDialogBase +//END KateSession + + +//BEGIN KateSessionManager +//FIXME (advanced - multiple main windows or multiple Kate instances) +//There should be only one session manager regardless of how many main windows of Kate are open. +//Changes should propagate to all session panels. Different Kate main windows should run different +//sessions. If the user switches to a session already opened in another Kate window, the other window +//should be brought up to the screen (eventually ask user confirmation first). +//This would allow a safe use of multiple Kate main windows/instances without overwriting session information +//among them. Currently the last instance/main window to be closed will overwrite the information previously +//saved by other Kate instances. +/** + * The Kate session manager. It takes care of storing and retrieving each session object + * as well as providing methods to operate on them. + * + * @note The Kate session manager takes ownership of each session object it handles. + */ +//FIXME update the sessions.list file when switching to another session or to a new session +// +//FIXME create new unnamed session, choose 'save' as session switch option. Exit Kate. +// Session is saved without asking for a name +//FIXME improve getStartupOption/getSwitchOption/setSwitchOption using new signal +// KateApp::optionsChanged() +//FIXME add kdDebug statement to ease debugging +class KateSessionManager : public TQObject { Q_OBJECT - public: - KateSessionChooser (TQWidget *parent, const TQString &lastSession); - ~KateSessionChooser (); - - KateSession::Ptr selectedSession (); + public: - bool reopenLastSession (); - - enum { - resultQuit = TQDialog::Rejected, - resultOpen, - resultNew, - resultNone + enum + { + INVALID_SESSION = -1 }; - protected slots: - /** - * open session - */ - void slotUser1 (); - - /** - * new session - */ - void slotUser2 (); - - /** - * quit kate - */ - void slotUser3 (); - - /** - * selection has changed - */ - void selectionChanged (); - - private: - TDEListView *m_sessions; - TQCheckBox *m_useLast; -}; - -class KateSessionOpenDialog : public KDialogBase -{ - Q_OBJECT - - public: - KateSessionOpenDialog (TQWidget *parent); - ~KateSessionOpenDialog (); - - KateSession::Ptr selectedSession (); - - enum { - resultOk, - resultCancel + // Session options on Kate startup + enum + { + STARTUP_NEW = 0, // New session + STARTUP_LAST, // Use last session + STARTUP_MANUAL // Manually choose a session }; - - protected slots: - /** - * cancel pressed - */ - void slotUser1 (); - - /** - * ok pressed - */ - void slotUser2 (); - - private: - TDEListView *m_sessions; + + // Session options on session switch or Kate shutdown + enum + { + SWITCH_DISCARD = 0, // Don't save current session + SWITCH_SAVE, // Save current session + SWITCH_ASK // Ask user what to do + }; + + /** + * 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 + * @param saveSessions true = sessions info will be saved + * false = all sessions will be discarded + */ + void saveConfig(bool saveSessions); + + /** + * @return the session startup option + * The function checks the config file to see if there was any value update + */ + const int getStartupOption(); + + /** + * @return the session switch option + * The function checks the config file to see if there was any value update + */ + const int getSwitchOption(); + + /** + * Set the new session switch preference + * @param option the new option value. Defaults to SWITCH_ASK if the value is invalid. + * @emit switchOptionChanged + */ + void setSwitchOption(int option); + + /** + * @return the session files folder name + */ + const TQString& getBaseDir() const { return m_baseDir; } + + /** + * @return the number of existing sessions + */ + int getSessionCount() const { return m_sessions.count(); } + + /** + * @return the active session id + */ + int getActiveSessionId() const { return m_activeSessionId; } + + /** + * @return the active session name + */ + const TQString& getActiveSessionName() /*FIXME const*/ { return m_sessions[m_activeSessionId]->getSessionName(); } + + /** + * @param sessionId the id of the session of interest + * @return the name of the specified session + */ + const TQString& getSessionName(int sessionId) /*FIXME const*/; + + /** + * @return a reference to the active session + */ + KateSession* getActiveSession() { return m_sessions[m_activeSessionId]; } + + /** + * @param sessionId the id of the session to return + * @return a reference to the specified session + */ + KateSession* getSessionFromId(int sessionId); + + /** + * Return the session id of the first session whose name matches the + * provided one. In case multiple sessions share the same name, + * the id of the first one found will be returned. + * @param name the session name to look for + * @return the session id of the matching session if it is found, + * otherwise KateSessionManager::INVALID_SESSION. + */ + int getSessionIdFromName(const TQString &name); + + /** + * @return a reference to the sessions list + */ + TQPtrList<KateSession>& getSessionsList() { return m_sessions; } + + /** + * Activate the selected session. + * @param sessionId the id of the session to activate + * @param saveCurr if true, save the current session before activating the new one + * @return whether the session was activated or not + * @emit sessionActivated + */ + bool activateSession(int sessionId, bool saveCurr = true); + + /** + * Create a new session and activate it + * @param sessionName new session name + * @param saveCurr if true, save the current session before activating the new one + * @return the id of the newly created session + * @emit sessionCreated + * @emit sessionDeleted (only when leaving an unstored and unnamed session) + */ + int newSession(const TQString &sessionName = TQString::null, bool saveCurr = true); + + /** + * Create a new session and activate it if required + * @param sessionId the id of the session to clone + * @param sessionName the new session name + * @param activate if true, activate the new session after creation + * @param deleteCurr if true, delete the current session after switching + * @return the id of the newly created session + * @emit sessionCreated + */ + int cloneSession(int sessionId, const TQString &sessionName = TQString::null, + bool activate = true, bool deleteCurr = false); + + /** + * Restore the current active session to the last saved state + */ + void reloadActiveSession() { m_sessions[m_activeSessionId]->load(true); } + + /** + * Restore the last saved session. Can only be used before + * any other session has been activated, i.e. on Kate's startup + * @return whether the session was activated or not + */ + bool restoreLastSession(); + + /** + * Saves the active session + * @emit sessionSaved (through invoked "void saveSession(int)" method) + */ + void saveActiveSession() { saveSession(m_activeSessionId); } + + /** + * Save the specified session + * @param sessionId the id of the session to save + * @emit sessionSaved + */ + void saveSession(int sessionId) { saveSession(sessionId, sessionId == m_activeSessionId); } + + /** + * Delete the specified session + * @param sessionId the id of the session to delete + * @param actSessId the id of the next session to activate. + * If INVALID_SESSION or invalid, create a new empty session. + * This is only meaningful when deleting the current active session. + * @return whether the session has been deleted or not + * @emit sessionDeleted + */ + bool deleteSession(int sessionId, int actSessId); + + /** + * Move the specified session forward in the session list (by one position) + * @param sessionId the id of the session to move + */ + void moveSessionForward(int sessionId); + + /** + * Move the specified session backward in the session list (by one position) + * @param sessionId the id of the session to move + */ + void moveSessionBackward(int sessionId); + + /** + * Rename the specified session + * @param sessionId the id of the session to rename + * @param newSessionName the new session name + * @emit sessionRenamed + */ + void renameSession(int sessionId, const TQString &newSessionName); + + /** + * Set the read only status of the specified session + * @param sessionId the id of the session to modify + * @param readOnly the new read only status + */ + void setSessionReadOnlyStatus(int sessionId, bool readOnly); + + signals: + /** + * Emitted when the session switch option has been set/changed + */ + void switchOptionChanged(); + + /** + * Emitted once a session has been activated + * @param newSessionId the id of the previous active session + * @param oldSessionId the id of the new active session + */ + void sessionActivated(int newSessionId, int oldSessionId); + + /** + * Emitted once a session has been created + * @param sessionId the id of the new session + */ + void sessionCreated(int sessionId); + + /** + * Emitted once a session has been saved + * @param sessionId the id of the saved session + */ + void sessionSaved(int sessionId); + + /** + * Emitted once a session has been deleted + * @param sessionId the id of the deleted session + */ + void sessionDeleted(int sessionId); + + /** + * Emitted once the position of the two sessions have been swapped + * @param sessionIdMin the smallest id of the session couple + * @param sessionIdMax the biggest id of the session couple + */ + void sessionsSwapped(int sessionIdMin, int sessionIdMax); + + /** + * Emitted once a session has been renamed + * @param sessionId the id of the new session + */ + void sessionRenamed(int sessionId); + + + protected: + KateSessionManager(); + + // Session options on Kate startup + enum + { + SO_STARTUP = 0, // session startup option only + SO_SWITCH, // session switch option only + SO_ALL, // session startup and switch options + }; + + /** + * Updated the session startup and switch options + * @param optionType specifies which options needs to be updated + */ + void updateSessionOptions(int optionType); + + /** + * Save the session startup and switch options to the config file + * @param optionType specifies which options needs to be saved + */ + void saveSessionOptions(int optionType); + + /** + * Swap the position of the two specified sessions in the session list + * @param sessionId1 the id of the first session + * @param sessionId2 the id of the second session + * @emit sessionsSwapped + */ + void swapSessionsPosition(int sessionId1, int sessionId2); + + /** + * Save the specified session + * @param sessionId the id of the session to save + * @param saveGUIInfo if true, save also the information about the GUI elements + * @param setReadOnly necessary to save a session that has to be turned to read only + * @emit sessionSaved + */ + void saveSession(int sessionId, bool saveGUIInfo, bool setReadOnly = false); + + + TQString m_baseDir; // folder where session files are stored + TQString m_configFile; // file where the session list config is stored + int m_activeSessionId; // id of the active session + int m_lastSessionId; // id of the last active session before closing Kate + TQPtrList<KateSession> m_sessions; // session list + KSimpleConfig *m_config; // session manager config + int m_startupOption; // session option on Kate startup + int m_switchOption; // session option on session switch or Kate shutdown + + static KateSessionManager *ksm_instance; // the only KateSessionManager instance }; +//END KateSessionManager -class KateSessionManageDialog : public KDialogBase -{ - Q_OBJECT +//BEGIN KateSessionChooserItem +class KateSessionChooserItem : public TDEListViewItem +{ public: - KateSessionManageDialog (TQWidget *parent); - ~KateSessionManageDialog (); + KateSessionChooserItem(TQListView *listview, const TQString &sessionName, const TQString &nDoc, int sessionId) + : TDEListViewItem(listview, sessionName, nDoc), m_sessionId(sessionId) {} - protected slots: - /** - * close pressed - */ - void slotUser1 (); + int getSessionId() { return m_sessionId; } + void setSessionId(int sessionId) { m_sessionId = sessionId; } - /** - * selection has changed - */ - void selectionChanged (); + protected: + int m_sessionId; +}; +//END KateSessionChooserItem - /** - * try to rename session - */ - void rename (); - /** - * try to delete session - */ - void del (); +//BEGIN KateSessionChooser +//FIXME create one single KateSessionChooser and reuse it all the time +class KateSessionChooser : public KDialogBase +{ + Q_OBJECT - private: - /** - * update our list - */ - void updateSessionList (); + public: + enum Result + { + RESULT_NO_OP = TQDialog::Rejected, + RESULT_OPEN_EXISTING, + RESULT_OPEN_NEW, + RESULT_QUIT_KATE + }; - private: - TDEListView *m_sessions; - KPushButton *m_rename; - KPushButton *m_del; -}; + KateSessionChooser(TQWidget *parent); + ~KateSessionChooser() {} -class KateSessionsAction : public TDEActionMenu -{ - Q_OBJECT + int getSelectedSessionId(); // return the session id of the selected session - public: - KateSessionsAction(const TQString& text, TQObject* parent = 0, const char* name = 0); - ~KateSessionsAction (){;}; + protected slots: - public slots: - void slotAboutToShow(); + void slotUser1(); // open existing session + void slotUser2(); // open new session + void slotUser3(); // quit kate + void slotSelectionChanged(); // list selection has changed - void openSession (int i); + protected: + TDEListView *m_listview; }; +//END KateSessionChooser #endif diff --git a/kate/app/katesessionpanel.cpp b/kate/app/katesessionpanel.cpp new file mode 100644 index 000000000..0cf7e235b --- /dev/null +++ b/kate/app/katesessionpanel.cpp @@ -0,0 +1,771 @@ +/* This file is part of the TDE project + Copyright (C) 2015-2016 Michele Calgaro <micheleDOTcalgaro__AT__yahooDOTit> + + 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 "katesessionpanel.h" +#include "katesessionpanel.moc" + +#include "kateapp.h" +#include "katemainwindow.h" +#include "kateviewmanager.h" +#include "katesession.h" + +#include <kiconloader.h> +#include <tdelocale.h> +#include <tdemessagebox.h> +#include <tqlistview.h> +#include <tqlabel.h> + + +namespace +{ + const char *KS_UNNAMED = "Unnamed"; +}; + + +//BEGIN KateSessionNameChooser +//------------------------------------------- +KateSessionNameChooser::KateSessionNameChooser(TQWidget *parent, bool showSwitchTo) + : KDialogBase(parent, "", true, i18n("Session Name Chooser"), KDialogBase::User1 | KDialogBase::User2, + KDialogBase::User2, true, KStdGuiItem::cancel(), KGuiItem(i18n("Continue"), "document-new")), + m_showSwitchTo(showSwitchTo) +{ + TQHBox *page = new TQHBox(this); + //page->setMinimumSize(300, 100); + setMainWidget(page); + + TQVBox *vb = new TQVBox(page); + vb->setSpacing(KDialog::spacingHint()); + + TQLabel *label = new TQLabel(vb); + label->setText("Please type the new session name:"); + + m_sessionNameLE = new TQLineEdit(vb); + m_sessionNameLE->setText(i18n(KS_UNNAMED)); + m_sessionNameLE->setFocus(); + + if (m_showSwitchTo) + { + m_activateCB = new TQCheckBox(i18n("Switch to the new session"), vb, NULL); + m_activateCB->setChecked(true); + } + + connect(m_sessionNameLE, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotTextChanged())); + slotTextChanged(); // update button status +} + +//------------------------------------------- +TQString KateSessionNameChooser::getSessionName() +{ + return m_sessionNameLE->text(); +} + +//------------------------------------------- +bool KateSessionNameChooser::getActivateFlag() +{ + if (m_showSwitchTo) + { + return m_activateCB->isChecked(); + } + return false; +} + +//------------------------------------------- +void KateSessionNameChooser::slotUser1() +{ + reject(); +} + +//------------------------------------------- +void KateSessionNameChooser::slotUser2() +{ + accept(); +} + +//------------------------------------------- +void KateSessionNameChooser::slotTextChanged() +{ + enableButton(KDialogBase::User2, !m_sessionNameLE->text().isEmpty()); +} +//END KateSessionNameChooser + + +//BEGIN KateSessionPanelToolBarParent +void KateSessionPanelToolBarParent::setToolBar(TDEToolBar *tbar) +{ + m_tbar = tbar; +} + +//------------------------------------------- +void KateSessionPanelToolBarParent::resizeEvent (TQResizeEvent*) +{ + if (m_tbar) + { + setMinimumHeight(m_tbar->sizeHint().height()); + m_tbar->resize(width(),height()); + } +} +//END KateSessionPanelToolBarParent + + +//BEGIN KateSessionPanel +//------------------------------------------- +KateSessionPanel::KateSessionPanel(KateMainWindow *mainWindow, KateViewManager *viewManager, + TQWidget *parent, const char *name) + : TQVBox(parent, name), m_sessionManager(KateSessionManager::self()), + m_actionCollection(new TDEActionCollection(this)), m_columnName(-1), m_columnPixmap(-1) +{ + // Toolbar + setup_toolbar(); + + // Listview + m_listview = new TDEListView(this); + m_listview->header()->hide(); + m_columnName = m_listview->addColumn("Session name"); + m_columnPixmap = m_listview->addColumn("Pixmap", 24); + m_listview->addColumn("Dummy", 1); // Dummy column, only for nice resizing + m_listview->header()->setResizeEnabled(false, m_columnPixmap); + m_listview->setColumnAlignment(m_columnPixmap, TQt::AlignCenter); + m_listview->setMinimumWidth(m_listview->sizeHint().width()); + m_listview->setSorting(-1); + m_listview->setResizeMode(TQListView::LastColumn); + //m_listview->setRootIsDecorated(true); // FIXME disabled until doc list software is developed + + + connect(m_listview, TQT_SIGNAL(selectionChanged()), + this, TQT_SLOT(slotSelectionChanged())); + connect(m_listview, TQT_SIGNAL(executed(TQListViewItem*)), + this, TQT_SLOT(slotItemExecuted(TQListViewItem*))); + connect(m_listview, TQT_SIGNAL(returnPressed(TQListViewItem*)), + this, TQT_SLOT(slotItemExecuted(TQListViewItem*))); + connect(KateApp::self(), TQT_SIGNAL(optionsChanged()), + this, TQT_SLOT(slotSelectionChanged())); + connect(m_sessionManager, TQT_SIGNAL(switchOptionChanged()), + this, TQT_SLOT(slotSelectionChanged())); + connect(m_sessionManager, TQT_SIGNAL(sessionActivated(int, int)), + this, TQT_SLOT(slotSessionActivated(int, int))); + connect(m_sessionManager, TQT_SIGNAL(sessionCreated(int)), + this, TQT_SLOT(slotSessionCreated(int))); + connect(m_sessionManager, TQT_SIGNAL(sessionDeleted(int)), + this, TQT_SLOT(slotSessionDeleted(int))); + connect(m_sessionManager, TQT_SIGNAL(sessionsSwapped(int, int)), + this, TQT_SLOT(slotSessionsSwapped(int, int))); + connect(m_sessionManager, TQT_SIGNAL(sessionRenamed(int)), + this, TQT_SLOT(slotSessionRenamed(int))); + connect(m_listview, TQT_SIGNAL(itemRenamed(TQListViewItem*)), + this, TQT_SLOT(slotLVSessionRenamed(TQListViewItem*))); + + TQPtrList<KateSession>& sessions = m_sessionManager->getSessionsList(); + for (int idx = sessions.count() - 1; idx >= 0; --idx) + { + new KateSessionPanelItem(m_listview, sessions[idx]->getSessionName(), idx); + if (idx == m_sessionManager->getActiveSessionId()) + { + m_listview->setSelected(m_listview->firstChild(), true); + m_listview->firstChild()->setPixmap(m_columnPixmap, SmallIcon("ok")); + } + } + +} + +//------------------------------------------- +void KateSessionPanel::setup_toolbar() +{ + // Toolbar widget and frame + KateSessionPanelToolBarParent *tbarParent = new KateSessionPanelToolBarParent(this); + m_toolbar = new TDEToolBar(tbarParent, "Kate Session Panel Toolbar", true); + tbarParent->setToolBar(m_toolbar); + m_toolbar->setMovingEnabled(false); + m_toolbar->setFlat(true); + m_toolbar->setIconText(TDEToolBar::IconOnly); + m_toolbar->setIconSize(16); + m_toolbar->setEnableContextMenu(false); + + // Toolbar actions + TDEAction *a; + + a = new TDEAction(i18n("New"), SmallIcon("list-add"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotNewSession()), m_actionCollection, "session_new"); + a->setWhatsThis(i18n("Create a new session and switch to it.")); + a->plug(m_toolbar); + + a = new TDEAction(i18n("Save"), SmallIcon("document-save"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotSaveSession()), m_actionCollection, "session_save"); + a->setWhatsThis(i18n("Save the selected session.")); + a->plug(m_toolbar); + + a = new TDEAction(i18n("Save as..."), SmallIcon("document-save-as"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotSaveSessionAs()), m_actionCollection, "session_save_as"); + a->setWhatsThis(i18n("Save an unsaved session with a new name or clone an already saved session " + "into a new session.")); + a->plug(m_toolbar); + + a = new TDEAction(i18n("Rename"), SmallIcon("edit_user"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotRenameSession()), m_actionCollection, "session_rename"); + a->setWhatsThis(i18n("Rename the selected session.")); + a->plug(m_toolbar); + + a = new TDEAction(i18n("Delete"), SmallIcon("edit-delete"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotDeleteSession()), m_actionCollection, "session_delete"); + a->setWhatsThis(i18n("Delete the selected session.")); + a->plug(m_toolbar); + + a = new TDEAction(i18n("Reload"), SmallIcon("reload"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotReloadSession()), m_actionCollection, "session_reload"); + a->setWhatsThis(i18n("Reload the last saved state of the selected session.")); + a->plug(m_toolbar); + + m_toolbar->insertLineSeparator(); + + a = new TDEAction(i18n("Activate"), SmallIcon("forward"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotActivateSession()), m_actionCollection, "session_activate"); + a->setWhatsThis(i18n("Activate the selected session.")); + a->plug(m_toolbar); + + TDEToggleAction *tglA = new TDEToggleAction(i18n("Toggle read only"), SmallIcon("encrypted"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotSessionToggleReadOnly()), m_actionCollection, "session_toggle_read_only"); + tglA->setWhatsThis(i18n("Toggle read only status for the selected session.<p>" + "In a read only session, you can work as usual but the list of documents in the session " + "will not be saved when you exit Kate or switch to another session.<p>" + "You can use this option to create template sessions that you wish to keep unchanged over time.")); + tglA->plug(m_toolbar); + + a = new TDEAction(i18n("Move Up"), SmallIcon("go-up"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotSessionMoveUp()), m_actionCollection, "session_move_up"); + a->setWhatsThis(i18n("Move up the selected session.")); + a->plug(m_toolbar); + + a = new TDEAction(i18n("Move Down"), SmallIcon("go-down"), 0, + TQT_TQOBJECT(this), TQT_SLOT(slotSessionMoveDown()), m_actionCollection, "session_move_down"); + a->setWhatsThis(i18n("Move down the selected session.")); + a->plug(m_toolbar); +} + +//------------------------------------------- +void KateSessionPanel::slotNewSession() +{ + KateSessionNameChooser *nameChooser = new KateSessionNameChooser(this, false); + int result = nameChooser->exec(); + if (result == TQDialog::Accepted) + { + int res = handleSessionSwitch(); + if (res == KMessageBox::Cancel) + { + return; + } + else + { + m_sessionManager->newSession(nameChooser->getSessionName(), res == KMessageBox::Yes); + } + } +} + +//------------------------------------------- +void KateSessionPanel::slotSaveSession() +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + if (!sessionItem) + { + return; + } + + int sessId = sessionItem->getSessionId(); + const KateSession *ks = m_sessionManager->getSessionFromId(sessId); + if (!ks) + { + return; + } + + if (ks->isStillVolatile()) + { + // Session has never been saved before. Ask user for a session name first + slotSaveSessionAs(); + } + else + { + m_sessionManager->saveSession(sessId); + slotSelectionChanged(); // Update the toolbar button status + } +} + +//------------------------------------------- +void KateSessionPanel::slotSaveSessionAs() +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + if (!sessionItem) + { + return; + } + int sessId = sessionItem->getSessionId(); + KateSession *ks = m_sessionManager->getSessionFromId(sessId); + if (!ks) + { + return; + } + + // If the session was never saved or named before, the session will be saved with a new name. + // Otherwise it will be cloned into a new session. + bool cloneSession = !ks->isStillVolatile(); + // Get new session name + KateSessionNameChooser *nameChooser = new KateSessionNameChooser(this, cloneSession); + int result = nameChooser->exec(); + if (result == TQDialog::Accepted) + { + if (!cloneSession) + { + // Save unsaved session + m_sessionManager->renameSession(sessId, nameChooser->getSessionName()); + m_sessionManager->saveSession(sessId); + } + else + { + // Clone session + bool activate = nameChooser->getActivateFlag(); + int activeSessionId = m_sessionManager->getActiveSessionId(); + int res = KMessageBox::Yes; + if (activate && sessId != activeSessionId) + { + // Cloning another session and switching to it at the same time, + // handle session switch correctly + res = handleSessionSwitch(); + if (res == KMessageBox::Cancel) + { + return; + } + } + m_sessionManager->cloneSession(sessId, nameChooser->getSessionName(), activate, res == KMessageBox::No); + } + } + + slotSelectionChanged(); // Update the toolbar button status +} + +//------------------------------------------- +void KateSessionPanel::slotRenameSession() +{ + TQListViewItem *sessionItem = m_listview->selectedItem(); + if (!sessionItem) + { + return; + } + + m_listview->rename(m_listview->selectedItem(), m_columnName); +} + +//------------------------------------------- +void KateSessionPanel::slotDeleteSession() +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + if (!sessionItem) + { + return; + } + + int result = KMessageBox::warningContinueCancel(this, + i18n("Do you really want to delete the session \"%1\"?").arg(sessionItem->text(0)), + i18n("Delete session"), KStdGuiItem::del()); + if (result == KMessageBox::Continue) + { + int sessionId = sessionItem->getSessionId(); + if (sessionId == m_sessionManager->getActiveSessionId()) + { + // First check if all documents can be closed safely + if (KateApp::self()->activeMainWindow()) + { + if (!KateApp::self()->activeMainWindow()->queryClose_internal()) + return; + } + } + //FIXME add options to let user decide what to do when deleting the current session + //(open previous/next session, create new empty session) + m_sessionManager->deleteSession(sessionId, KateSessionManager::INVALID_SESSION); + } +} + +//------------------------------------------- +void KateSessionPanel::slotReloadSession() +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + if (!sessionItem) + { + return; + } + int sessId = sessionItem->getSessionId(); + if (sessId != m_sessionManager->getActiveSessionId()) + { + return; + } + + // Restore active session to the last saved state + m_sessionManager->reloadActiveSession(); +} + +//------------------------------------------- +void KateSessionPanel::slotActivateSession() +{ + KateSessionPanelItem *newSessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + if (!newSessionItem) + { + return; + } + + int currSessionId = m_sessionManager->getActiveSessionId(); + int newSessionId = newSessionItem->getSessionId(); + if (newSessionId != currSessionId) + { + int res = handleSessionSwitch(); + if (res == KMessageBox::Cancel) + { + return; + } + else + { + m_sessionManager->activateSession(newSessionId, res == KMessageBox::Yes); + } + } +} + +//------------------------------------------- +void KateSessionPanel::slotSessionToggleReadOnly() +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + const KateSession *ks(NULL); + if (sessionItem) + { + ks = m_sessionManager->getSessionFromId(sessionItem->getSessionId()); + } + if (!sessionItem || !ks) + { + return; + } + + m_sessionManager->setSessionReadOnlyStatus(sessionItem->getSessionId(), !ks->isReadOnly()); + slotSelectionChanged(); // Update the toolbar button status +} + +//------------------------------------------- +void KateSessionPanel::slotSessionMoveUp() +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + if (!sessionItem) + { + return; + } + + m_sessionManager->moveSessionBackward(sessionItem->getSessionId()); +} + +//------------------------------------------- +void KateSessionPanel::slotSessionMoveDown() +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + if (!sessionItem) + { + return; + } + + m_sessionManager->moveSessionForward(sessionItem->getSessionId()); +} + +//------------------------------------------- +void KateSessionPanel::slotItemExecuted(TQListViewItem *item) +{ + if (!item) + { + return; + } + + // First level items are sessions. Executing one, will switch to that session. + // This is only allow when the 'Activate' toolbar button is enabled + if (!item->parent() && + m_actionCollection->action("session_activate")->isEnabled()) + { + slotActivateSession(); + return; + } +} + +//------------------------------------------- +void KateSessionPanel::slotSelectionChanged() +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem()); + const KateSession *ks(NULL); + if (sessionItem) + { + ks = m_sessionManager->getSessionFromId(sessionItem->getSessionId()); + } + + TDEToggleAction *readOnlyAction = dynamic_cast<TDEToggleAction*>( + m_actionCollection->action("session_toggle_read_only")); + if (!sessionItem || !ks || + m_sessionManager->getSwitchOption() == KateSessionManager::SWITCH_DISCARD) + { + m_actionCollection->action("session_save")->setEnabled(false); + m_actionCollection->action("session_save_as")->setEnabled(false); + m_actionCollection->action("session_rename")->setEnabled(false); + m_actionCollection->action("session_delete")->setEnabled(false); + m_actionCollection->action("session_reload")->setEnabled(false); + m_actionCollection->action("session_activate")->setEnabled(false); + m_actionCollection->action("session_move_up")->setEnabled(false); + m_actionCollection->action("session_move_down")->setEnabled(false); + readOnlyAction->setEnabled(false); + readOnlyAction->setChecked(false); + } + else + { + if (ks->isReadOnly()) + { + // Read only sessions can not be saved or renamed + m_actionCollection->action("session_save")->setEnabled(false); + m_actionCollection->action("session_rename")->setEnabled(false); + m_actionCollection->action("session_delete")->setEnabled(false); + } + else + { + m_actionCollection->action("session_save")->setEnabled(true); + m_actionCollection->action("session_rename")->setEnabled(true); + m_actionCollection->action("session_delete")->setEnabled(true); + } + if (ks->getSessionFilename().isEmpty()) + { + // Unstored sessions can not be made readonly + readOnlyAction->setEnabled(false); + readOnlyAction->setChecked(false); + } + else + { + readOnlyAction->setEnabled(true); + readOnlyAction->setChecked(ks->isReadOnly()); + } + int sessId = sessionItem->getSessionId(); + int activeSessId = m_sessionManager->getActiveSessionId(); + m_actionCollection->action("session_save_as")->setEnabled(true); + m_actionCollection->action("session_reload")->setEnabled(sessId == activeSessId); + m_actionCollection->action("session_activate")->setEnabled(sessId != activeSessId); + m_actionCollection->action("session_move_up")->setEnabled(sessId > 0); + m_actionCollection->action("session_move_down")->setEnabled(sessId < (m_sessionManager->getSessionCount() - 1)); + } + + emit selectionChanged(); +} + +//------------------------------------------- +void KateSessionPanel::slotSessionActivated(int newSessionId, int oldSessionId) +{ + // Move the active session marker + TQListViewItem *item = NULL; + if (oldSessionId != KateSessionManager::INVALID_SESSION) + { + // Old volatile sessions may have already been deleted. + // Remove the marker only for valid sessions. + item = m_listview->firstChild(); + for (int idx = 0; idx < oldSessionId; ++idx) + { + item = item->nextSibling(); + } + item->setPixmap(m_columnPixmap, TQPixmap()); + } + + item = m_listview->firstChild(); + for (int idx = 0; idx < newSessionId; ++idx) + { + item = item->nextSibling(); + } + item->setPixmap(m_columnPixmap, SmallIcon("ok")); + m_listview->setSelected(item, true); + slotSelectionChanged(); // Update the toolbar button status +} + +//------------------------------------------- +void KateSessionPanel::slotSessionCreated(int sessionId) +{ + TQPtrList<KateSession>& sessions = m_sessionManager->getSessionsList(); + new KateSessionPanelItem(m_listview, m_listview->lastItem(), sessions[sessionId]->getSessionName(), + sessionId); +} + +//------------------------------------------- +void KateSessionPanel::slotSessionDeleted(int sessionId) +{ + // delete item from listview + TQListViewItem *item = m_listview->firstChild(); + int idx = 0; + for (; idx < sessionId; ++idx) + { + item = item->nextSibling(); + } + TQListViewItem *nextItem = item->nextSibling(); + delete item; + // update session id of all following items + item = nextItem; + while (item) + { + dynamic_cast<KateSessionPanelItem*>(item)->setSessionId(idx++); + item = item->nextSibling(); + } +} + +//------------------------------------------- +void KateSessionPanel::slotSessionsSwapped(int sessionIdMin, int sessionIdMax) +{ + if (sessionIdMin == sessionIdMax) + { + return; + } + + if (sessionIdMin > sessionIdMax) + { + // this is not executed when the slot is connected to m_sessionManager's + // sessionsSwapped(int, int) signal + int tmp = sessionIdMin; + sessionIdMin = sessionIdMax; + sessionIdMax = tmp; + } + + TQListViewItem *selectedItem = m_listview->selectedItem(); + + // Looks for the previous siblings of the two items + TQListViewItem *siblMin(NULL), *siblMax(NULL), *itemMin(NULL), *itemMax(NULL); + TQListViewItem *currItem = m_listview->firstChild(); + TQListViewItem *nextItem(NULL); + while (currItem) + { + nextItem = currItem->nextSibling(); + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(nextItem); + if (sessionItem->getSessionId() == sessionIdMin) + { + siblMin = currItem; + itemMin = nextItem; + } + else if (sessionItem->getSessionId() == sessionIdMax) + { + siblMax = currItem; + itemMax = nextItem; + break; + } + currItem = nextItem; + } + if (!itemMin) + { + // The sessionIdMin item was the first of the list + itemMin = m_listview->firstChild(); + } + // Remove the two items and place them in their new positions + m_listview->takeItem(itemMax); + m_listview->takeItem(itemMin); + m_listview->insertItem(itemMin); + m_listview->insertItem(itemMax); + itemMax->moveItem(siblMin); + if (siblMax != itemMin) + { + itemMin->moveItem(siblMax); + } + else + { + itemMin->moveItem(itemMax); + } + // Update item's session id + (dynamic_cast<KateSessionPanelItem*>(itemMax))->setSessionId(sessionIdMin); + (dynamic_cast<KateSessionPanelItem*>(itemMin))->setSessionId(sessionIdMax); + + m_listview->setSelected(selectedItem, true); +} + +//------------------------------------------- +void KateSessionPanel::slotSessionRenamed(int sessionId) +{ + TQListViewItem *item = m_listview->firstChild(); + for (int idx = 0; idx < sessionId; ++idx) + { + item = item->nextSibling(); + } + item->setText(m_columnName, m_sessionManager->getSessionName(sessionId)); +} + +//------------------------------------------- +void KateSessionPanel::slotLVSessionRenamed(TQListViewItem *item) +{ + KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(item); + if (!sessionItem) + { + return; + } + + m_sessionManager->renameSession(sessionItem->getSessionId(), sessionItem->text(m_columnName)); +} + +//------------------------------------------- +int KateSessionPanel::handleSessionSwitch() +{ + const KateSession *ks = m_sessionManager->getActiveSession(); + int switchOption = m_sessionManager->getSwitchOption(); + if (!ks || switchOption == KateSessionManager::SWITCH_DISCARD) + { + return KMessageBox::No; + } + + if (switchOption == KateSessionManager::SWITCH_ASK) + { + KDialogBase *dlg = new KDialogBase(i18n("Save Session"), + KDialogBase::Yes | KDialogBase::No | KDialogBase::Cancel, + KDialogBase::Cancel, KDialogBase::Cancel, NULL, NULL, true, false, + KStdGuiItem::save(), KStdGuiItem::del(), KStdGuiItem::cancel()); + bool dontAgain = false; + int res = KMessageBox::createKMessageBox(dlg, TQMessageBox::Warning, + i18n("<p>Do you want to save the current session?<p>!!NOTE!!" + "<p>The session will be removed if you choose \"Delete\""), TQStringList(), + i18n("Do not ask again"), &dontAgain, KMessageBox::Notify); + if (res == KDialogBase::Cancel) + { + return KMessageBox::Cancel; + } + if (dontAgain) + { + if (res == KDialogBase::No) + { + m_sessionManager->setSwitchOption(KateSessionManager::SWITCH_DISCARD); + } + else + { + m_sessionManager->setSwitchOption(KateSessionManager::SWITCH_SAVE); + } + } + if (res == KDialogBase::No) + { + return KMessageBox::No; + } + } + + // At this point the session needs to be saved. + // Make sure to handle volatile sessions correctly. + if (ks->isStillVolatile()) + { + KateSessionNameChooser *nameChooser = new KateSessionNameChooser(this, false); + int res = nameChooser->exec(); + if (res == TQDialog::Accepted) + { + m_sessionManager->renameSession(m_sessionManager->getActiveSessionId(), nameChooser->getSessionName()); + } + else + { + return KMessageBox::Cancel; + } + } + + return KMessageBox::Yes; +} +//END KateSessionPanel diff --git a/kate/app/katesessionpanel.h b/kate/app/katesessionpanel.h new file mode 100644 index 000000000..acaec56cd --- /dev/null +++ b/kate/app/katesessionpanel.h @@ -0,0 +1,174 @@ +/* This file is part of the TDE project + Copyright (C) 2015-2016 Michele Calgaro <micheleDOTcalgaro__AT__yahooDOTit> + + 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. +*/ + +#ifndef __KATE_SESSIONPANEL_H__ +#define __KATE_SESSIONPANEL_H__ + +/* + The kate session panel displays the available sessions (and their documents) + in a treeview list and allows for quick switching among them. + A toolbar on the top also provides quick access to actions needed + to manage sessions. +*/ + +#include <tqvbox.h> +#include <tdetoolbar.h> +#include <tdelistview.h> +#include <tqframe.h> +#include <tqlineedit.h> +#include <tqcheckbox.h> +#include <kdialogbase.h> + +class KateMainWindow; +class KateViewManager; +class KateSessionManager; +class TDEActionCollection; + + +//BEGIN KateSessionNameChooser +//FIXME create one single KateSessionNameChooser and reuse it all the time +//FIXME improve string to distinguish between new session and saving an unnamed session +class KateSessionNameChooser : public KDialogBase +{ + Q_OBJECT + + public: + + KateSessionNameChooser(TQWidget *parent, bool showSwitchTo); + ~KateSessionNameChooser() {} + + TQString getSessionName(); // return the session name typed by the user + bool getActivateFlag(); // return whether to switch to the new session or not + + protected slots: + + void slotUser1(); // create new session + void slotUser2(); // cancel + void slotTextChanged(); // session name has changed + + protected: + TQLineEdit *m_sessionNameLE; + TQCheckBox *m_activateCB; + bool m_showSwitchTo; // if true, display the m_activateCB checkbox +}; +//BEGIN KateSessionNameChooser + + +//BEGIN KateSessionPanelToolBarParent +class KateSessionPanelToolBarParent: public TQFrame +{ + Q_OBJECT + + public: + KateSessionPanelToolBarParent(TQWidget *parent) : TQFrame(parent), m_tbar(0) {} + ~KateSessionPanelToolBarParent() {} + void setToolBar(TDEToolBar *tbar); + + protected: + virtual void resizeEvent (TQResizeEvent*); + + private: + TDEToolBar *m_tbar; +}; +//END KateSessionPanelToolBarParent + + +//BEGIN KateSessionPanelItem +class KateSessionPanelItem : public TDEListViewItem +{ + public: + KateSessionPanelItem(TQListView *listview, const TQString &sessionName, int sessionId) + : TDEListViewItem(listview, sessionName), m_sessionId(sessionId) {} + KateSessionPanelItem(TQListView *listview, TQListViewItem *after, const TQString &sessionName, int sessionId) + : TDEListViewItem(listview, after, sessionName), m_sessionId(sessionId) {} + + int getSessionId() { return m_sessionId; } + void setSessionId(int sessionId) { m_sessionId = sessionId; } + + protected: + int m_sessionId; +}; +//END KateSessionPanelItem + + +//BEGIN KateSessionPanel +class KateSessionPanel : public TQVBox +{ + Q_OBJECT + + friend class KateMainWindow; + + public: + + KateSessionPanel(KateMainWindow *mainWindow=0, KateViewManager *viewManager=0, + TQWidget *parent=0, const char *name=0); + ~KateSessionPanel() {} + + signals: + /** + * Emitted when the session selection in the panel has changed + */ + void selectionChanged(); + + + public slots: + void slotNewSession(); + void slotSaveSession(); + void slotSaveSessionAs(); + void slotRenameSession(); + void slotDeleteSession(); + void slotReloadSession(); + void slotActivateSession(); + void slotSessionToggleReadOnly(); + void slotSessionMoveUp(); + void slotSessionMoveDown(); + void slotItemExecuted(TQListViewItem *item); + + void slotSelectionChanged(); /** @emit selectionChanged */ + void slotSessionActivated(int newSessionId, int oldSessionId); + void slotSessionCreated(int sessionId); + void slotSessionDeleted(int sessionId); + void slotSessionsSwapped(int sessionIdMin, int sessionIdMax); + void slotSessionRenamed(int sessionId); + void slotLVSessionRenamed(TQListViewItem *item); + + protected: + void setup_toolbar(); + + /* Checks the session switch option. If the choice is 'ask user', + opens a dialog and asks the user what to do. + Returns one of the following: + - KMessageBox::Cancel : the user wants to abort the current operation + - KMessageBox::No : the user wants to discard the session and continue + - KMessageBox::Yes : the user wants to save the session and continue + If the current session is volatile and the session needs to be saved, + it will also ask the user to provide a session name. + */ + int handleSessionSwitch(); + + KateSessionManager *m_sessionManager; + TDEActionCollection *m_actionCollection; + TDEToolBar *m_toolbar; + TDEListView *m_listview; + int m_columnName; + int m_columnPixmap; +}; +//END KateSessionPanel + + +#endif //__KATE_SESSIONPANEL_H__ diff --git a/kate/app/kateviewmanager.cpp b/kate/app/kateviewmanager.cpp index ca361232a..47ece5270 100644 --- a/kate/app/kateviewmanager.cpp +++ b/kate/app/kateviewmanager.cpp @@ -462,7 +462,6 @@ void KateViewManager::setShowFullPath( bool enable ) /** * session config functions */ -// FIXME 3.0 - make those config goups more streamlined: "objN:objN..." void KateViewManager::saveViewConfiguration(TDEConfig *config,const TQString& grp) { // Use the same group name for view configuration as usual for sessions. diff --git a/kate/app/kateviewspace.cpp b/kate/app/kateviewspace.cpp index ebc7a3b97..a4066ee5a 100644 --- a/kate/app/kateviewspace.cpp +++ b/kate/app/kateviewspace.cpp @@ -110,15 +110,16 @@ void KateViewSpace::addView(Kate::View* v, bool show) if ( !m_group.isEmpty() ) { TQString fn = v->getDoc()->url().prettyURL(); - if ( ! fn.isEmpty() ) + if (!fn.isEmpty()) { TQString vgroup = TQString("%1 %2").arg(m_group).arg(fn); - KateSession::Ptr as = KateSessionManager::self()->activeSession (); - if ( as->configRead() && as->configRead()->hasGroup( vgroup ) ) + const KateSession *as = KateSessionManager::self()->getActiveSession(); + TDEConfig *asCfg = as->getConfig(); + if (asCfg && asCfg->hasGroup(vgroup)) { - as->configRead()->setGroup( vgroup ); - v->readSessionConfig ( as->configRead() ); + asCfg->setGroup(vgroup); + v->readSessionConfig(asCfg); } } } |