You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdebase/kate/app/katesessionpanel.cpp

658 lines
21 KiB

/* 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 "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_mainWin(mainWindow), m_viewManager(viewManager),
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(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."));
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, true);
int result = nameChooser->exec();
if (result == TQDialog::Accepted)
{
m_sessionManager->newSession(nameChooser->getSessionName(), nameChooser->getActivateFlag());
}
delete nameChooser;
}
//-------------------------------------------
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->getSessionFilename().isEmpty() && ks->getSessionName() == i18n(KS_UNNAMED))
{
// 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 before, the session will be saved with a new name.
// If the session was already saved once, it will be cloned into a new session.
bool cloneSession = true;
//FIXME replace ks->getSessionFilename().isEmpty() with a function that tests for m_fileExists
if (ks->getSessionFilename().isEmpty() && ks->getSessionName() == i18n(KS_UNNAMED))
{
// Session has never been saved before.
cloneSession = false;
}
// 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
m_sessionManager->cloneSession(sessId, nameChooser->getSessionName(), nameChooser->getActivateFlag());
}
}
delete nameChooser;
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)
{
m_sessionManager->deleteSession(sessionItem->getSessionId());
}
}
//-------------------------------------------
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)
{
m_sessionManager->activateSession(newSessionId);
}
}
//-------------------------------------------
void KateSessionPanel::slotSessionToggleReadOnly()
{
KateSessionPanelItem *sessionItem = dynamic_cast<KateSessionPanelItem*>(m_listview->selectedItem());
if (!sessionItem)
{
return;
}
m_sessionManager->setSessionReadOnlyStatus(sessionItem->getSessionId(),
(dynamic_cast<TDEToggleAction*>(
m_actionCollection->action("session_toggle_read_only")))->isChecked());
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
if (!item->parent())
{
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_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());
}
m_actionCollection->action("session_save_as")->setEnabled(true);
m_actionCollection->action("session_reload")->setEnabled(
sessionItem->getSessionId() == m_sessionManager->getActiveSessionId());
m_actionCollection->action("session_activate")->setEnabled(true);
m_actionCollection->action("session_move_up")->setEnabled(true);
m_actionCollection->action("session_move_down")->setEnabled(true);
}
}
//-------------------------------------------
void KateSessionPanel::slotSessionActivated(int newSessionId, int oldSessionId)
{
// Move the active session marker
TQListViewItem *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));
}
//END KateSessionPanel