00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "katesession.h"
00020 #include "katesession.moc"
00021
00022 #include "kateapp.h"
00023 #include "katemainwindow.h"
00024 #include "katedocmanager.h"
00025
00026 #include <kstandarddirs.h>
00027 #include <klocale.h>
00028 #include <kdebug.h>
00029 #include <kdirwatch.h>
00030 #include <klistview.h>
00031 #include <kinputdialog.h>
00032 #include <kiconloader.h>
00033 #include <kmessagebox.h>
00034 #include <kmdcodec.h>
00035 #include <kstdguiitem.h>
00036 #include <kpushbutton.h>
00037 #include <kpopupmenu.h>
00038
00039 #include <qdir.h>
00040 #include <qlabel.h>
00041 #include <qlayout.h>
00042 #include <qvbox.h>
00043 #include <qhbox.h>
00044 #include <qcheckbox.h>
00045 #include <qdatetime.h>
00046 #include <qmap.h>
00047
00048 #include <unistd.h>
00049 #include <time.h>
00050
00051 bool operator<( const KateSession::Ptr& a, const KateSession::Ptr& b )
00052 {
00053 return a->sessionName().lower() < b->sessionName().lower();
00054 }
00055
00056 KateSession::KateSession (KateSessionManager *manager, const QString &fileName, const QString &name)
00057 : m_sessionFileRel (fileName)
00058 , m_sessionName (name)
00059 , m_documents (0)
00060 , m_manager (manager)
00061 , m_readConfig (0)
00062 , m_writeConfig (0)
00063 {
00064 init ();
00065 }
00066
00067 void KateSession::init ()
00068 {
00069
00070 if (!m_sessionFileRel.isEmpty() && KGlobal::dirs()->exists(sessionFile ()))
00071 {
00072 KSimpleConfig config (sessionFile (), true);
00073
00074 if (m_sessionName.isEmpty())
00075 {
00076
00077 if (m_sessionFileRel == "default.katesession")
00078 m_sessionName = i18n("Default Session");
00079 else
00080 {
00081 config.setGroup ("General");
00082 m_sessionName = config.readEntry ("Name", i18n ("Unnamed Session"));
00083 }
00084 }
00085
00086
00087 config.setGroup ("Open Documents");
00088 m_documents = config.readUnsignedNumEntry("Count", 0);
00089
00090 return;
00091 }
00092
00093
00094
00095 if (!m_sessionFileRel.isEmpty())
00096 {
00097 kdDebug(13001)<<"Kate::Session: initializing unexisting file!"<<endl;
00098
00099 if (m_sessionName.isEmpty())
00100 {
00101 if (m_sessionFileRel == "default.katesession")
00102 m_sessionName = i18n("Default Session");
00103 else
00104 m_sessionName = i18n("Session (%1)").arg(QTime::currentTime().toString(Qt::LocalDate));
00105 }
00106
00107
00108 KSimpleConfig config (sessionFile ());
00109 config.setGroup ("General");
00110 config.writeEntry ("Name", m_sessionName);
00111
00112 config.sync ();
00113 }
00114 }
00115
00116 KateSession::~KateSession ()
00117 {
00118 delete m_readConfig;
00119 delete m_writeConfig;
00120 }
00121
00122 QString KateSession::sessionFile () const
00123 {
00124 return m_manager->sessionsDir() + "/" + m_sessionFileRel;
00125 }
00126
00127 bool KateSession::create (const QString &name, bool force)
00128 {
00129 if (!force && (name.isEmpty() || !m_sessionFileRel.isEmpty()))
00130 return false;
00131
00132 delete m_writeConfig;
00133 m_writeConfig = 0;
00134
00135 delete m_readConfig;
00136 m_readConfig = 0;
00137
00138 m_sessionName = name;
00139
00140
00141 int s = time(0);
00142 QCString tname;
00143 while (true)
00144 {
00145 tname.setNum (s++);
00146 KMD5 md5 (tname);
00147 m_sessionFileRel = QString ("%1.katesession").arg (md5.hexDigest().data());
00148
00149 if (!KGlobal::dirs()->exists(sessionFile ()))
00150 break;
00151 }
00152
00153
00154 KSimpleConfig config (sessionFile ());
00155 config.setGroup ("General");
00156 config.writeEntry ("Name", m_sessionName);
00157 config.sync ();
00158
00159
00160 init ();
00161
00162 return true;
00163 }
00164
00165 bool KateSession::rename (const QString &name)
00166 {
00167 if (name.isEmpty () || m_sessionFileRel.isEmpty() || m_sessionFileRel == "default.katesession")
00168 return false;
00169
00170 m_sessionName = name;
00171
00172 KConfig config (sessionFile (), false, false);
00173 config.setGroup ("General");
00174 config.writeEntry ("Name", m_sessionName);
00175 config.sync ();
00176
00177 return true;
00178 }
00179
00180 KConfig *KateSession::configRead ()
00181 {
00182 if (m_sessionFileRel.isEmpty())
00183 return 0;
00184
00185 if (m_readConfig)
00186 return m_readConfig;
00187
00188 return m_readConfig = new KSimpleConfig (sessionFile (), true);
00189 }
00190
00191 KConfig *KateSession::configWrite ()
00192 {
00193 if (m_sessionFileRel.isEmpty())
00194 return 0;
00195
00196 if (m_writeConfig)
00197 return m_writeConfig;
00198
00199 m_writeConfig = new KSimpleConfig (sessionFile ());
00200 m_writeConfig->setGroup ("General");
00201 m_writeConfig->writeEntry ("Name", m_sessionName);
00202
00203 return m_writeConfig;
00204 }
00205
00206 KateSessionManager::KateSessionManager (QObject *parent)
00207 : QObject (parent)
00208 , m_sessionsDir (locateLocal( "data", "kate/sessions"))
00209 , m_activeSession (new KateSession (this, "", ""))
00210 {
00211 kdDebug() << "LOCAL SESSION DIR: " << m_sessionsDir << endl;
00212
00213
00214 KGlobal::dirs()->makeDir (m_sessionsDir);
00215 }
00216
00217 KateSessionManager::~KateSessionManager()
00218 {
00219 }
00220
00221 KateSessionManager *KateSessionManager::self()
00222 {
00223 return KateApp::self()->sessionManager ();
00224 }
00225
00226 void KateSessionManager::dirty (const QString &)
00227 {
00228 updateSessionList ();
00229 }
00230
00231 void KateSessionManager::updateSessionList ()
00232 {
00233 m_sessionList.clear ();
00234
00235
00236 QDir dir (m_sessionsDir, "*.katesession");
00237
00238 bool foundDefault = false;
00239 for (unsigned int i=0; i < dir.count(); ++i)
00240 {
00241 KateSession *session = new KateSession (this, dir[i], "");
00242 m_sessionList.append (session);
00243
00244 kdDebug () << "FOUND SESSION: " << session->sessionName() << " FILE: " << session->sessionFile() << endl;
00245
00246 if (!foundDefault && (dir[i] == "default.katesession"))
00247 foundDefault = true;
00248 }
00249
00250
00251 if (!foundDefault)
00252 m_sessionList.append (new KateSession (this, "default.katesession", i18n("Default Session")));
00253
00254 qHeapSort(m_sessionList);
00255 }
00256
00257 void KateSessionManager::activateSession (KateSession::Ptr session, bool closeLast, bool saveLast, bool loadNew)
00258 {
00259
00260
00261 if ( ! session->sessionName().isEmpty() && session->sessionName() == m_activeSession->sessionName() )
00262 return;
00263
00264 if (closeLast)
00265 {
00266 if (KateApp::self()->activeMainWindow())
00267 {
00268 if (!KateApp::self()->activeMainWindow()->queryClose_internal())
00269 return;
00270 }
00271 }
00272
00273
00274 if (saveLast)
00275 saveActiveSession (true);
00276
00277
00278 if (closeLast)
00279 {
00280 KateDocManager::self()->closeAllDocuments ();
00281 }
00282
00283
00284 m_activeSession = session;
00285
00286 if (loadNew)
00287 {
00288
00289 Kate::Document::setOpenErrorDialogsActivated (false);
00290
00291 KConfig *sc = activeSession()->configRead();
00292
00293 if (sc)
00294 KateApp::self()->documentManager()->restoreDocumentList (sc);
00295
00296
00297
00298 if ( ! sc )
00299 sc = new KSimpleConfig( sessionsDir() + "/default.katesession" );
00300
00301
00302 if (sc)
00303 {
00304 KConfig *c = KateApp::self()->config();
00305 c->setGroup("General");
00306
00307 if (c->readBoolEntry("Restore Window Configuration", true))
00308 {
00309
00310 if ( ! sc->hasGroup("Open MainWindows") )
00311 sc = new KSimpleConfig( sessionsDir() + "/default.katesession" );
00312
00313 sc->setGroup ("Open MainWindows");
00314 unsigned int wCount = sc->readUnsignedNumEntry("Count", 1);
00315
00316 for (unsigned int i=0; i < wCount; ++i)
00317 {
00318 if (i >= KateApp::self()->mainWindows())
00319 {
00320 KateApp::self()->newMainWindow(sc, QString ("MainWindow%1").arg(i));
00321 }
00322 else
00323 {
00324 sc->setGroup(QString ("MainWindow%1").arg(i));
00325 KateApp::self()->mainWindow(i)->readProperties (sc);
00326 }
00327 }
00328
00329 if (wCount > 0)
00330 {
00331 while (wCount < KateApp::self()->mainWindows())
00332 {
00333 KateMainWindow *w = KateApp::self()->mainWindow(KateApp::self()->mainWindows()-1);
00334 KateApp::self()->removeMainWindow (w);
00335 delete w;
00336 }
00337 }
00338 }
00339 }
00340
00341 Kate::Document::setOpenErrorDialogsActivated (true);
00342 }
00343 }
00344
00345 KateSession::Ptr KateSessionManager::createSession (const QString &name)
00346 {
00347 KateSession::Ptr s = new KateSession (this, "", "");
00348 s->create (name);
00349
00350 return s;
00351 }
00352
00353 KateSession::Ptr KateSessionManager::giveSession (const QString &name)
00354 {
00355 if (name.isEmpty())
00356 return new KateSession (this, "", "");
00357
00358 updateSessionList();
00359
00360 for (unsigned int i=0; i < m_sessionList.count(); ++i)
00361 {
00362 if (m_sessionList[i]->sessionName() == name)
00363 return m_sessionList[i];
00364 }
00365
00366 return createSession (name);
00367 }
00368
00369 bool KateSessionManager::saveActiveSession (bool tryAsk, bool rememberAsLast)
00370 {
00371 if (tryAsk)
00372 {
00373
00374 KConfig *c = KateApp::self()->config();
00375 c->setGroup("General");
00376
00377 QString sesExit (c->readEntry ("Session Exit", "save"));
00378
00379 if (sesExit == "discard")
00380 return true;
00381
00382 if (sesExit == "ask")
00383 {
00384 KDialogBase *dlg = new KDialogBase (
00385 i18n ("Save Session?")
00386 , KDialogBase::Yes | KDialogBase::No
00387 , KDialogBase::Yes, KDialogBase::No
00388 );
00389
00390 bool dontAgain = false;
00391 int res = KMessageBox::createKMessageBox(dlg, QMessageBox::Question,
00392 i18n("Save current session?"), QStringList(),
00393 i18n("Do not ask again"), &dontAgain, KMessageBox::Notify);
00394
00395
00396 if (dontAgain)
00397 {
00398 c->setGroup("General");
00399
00400 if (res == KDialogBase::No)
00401 c->writeEntry ("Session Exit", "discard");
00402 else
00403 c->writeEntry ("Session Exit", "save");
00404 }
00405
00406 if (res == KDialogBase::No)
00407 return true;
00408 }
00409 }
00410
00411 KConfig *sc = activeSession()->configWrite();
00412
00413 if (!sc)
00414 return false;
00415
00416 KateDocManager::self()->saveDocumentList (sc);
00417
00418 sc->setGroup ("Open MainWindows");
00419 sc->writeEntry ("Count", KateApp::self()->mainWindows ());
00420
00421
00422 for (unsigned int i=0; i < KateApp::self()->mainWindows (); ++i )
00423 {
00424 sc->setGroup(QString ("MainWindow%1").arg(i));
00425 KateApp::self()->mainWindow(i)->saveProperties (sc);
00426 }
00427
00428 sc->sync();
00429
00430 if (rememberAsLast)
00431 {
00432 KConfig *c = KateApp::self()->config();
00433 c->setGroup("General");
00434 c->writeEntry ("Last Session", activeSession()->sessionFileRelative());
00435 c->sync ();
00436 }
00437
00438 return true;
00439 }
00440
00441 bool KateSessionManager::chooseSession ()
00442 {
00443 bool success = true;
00444
00445
00446 KConfig *c = KateApp::self()->config();
00447 c->setGroup("General");
00448
00449
00450 QString lastSession (c->readEntry ("Last Session", "default.katesession"));
00451 QString sesStart (c->readEntry ("Startup Session", "manual"));
00452
00453
00454 if (sesStart == "last")
00455 {
00456 activateSession (new KateSession (this, lastSession, ""), false, false);
00457 return success;
00458 }
00459
00460
00461 if (sesStart == "new")
00462 {
00463 activateSession (new KateSession (this, "", ""), false, false);
00464 return success;
00465 }
00466
00467 KateSessionChooser *chooser = new KateSessionChooser (0, lastSession);
00468
00469 bool retry = true;
00470 int res = 0;
00471 while (retry)
00472 {
00473 res = chooser->exec ();
00474
00475 switch (res)
00476 {
00477 case KateSessionChooser::resultOpen:
00478 {
00479 KateSession::Ptr s = chooser->selectedSession ();
00480
00481 if (!s)
00482 {
00483 KMessageBox::error (chooser, i18n("No session selected to open."), i18n ("No Session Selected"));
00484 break;
00485 }
00486
00487 activateSession (s, false, false);
00488 retry = false;
00489 break;
00490 }
00491
00492
00493 case KateSessionChooser::resultQuit:
00494 success = false;
00495 retry = false;
00496 break;
00497
00498 default:
00499 activateSession (new KateSession (this, "", ""), false, false);
00500 retry = false;
00501 break;
00502 }
00503 }
00504
00505
00506 if (success && chooser->reopenLastSession ())
00507 {
00508 c->setGroup("General");
00509
00510 if (res == KateSessionChooser::resultOpen)
00511 c->writeEntry ("Startup Session", "last");
00512 else if (res == KateSessionChooser::resultNew)
00513 c->writeEntry ("Startup Session", "new");
00514
00515 c->sync ();
00516 }
00517
00518 delete chooser;
00519
00520 return success;
00521 }
00522
00523 void KateSessionManager::sessionNew ()
00524 {
00525 activateSession (new KateSession (this, "", ""));
00526 }
00527
00528 void KateSessionManager::sessionOpen ()
00529 {
00530 KateSessionOpenDialog *chooser = new KateSessionOpenDialog (0);
00531
00532 int res = chooser->exec ();
00533
00534 if (res == KateSessionOpenDialog::resultCancel)
00535 {
00536 delete chooser;
00537 return;
00538 }
00539
00540 KateSession::Ptr s = chooser->selectedSession ();
00541
00542 if (s)
00543 activateSession (s);
00544
00545 delete chooser;
00546 }
00547
00548 void KateSessionManager::sessionSave ()
00549 {
00550
00551 if (saveActiveSession ())
00552 return;
00553
00554 bool ok = false;
00555 QString name = KInputDialog::getText (i18n("Specify Name for Current Session"), i18n("Session name:"), "", &ok);
00556
00557 if (!ok)
00558 return;
00559
00560 if (name.isEmpty())
00561 {
00562 KMessageBox::error (0, i18n("To save a new session, you must specify a name."), i18n ("Missing Session Name"));
00563 return;
00564 }
00565
00566 activeSession()->create (name);
00567 saveActiveSession ();
00568 }
00569
00570 void KateSessionManager::sessionSaveAs ()
00571 {
00572 bool ok = false;
00573 QString name = KInputDialog::getText (i18n("Specify New Name for Current Session"), i18n("Session name:"), "", &ok);
00574
00575 if (!ok)
00576 return;
00577
00578 if (name.isEmpty())
00579 {
00580 KMessageBox::error (0, i18n("To save a session, you must specify a name."), i18n ("Missing Session Name"));
00581 return;
00582 }
00583
00584 activeSession()->create (name, true);
00585 saveActiveSession ();
00586 }
00587
00588
00589 void KateSessionManager::sessionManage ()
00590 {
00591 KateSessionManageDialog *dlg = new KateSessionManageDialog (0);
00592
00593 dlg->exec ();
00594
00595 delete dlg;
00596 }
00597
00598
00599
00600 class KateSessionChooserItem : public QListViewItem
00601 {
00602 public:
00603 KateSessionChooserItem (KListView *lv, KateSession::Ptr s)
00604 : QListViewItem (lv, s->sessionName())
00605 , session (s)
00606 {
00607 QString docs;
00608 docs.setNum (s->documents());
00609 setText (1, docs);
00610 }
00611
00612 KateSession::Ptr session;
00613 };
00614
00615 KateSessionChooser::KateSessionChooser (QWidget *parent, const QString &lastSession)
00616 : KDialogBase ( parent
00617 , ""
00618 , true
00619 , i18n ("Session Chooser")
00620 , KDialogBase::User1 | KDialogBase::User2 | KDialogBase::User3
00621 , KDialogBase::User2
00622 , true
00623 , KStdGuiItem::quit ()
00624 , KGuiItem (i18n ("Open Session"), "fileopen")
00625 , KGuiItem (i18n ("New Session"), "filenew")
00626 )
00627 {
00628 QHBox *page = new QHBox (this);
00629 page->setMinimumSize (400, 200);
00630 setMainWidget(page);
00631
00632 QHBox *hb = new QHBox (page);
00633 hb->setSpacing (KDialog::spacingHint());
00634
00635 QLabel *label = new QLabel (hb);
00636 label->setPixmap (UserIcon("sessionchooser"));
00637 label->setFrameStyle (QFrame::Panel | QFrame::Sunken);
00638
00639 QVBox *vb = new QVBox (hb);
00640 vb->setSpacing (KDialog::spacingHint());
00641
00642 m_sessions = new KListView (vb);
00643 m_sessions->addColumn (i18n("Session Name"));
00644 m_sessions->addColumn (i18n("Open Documents"));
00645 m_sessions->setResizeMode (QListView::AllColumns);
00646 m_sessions->setSelectionMode (QListView::Single);
00647 m_sessions->setAllColumnsShowFocus (true);
00648
00649 connect (m_sessions, SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
00650 connect (m_sessions, SIGNAL(doubleClicked(QListViewItem *, const QPoint &, int)), this, SLOT(slotUser2()));
00651
00652 KateSessionList &slist (KateSessionManager::self()->sessionList());
00653 for (unsigned int i=0; i < slist.count(); ++i)
00654 {
00655 KateSessionChooserItem *item = new KateSessionChooserItem (m_sessions, slist[i]);
00656
00657 if (slist[i]->sessionFileRelative() == lastSession)
00658 m_sessions->setSelected (item, true);
00659 }
00660
00661 m_useLast = new QCheckBox (i18n ("&Always use this choice"), vb);
00662
00663 setResult (resultNone);
00664
00665
00666 selectionChanged ();
00667 }
00668
00669 KateSessionChooser::~KateSessionChooser ()
00670 {
00671 }
00672
00673 KateSession::Ptr KateSessionChooser::selectedSession ()
00674 {
00675 KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
00676
00677 if (!item)
00678 return 0;
00679
00680 return item->session;
00681 }
00682
00683 bool KateSessionChooser::reopenLastSession ()
00684 {
00685 return m_useLast->isChecked ();
00686 }
00687
00688 void KateSessionChooser::slotUser2 ()
00689 {
00690 done (resultOpen);
00691 }
00692
00693 void KateSessionChooser::slotUser3 ()
00694 {
00695 done (resultNew);
00696 }
00697
00698 void KateSessionChooser::slotUser1 ()
00699 {
00700 done (resultQuit);
00701 }
00702
00703 void KateSessionChooser::selectionChanged ()
00704 {
00705 enableButton (KDialogBase::User1, m_sessions->selectedItem ());
00706 }
00707
00708
00709
00710
00711
00712 KateSessionOpenDialog::KateSessionOpenDialog (QWidget *parent)
00713 : KDialogBase ( parent
00714 , ""
00715 , true
00716 , i18n ("Open Session")
00717 , KDialogBase::User1 | KDialogBase::User2
00718 , KDialogBase::User2
00719 , false
00720 , KStdGuiItem::cancel ()
00721 , KGuiItem( i18n("&Open"), "fileopen")
00722 )
00723 {
00724 QHBox *page = new QHBox (this);
00725 page->setMinimumSize (400, 200);
00726 setMainWidget(page);
00727
00728 QHBox *hb = new QHBox (page);
00729
00730 QVBox *vb = new QVBox (hb);
00731
00732 m_sessions = new KListView (vb);
00733 m_sessions->addColumn (i18n("Session Name"));
00734 m_sessions->addColumn (i18n("Open Documents"));
00735 m_sessions->setResizeMode (QListView::AllColumns);
00736 m_sessions->setSelectionMode (QListView::Single);
00737 m_sessions->setAllColumnsShowFocus (true);
00738
00739 connect (m_sessions, SIGNAL(doubleClicked(QListViewItem *, const QPoint &, int)), this, SLOT(slotUser2()));
00740
00741 KateSessionList &slist (KateSessionManager::self()->sessionList());
00742 for (unsigned int i=0; i < slist.count(); ++i)
00743 {
00744 new KateSessionChooserItem (m_sessions, slist[i]);
00745 }
00746
00747 setResult (resultCancel);
00748 }
00749
00750 KateSessionOpenDialog::~KateSessionOpenDialog ()
00751 {
00752 }
00753
00754 KateSession::Ptr KateSessionOpenDialog::selectedSession ()
00755 {
00756 KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
00757
00758 if (!item)
00759 return 0;
00760
00761 return item->session;
00762 }
00763
00764 void KateSessionOpenDialog::slotUser1 ()
00765 {
00766 done (resultCancel);
00767 }
00768
00769 void KateSessionOpenDialog::slotUser2 ()
00770 {
00771 done (resultOk);
00772 }
00773
00774
00775
00776
00777
00778 KateSessionManageDialog::KateSessionManageDialog (QWidget *parent)
00779 : KDialogBase ( parent
00780 , ""
00781 , true
00782 , i18n ("Manage Sessions")
00783 , KDialogBase::User1
00784 , KDialogBase::User1
00785 , false
00786 , KStdGuiItem::close ()
00787 )
00788 {
00789 QHBox *page = new QHBox (this);
00790 page->setMinimumSize (400, 200);
00791 setMainWidget(page);
00792
00793 QHBox *hb = new QHBox (page);
00794 hb->setSpacing (KDialog::spacingHint());
00795
00796 m_sessions = new KListView (hb);
00797 m_sessions->addColumn (i18n("Session Name"));
00798 m_sessions->addColumn (i18n("Open Documents"));
00799 m_sessions->setResizeMode (QListView::AllColumns);
00800 m_sessions->setSelectionMode (QListView::Single);
00801 m_sessions->setAllColumnsShowFocus (true);
00802
00803 connect (m_sessions, SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
00804
00805 updateSessionList ();
00806
00807 QWidget *vb = new QWidget (hb);
00808 QVBoxLayout *vbl = new QVBoxLayout (vb);
00809 vbl->setSpacing (KDialog::spacingHint());
00810
00811 m_rename = new KPushButton (i18n("&Rename..."), vb);
00812 connect (m_rename, SIGNAL(clicked()), this, SLOT(rename()));
00813 vbl->addWidget (m_rename);
00814
00815 m_del = new KPushButton (KStdGuiItem::del (), vb);
00816 connect (m_del, SIGNAL(clicked()), this, SLOT(del()));
00817 vbl->addWidget (m_del);
00818
00819 vbl->addStretch ();
00820
00821
00822 selectionChanged ();
00823 }
00824
00825 KateSessionManageDialog::~KateSessionManageDialog ()
00826 {
00827 }
00828
00829 void KateSessionManageDialog::slotUser1 ()
00830 {
00831 done (0);
00832 }
00833
00834
00835 void KateSessionManageDialog::selectionChanged ()
00836 {
00837 KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
00838
00839 m_rename->setEnabled (item && item->session->sessionFileRelative() != "default.katesession");
00840 m_del->setEnabled (item && item->session->sessionFileRelative() != "default.katesession");
00841 }
00842
00843 void KateSessionManageDialog::rename ()
00844 {
00845 KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
00846
00847 if (!item || item->session->sessionFileRelative() == "default.katesession")
00848 return;
00849
00850 bool ok = false;
00851 QString name = KInputDialog::getText (i18n("Specify New Name for Session"), i18n("Session name:"), item->session->sessionName(), &ok);
00852
00853 if (!ok)
00854 return;
00855
00856 if (name.isEmpty())
00857 {
00858 KMessageBox::error (0, i18n("To save a session, you must specify a name."), i18n ("Missing Session Name"));
00859 return;
00860 }
00861
00862 item->session->rename (name);
00863 updateSessionList ();
00864 }
00865
00866 void KateSessionManageDialog::del ()
00867 {
00868 KateSessionChooserItem *item = (KateSessionChooserItem *) m_sessions->selectedItem ();
00869
00870 if (!item || item->session->sessionFileRelative() == "default.katesession")
00871 return;
00872
00873 QFile::remove (item->session->sessionFile());
00874 KateSessionManager::self()->updateSessionList ();
00875 updateSessionList ();
00876 }
00877
00878 void KateSessionManageDialog::updateSessionList ()
00879 {
00880 m_sessions->clear ();
00881
00882 KateSessionList &slist (KateSessionManager::self()->sessionList());
00883 for (unsigned int i=0; i < slist.count(); ++i)
00884 {
00885 new KateSessionChooserItem (m_sessions, slist[i]);
00886 }
00887 }
00888
00889
00890
00891
00892 KateSessionsAction::KateSessionsAction(const QString& text, QObject* parent, const char* name )
00893 : KActionMenu(text, parent, name)
00894 {
00895 connect(popupMenu(),SIGNAL(aboutToShow()),this,SLOT(slotAboutToShow()));
00896 }
00897
00898 void KateSessionsAction::slotAboutToShow()
00899 {
00900 popupMenu()->clear ();
00901
00902 KateSessionList &slist (KateSessionManager::self()->sessionList());
00903 for (unsigned int i=0; i < slist.count(); ++i)
00904 {
00905 popupMenu()->insertItem (
00906 slist[i]->sessionName(),
00907 this, SLOT (openSession (int)), 0,
00908 i );
00909 }
00910 }
00911
00912 void KateSessionsAction::openSession (int i)
00913 {
00914 KateSessionList &slist (KateSessionManager::self()->sessionList());
00915
00916 if ((uint)i >= slist.count())
00917 return;
00918
00919 KateSessionManager::self()->activateSession(slist[(uint)i]);
00920 }
00921