apps/konsole/src/SessionManager.cpp

   1 /*
   2     This source file is part of Konsole, a terminal emulator.
   3
   4     Copyright 2006-2008 by Robert Knight <robertknight@gmail.com>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19     02110-1301  USA.
  20 */
  21
  22 // Own
  23 #include "SessionManager.h"
  24
  25 // Qt
  26 #include <QtCore/QDir>
  27 #include <QtCore/QFileInfo>
  28 #include <QtCore/QList>
  29 #include <QtCore/QSignalMapper>
  30 #include <QtCore/QString>
  31 #include <QtCore/QTextCodec>
  32
  33 // KDE
  34 #include <klocale.h>
  35 #include <kicon.h>
  36 #include <krun.h>
  37 #include <kshell.h>
  38 #include <kconfig.h>
  39 #include <kglobal.h>
  40 #include <kdebug.h>
  41 #include <kconfiggroup.h>
  42 #include <kstandarddirs.h>
  43 #include <kdesktopfile.h>
  44
  45 // Konsole
  46 #include "ColorScheme.h"
  47 #include "Session.h"
  48 #include "History.h"
  49 #include "ShellCommand.h"
  50
  51 using namespace Konsole;
  52
  53 #if 0
  54
  55 bool Profile::isAvailable() const
  56 {
  57     //TODO:  Is it necessary to cache the result of the search?
  58
  59     QString binary = KRun::binaryName( command(true) , false );
  60     binary = KShell::tildeExpand(binary);
  61
  62     QString fullBinaryPath = KGlobal::dirs()->findExe(binary);
  63
  64     if ( fullBinaryPath.isEmpty() )
  65         return false;
  66     else
  67         return true;
  68 }
  69 #endif
  70
  71 SessionManager::SessionManager()
  72     : _loadedAllProfiles(false)
  73     , _loadedFavorites(false)
  74 {
  75     //map finished() signals from sessions
  76     _sessionMapper = new QSignalMapper(this);
  77     connect( _sessionMapper , SIGNAL(mapped(QObject*)) , this ,
  78             SLOT(sessionTerminated(QObject*)) );
  79
  80     //load fallback profile
  81     _fallbackProfile = Profile::Ptr(new FallbackProfile);
  82     addProfile(_fallbackProfile);
  83
  84     //locate and load default profile
  85     KSharedConfigPtr appConfig = KGlobal::config();
  86     const KConfigGroup group = appConfig->group( "Desktop Entry" );
  87     QString defaultSessionFilename = group.readEntry("DefaultProfile","Shell.profile");
  88
  89     QString path = KGlobal::dirs()->findResource("data","konsole/"+defaultSessionFilename);
  90     if (!path.isEmpty())
  91     {
  92         Profile::Ptr profile = loadProfile(path);
  93         if ( profile )
  94             _defaultProfile = profile;
  95     }
  96
  97     Q_ASSERT( _types.count() > 0 );
  98     Q_ASSERT( _defaultProfile );
  99
 100     // get shortcuts and paths of profiles associated with
 101     // them - this doesn't load the shortcuts themselves,
 102     // that is done on-demand.
 103     loadShortcuts();
 104 }
 105 Profile::Ptr SessionManager::loadProfile(const QString& shortPath)
 106 {
 107     // the fallback profile has a 'special' path name, "FALLBACK/"
 108     if (shortPath == _fallbackProfile->property<QString>(Profile::Path))
 109         return _fallbackProfile;
 110
 111     QString path = shortPath;
 112
 113     // add a suggested suffix and relative prefix if missing
 114     QFileInfo fileInfo(path);
 115     if ( fileInfo.suffix().isEmpty() )
 116         path.append(".profile");
 117     if ( fileInfo.path().isEmpty() || fileInfo.path() == "." )
 118         path.prepend(QString("konsole")+QDir::separator());
 119
 120     // if the file is not an absolute path, look it up
 121     if ( !fileInfo.isAbsolute() )
 122         path = KStandardDirs::locate("data",path);
 123
 124     // check that we have not already loaded this profile
 125     QSetIterator<Profile::Ptr> iter(_types);
 126     while ( iter.hasNext() )
 127     {
 128         Profile::Ptr profile = iter.next();
 129         if ( profile->path() == path )
 130             return profile;
 131     }
 132
 133     // guard to prevent problems if a profile specifies itself as its parent
 134     // or if there is recursion in the "inheritance" chain
 135     // (eg. two profiles, A and B, specifying each other as their parents)
 136     static QStack<QString> recursionGuard;
 137     PopStackOnExit<QString> popGuardOnExit(recursionGuard);
 138
 139     if (recursionGuard.contains(path))
 140     {
 141         kWarning() << "Ignoring attempt to load profile recursively from" << path;
 142         return _fallbackProfile;
 143     }
 144     else
 145         recursionGuard.push(path);
 146
 147     // load the profile
 148     ProfileReader* reader = 0;
 149     if ( path.endsWith(".desktop") )
 150         reader = 0; // new KDE3ProfileReader;
 151     else
 152         reader = new KDE4ProfileReader;
 153
 154     if (!reader)
 155     {
 156         kWarning() << "Could not create loader to read profile from" << path;
 157         return Profile::Ptr();
 158     }
 159
 160     Profile::Ptr newProfile = Profile::Ptr(new Profile(defaultProfile()));
 161     newProfile->setProperty(Profile::Path,path);
 162
 163     QString parentProfilePath;
 164     bool result = reader->readProfile(path,newProfile,parentProfilePath);
 165
 166     if ( !parentProfilePath.isEmpty() )
 167     {
 168         Profile::Ptr parentProfile = loadProfile(parentProfilePath);
 169         newProfile->setParent(parentProfile);
 170     }
 171
 172     delete reader;
 173
 174     if (!result)
 175     {
 176         kWarning() << "Could not load profile from " << path;
 177         return Profile::Ptr();
 178     }
 179     else
 180     {
 181         addProfile(newProfile);
 182         return newProfile;
 183     }
 184 }
 185 QStringList SessionManager::availableProfilePaths() const
 186 {
 187     KDE3ProfileReader kde3Reader;
 188     KDE4ProfileReader kde4Reader;
 189
 190     QStringList profiles;
 191     profiles += kde3Reader.findProfiles();
 192     profiles += kde4Reader.findProfiles();
 193
 194     return profiles;
 195 }
 196
 197 void SessionManager::loadAllProfiles()
 198 {
 199     if ( _loadedAllProfiles )
 200         return;
 201
 202     QStringList profiles = availableProfilePaths();
 203
 204     QListIterator<QString> iter(profiles);
 205     while (iter.hasNext())
 206         loadProfile(iter.next());
 207
 208     _loadedAllProfiles = true;
 209 }
 210 void SessionManager::saveState()
 211 {
 212     // save default profile
 213     setDefaultProfile( _defaultProfile );
 214
 215     // save shortcuts
 216     saveShortcuts();
 217
 218     // save favorites
 219     saveFavorites();
 220 }
 221 void SessionManager::closeAll()
 222 {
 223     // close remaining sessions
 224     foreach( Session* session , _sessions )
 225     {
 226         session->close();
 227     }
 228     _sessions.clear();
 229 }
 230 SessionManager::~SessionManager()
 231 {
 232     if (_sessions.count() > 0)
 233     {
 234         kWarning() << "Konsole SessionManager destroyed with sessions still alive";
 235         // ensure that the Session doesn't later try to call back and do things to the
 236         // SessionManager
 237         foreach(Session* session , _sessions)
 238             disconnect(session , 0 , this , 0);
 239     }
 240 }
 241
 242 const QList<Session*> SessionManager::sessions()
 243 {
 244     return _sessions;
 245 }
 246
 247 void SessionManager::updateSession(Session* session)
 248 {
 249     Profile::Ptr info = _sessionProfiles[session];
 250
 251     Q_ASSERT( info );
 252
 253     applyProfile(session,info,false);
 254
 255     // FIXME - This may update a lot more than just the session
 256     // of interest.
 257     emit sessionUpdated(session);
 258 }
 259
 260 Session* SessionManager::createSession(Profile::Ptr info)
 261 {
 262     Session* session = 0;
 263
 264     if (!info)
 265         info = defaultProfile();
 266
 267     if (!_types.contains(info))
 268         addProfile(info);
 269
 270     //configuration information found, create a new session based on this
 271     session = new Session();
 272     applyProfile(session,info,false);
 273
 274     connect( session , SIGNAL(profileChangeCommandReceived(QString)) , this ,
 275             SLOT(sessionProfileCommandReceived(QString)) );
 276
 277     //ask for notification when session dies
 278     _sessionMapper->setMapping(session,session);
 279     connect( session , SIGNAL(finished()) , _sessionMapper ,
 280              SLOT(map()) );
 281
 282     //add session to active list
 283     _sessions << session;
 284     _sessionProfiles.insert(session,info);
 285
 286     Q_ASSERT( session );
 287
 288     return session;
 289 }
 290
 291 void SessionManager::sessionTerminated(QObject* sessionObject)
 292 {
 293     Session* session = qobject_cast<Session*>(sessionObject);
 294
 295     Q_ASSERT( session );
 296
 297     _sessions.removeAll(session);
 298     session->deleteLater();
 299 }
 300
 301 QList<Profile::Ptr> SessionManager::loadedProfiles() const
 302 {
 303     return _types.toList();
 304 }
 305
 306 Profile::Ptr SessionManager::defaultProfile() const
 307 {
 308     return _defaultProfile;
 309 }
 310 Profile::Ptr SessionManager::fallbackProfile() const
 311 { return _fallbackProfile; }
 312
 313 QString SessionManager::saveProfile(Profile::Ptr info)
 314 {
 315     ProfileWriter* writer = new KDE4ProfileWriter;
 316
 317     QString newPath = writer->getPath(info);
 318
 319     writer->writeProfile(newPath,info);
 320
 321     delete writer;
 322
 323     return newPath;
 324 }
 325
 326 void SessionManager::changeProfile(Profile::Ptr info ,
 327                                    QHash<Profile::Property,QVariant> propertyMap, bool persistant)
 328 {
 329     Q_ASSERT(info);
 330
 331     // insert the changes into the existing Profile instance
 332     QListIterator<Profile::Property> iter(propertyMap.keys());
 333     while ( iter.hasNext() )
 334     {
 335         const Profile::Property property = iter.next();
 336         info->setProperty(property,propertyMap[property]);
 337     }
 338
 339     // when changing a group, iterate through the profiles
 340     // in the group and call changeProfile() on each of them
 341     //
 342     // this is so that each profile in the group, the profile is
 343     // applied, a change notification is emitted and the profile
 344     // is saved to disk
 345     ProfileGroup::Ptr group = info->asGroup();
 346     if (group)
 347     {
 348         foreach(Profile::Ptr profile, group->profiles())
 349             changeProfile(profile,propertyMap,persistant);
 350         return;
 351     }
 352
 353     // apply the changes to existing sessions
 354     applyProfile(info,true);
 355
 356     // notify the world about the change
 357     emit profileChanged(info);
 358
 359     // save changes to disk, unless the profile is hidden, in which case
 360     // it has no file on disk
 361     if ( persistant && !info->isHidden() )
 362     {
 363         info->setProperty(Profile::Path,saveProfile(info));
 364     }
 365 }
 366 void SessionManager::applyProfile(Profile::Ptr info , bool modifiedPropertiesOnly)
 367 {
 368     QListIterator<Session*> iter(_sessions);
 369     while ( iter.hasNext() )
 370     {
 371         Session* next = iter.next();
 372         if ( _sessionProfiles[next] == info )
 373             applyProfile(next,info,modifiedPropertiesOnly);
 374     }
 375 }
 376 Profile::Ptr SessionManager::sessionProfile(Session* session) const
 377 {
 378     return _sessionProfiles[session];
 379 }
 380 void SessionManager::setSessionProfile(Session* session, Profile::Ptr profile)
 381 {
 382     _sessionProfiles[session] = profile;
 383     updateSession(session);
 384 }
 385 void SessionManager::applyProfile(Session* session, const Profile::Ptr info , bool modifiedPropertiesOnly)
 386 {
 387     Q_ASSERT(info);
 388
 389     _sessionProfiles[session] = info;
 390
 391     ShouldApplyProperty apply(info,modifiedPropertiesOnly);
 392
 393     // Basic session settings
 394     if ( apply.shouldApply(Profile::Name) )
 395         session->setTitle(Session::NameRole,info->name());
 396
 397     if ( apply.shouldApply(Profile::Command) )
 398         session->setProgram(info->command());
 399
 400     if ( apply.shouldApply(Profile::Arguments) )
 401         session->setArguments(info->arguments());
 402
 403     if ( apply.shouldApply(Profile::Directory) )
 404         session->setInitialWorkingDirectory(info->defaultWorkingDirectory());
 405
 406     if ( apply.shouldApply(Profile::Environment) )
 407     {
 408         // add environment variable containing home directory of current profile
 409         // (if specified)
 410         QStringList environment = info->property<QStringList>(Profile::Environment);
 411         environment << QString("PROFILEHOME=%1").arg(info->defaultWorkingDirectory());
 412
 413         session->setEnvironment(environment);
 414     }
 415
 416     if ( apply.shouldApply(Profile::Icon) )
 417         session->setIconName(info->icon());
 418
 419     // Key bindings
 420     if ( apply.shouldApply(Profile::KeyBindings) )
 421         session->setKeyBindings(info->property<QString>(Profile::KeyBindings));
 422
 423     // Tab formats
 424     if ( apply.shouldApply(Profile::LocalTabTitleFormat) )
 425         session->setTabTitleFormat( Session::LocalTabTitle ,
 426                                     info->property<QString>(Profile::LocalTabTitleFormat));
 427     if ( apply.shouldApply(Profile::RemoteTabTitleFormat) )
 428         session->setTabTitleFormat( Session::RemoteTabTitle ,
 429                                     info->property<QString>(Profile::RemoteTabTitleFormat));
 430
 431     // Scrollback / history
 432     if ( apply.shouldApply(Profile::HistoryMode) || apply.shouldApply(Profile::HistorySize) )
 433     {
 434         int mode = info->property<int>(Profile::HistoryMode);
 435         switch ((Profile::HistoryModeEnum)mode)
 436         {
 437             case Profile::DisableHistory:
 438                     session->setHistoryType( HistoryTypeNone() );
 439                 break;
 440             case Profile::FixedSizeHistory:
 441                 {
 442                     int lines = info->property<int>(Profile::HistorySize);
 443                     session->setHistoryType( HistoryTypeBuffer(lines) );
 444                 }
 445                 break;
 446             case Profile::UnlimitedHistory:
 447                     session->setHistoryType( HistoryTypeFile() );
 448                 break;
 449         }
 450     }
 451
 452     // Terminal features
 453     if ( apply.shouldApply(Profile::FlowControlEnabled) )
 454         session->setFlowControlEnabled( info->property<bool>(Profile::FlowControlEnabled) );
 455
 456     // Encoding
 457     if ( apply.shouldApply(Profile::DefaultEncoding) )
 458     {
 459         QByteArray name = info->property<QString>(Profile::DefaultEncoding).toUtf8();
 460         session->setCodec( QTextCodec::codecForName(name) );
 461     }
 462 }
 463
 464 void SessionManager::addProfile(Profile::Ptr type)
 465 {
 466     if ( _types.isEmpty() )
 467         _defaultProfile = type;
 468
 469     _types.insert(type);
 470
 471     emit profileAdded(type);
 472 }
 473
 474 bool SessionManager::deleteProfile(Profile::Ptr type)
 475 {
 476     bool wasDefault = ( type == defaultProfile() );
 477
 478     if ( type )
 479     {
 480         // try to delete the config file
 481         if ( type->isPropertySet(Profile::Path) && QFile::exists(type->path()) )
 482         {
 483             if (!QFile::remove(type->path()))
 484             {
 485                 kWarning() << "Could not delete profile: " << type->path()
 486                     << "The file is most likely in a directory which is read-only.";
 487
 488                 return false;
 489             }
 490         }
 491
 492         // remove from favorites, profile list, shortcut list etc.
 493         setFavorite(type,false);
 494         setShortcut(type,QKeySequence());
 495         _types.remove(type);
 496
 497         // mark the profile as hidden so that it does not show up in the
 498         // Manage Profiles dialog and is not saved to disk
 499         type->setHidden(true);
 500     }
 501
 502     // if we just deleted the default session type,
 503     // replace it with a random type from the list
 504     if ( wasDefault )
 505     {
 506         setDefaultProfile( _types.toList().first() );
 507     }
 508
 509     emit profileRemoved(type);
 510
 511     return true;
 512 }
 513 void SessionManager::setDefaultProfile(Profile::Ptr info)
 514 {
 515    Q_ASSERT ( _types.contains(info) );
 516
 517    _defaultProfile = info;
 518
 519    QString path = info->path();
 520
 521    if ( path.isEmpty() )
 522        path = KDE4ProfileWriter().getPath(info);
 523
 524    QFileInfo fileInfo(path);
 525
 526    KSharedConfigPtr config = KGlobal::config();
 527    KConfigGroup group = config->group("Desktop Entry");
 528    group.writeEntry("DefaultProfile",fileInfo.fileName());
 529 }
 530 QSet<Profile::Ptr> SessionManager::findFavorites()
 531 {
 532     if (!_loadedFavorites)
 533         loadFavorites();
 534
 535     return _favorites;
 536 }
 537 void SessionManager::setFavorite(Profile::Ptr info , bool favorite)
 538 {
 539     if (!_types.contains(info))
 540         addProfile(info);
 541
 542     if ( favorite && !_favorites.contains(info) )
 543     {
 544         _favorites.insert(info);
 545         emit favoriteStatusChanged(info,favorite);
 546     }
 547     else if ( !favorite && _favorites.contains(info) )
 548     {
 549         _favorites.remove(info);
 550         emit favoriteStatusChanged(info,favorite);
 551     }
 552 }
 553 void SessionManager::loadShortcuts()
 554 {
 555     KSharedConfigPtr appConfig = KGlobal::config();
 556     KConfigGroup shortcutGroup = appConfig->group("Profile Shortcuts");
 557
 558     QMap<QString,QString> entries = shortcutGroup.entryMap();
 559
 560     QMapIterator<QString,QString> iter(entries);
 561     while ( iter.hasNext() )
 562     {
 563         iter.next();
 564
 565         QKeySequence shortcut = QKeySequence::fromString(iter.key());
 566         QString profilePath = iter.value();
 567
 568         ShortcutData data;
 569         data.profilePath = profilePath;
 570
 571         _shortcuts.insert(shortcut,data);
 572     }
 573 }
 574 void SessionManager::saveShortcuts()
 575 {
 576     KSharedConfigPtr appConfig = KGlobal::config();
 577     KConfigGroup shortcutGroup = appConfig->group("Profile Shortcuts");
 578     shortcutGroup.deleteGroup();
 579
 580     QMapIterator<QKeySequence,ShortcutData> iter(_shortcuts);
 581     while ( iter.hasNext() )
 582     {
 583         iter.next();
 584
 585         QString shortcutString = iter.key().toString();
 586
 587         shortcutGroup.writeEntry(shortcutString,
 588                 iter.value().profilePath);
 589     }
 590 }
 591 void SessionManager::setShortcut(Profile::Ptr info ,
 592                                  const QKeySequence& keySequence )
 593 {
 594     QKeySequence existingShortcut = shortcut(info);
 595     _shortcuts.remove(existingShortcut);
 596
 597     if (keySequence.isEmpty())
 598         return;
 599
 600     ShortcutData data;
 601     data.profileKey = info;
 602     data.profilePath = info->path();
 603     // TODO - This won't work if the profile doesn't
 604     // have a path yet
 605     _shortcuts.insert(keySequence,data);
 606
 607     emit shortcutChanged(info,keySequence);
 608 }
 609 void SessionManager::loadFavorites()
 610 {
 611     KSharedConfigPtr appConfig = KGlobal::config();
 612     KConfigGroup favoriteGroup = appConfig->group("Favorite Profiles");
 613
 614     QSet<QString> favoriteSet;
 615
 616     if ( favoriteGroup.hasKey("Favorites") )
 617     {
 618        QStringList list = favoriteGroup.readEntry("Favorites", QStringList());
 619        favoriteSet = QSet<QString>::fromList(list);
 620     }
 621     else
 622     {
 623        // if there is no favorites key at all, mark the
 624        // supplied 'Shell.profile' as the only favorite
 625        favoriteSet << "Shell.profile";
 626     }
 627
 628     // look for favorites amongst those already loaded
 629     QSetIterator<Profile::Ptr> iter(_types);
 630     while ( iter.hasNext() )
 631     {
 632          Profile::Ptr profile = iter.next();
 633          const QString& path = profile->path();
 634          if ( favoriteSet.contains( path ) )
 635          {
 636              _favorites.insert( profile );
 637              favoriteSet.remove(path);
 638          }
 639     }
 640     // load any remaining favorites
 641     QSetIterator<QString> unloadedFavoriteIter(favoriteSet);
 642     while ( unloadedFavoriteIter.hasNext() )
 643     {
 644           Profile::Ptr profile = loadProfile(unloadedFavoriteIter.next());
 645           if (profile)
 646               _favorites.insert(profile);
 647     }
 648
 649     _loadedFavorites = true;
 650 }
 651 void SessionManager::saveFavorites()
 652 {
 653     KSharedConfigPtr appConfig = KGlobal::config();
 654     KConfigGroup favoriteGroup = appConfig->group("Favorite Profiles");
 655
 656     QStringList paths;
 657     QSetIterator<Profile::Ptr> keyIter(_favorites);
 658     while ( keyIter.hasNext() )
 659     {
 660         Profile::Ptr profile = keyIter.next();
 661
 662         Q_ASSERT( _types.contains(profile) && profile );
 663
 664         paths << profile->path();
 665     }
 666
 667     favoriteGroup.writeEntry("Favorites",paths);
 668 }
 669
 670 QList<QKeySequence> SessionManager::shortcuts()
 671 {
 672     return _shortcuts.keys();
 673 }
 674
 675 Profile::Ptr SessionManager::findByShortcut(const QKeySequence& shortcut)
 676 {
 677     Q_ASSERT( _shortcuts.contains(shortcut) );
 678
 679     if ( !_shortcuts[shortcut].profileKey )
 680     {
 681         Profile::Ptr key = loadProfile(_shortcuts[shortcut].profilePath);
 682         if (!key)
 683         {
 684             _shortcuts.remove(shortcut);
 685             return Profile::Ptr();
 686         }
 687         _shortcuts[shortcut].profileKey = key;
 688     }
 689
 690     return _shortcuts[shortcut].profileKey;
 691 }
 692
 693 void SessionManager::sessionProfileCommandReceived(const QString& text)
 694 {
 695     // FIXME: This is inefficient, it creates a new profile instance for
 696     // each set of changes applied.  Instead a new profile should be created
 697     // only the first time changes are applied to a session
 698
 699     Session* session = qobject_cast<Session*>(sender());
 700     Q_ASSERT( session );
 701
 702     ProfileCommandParser parser;
 703     QHash<Profile::Property,QVariant> changes = parser.parse(text);
 704
 705     Profile::Ptr newProfile = Profile::Ptr(new Profile(_sessionProfiles[session]));
 706
 707     QHashIterator<Profile::Property,QVariant> iter(changes);
 708     while ( iter.hasNext() )
 709     {
 710         iter.next();
 711         newProfile->setProperty(iter.key(),iter.value());
 712     }
 713
 714     _sessionProfiles[session] = newProfile;
 715     applyProfile(newProfile,true);
 716     emit sessionUpdated(session);
 717 }
 718
 719 QKeySequence SessionManager::shortcut(Profile::Ptr info) const
 720 {
 721     QMapIterator<QKeySequence,ShortcutData> iter(_shortcuts);
 722     while (iter.hasNext())
 723     {
 724         iter.next();
 725         if ( iter.value().profileKey == info
 726              || iter.value().profilePath == info->path() )
 727             return iter.key();
 728     }
 729
 730     return QKeySequence();
 731 }
 732
 733 void SessionManager::saveSessions(KConfig* config)
 734 {
 735     // The session IDs can't be restored.
 736     // So we need to map the old ID to the future new ID.
 737     int n = 1;
 738     _restoreMapping.clear();
 739
 740     foreach(Session* session, _sessions)
 741     {
 742         QString name = QLatin1String("Session") + QString::number(n);
 743         KConfigGroup group(config, name);
 744
 745         group.writePathEntry("Profile",
 746                              _sessionProfiles.value(session)->path());
 747         session->saveSession(group);
 748         _restoreMapping.insert(session, n);
 749         n++;
 750     }
 751
 752     KConfigGroup group(config, "Number");
 753     group.writeEntry("NumberOfSessions", _sessions.count());
 754 }
 755
 756 int SessionManager::getRestoreId(Session* session)
 757 {
 758     return _restoreMapping.value(session);
 759 }
 760
 761 void SessionManager::restoreSessions(KConfig* config)
 762 {
 763     KConfigGroup group(config, "Number");
 764     int sessions;
 765
 766     // Any sessions saved?
 767     if ((sessions = group.readEntry("NumberOfSessions", 0)) > 0)
 768     {
 769         for (int n = 1; n <= sessions; n++)
 770         {
 771             QString name = QLatin1String("Session") + QString::number(n);
 772             KConfigGroup sessionGroup(config, name);
 773
 774             QString profile = sessionGroup.readPathEntry("Profile", QString());
 775             Profile::Ptr ptr = defaultProfile();
 776             if (!profile.isEmpty()) ptr = loadProfile(profile);
 777
 778             Session* session = createSession(ptr);
 779             session->restoreSession(sessionGroup);
 780         }
 781     }
 782 }
 783
 784 Session* SessionManager::idToSession(int id)
 785 {
 786     Q_ASSERT(id);
 787     foreach(Session* session, _sessions)
 788         if (session->sessionId() == id)
 789             return session;
 790
 791     // this should not happen
 792     Q_ASSERT(0);
 793     return 0;
 794 }
 795
 796 K_GLOBAL_STATIC( SessionManager , theSessionManager )
 797 SessionManager* SessionManager::instance()
 798 {
 799     return theSessionManager;
 800 }
 801
 802 SessionListModel::SessionListModel(QObject* parent)
 803 : QAbstractListModel(parent)
 804 {
 805 }
 806
 807 void SessionListModel::setSessions(const QList<Session*>& sessions)
 808 {
 809     _sessions = sessions;
 810
 811     foreach(Session* session, sessions)
 812         connect(session,SIGNAL(finished()),this,SLOT(sessionFinished()));
 813
 814     reset();
 815 }
 816 QVariant SessionListModel::data(const QModelIndex& index, int role) const
 817 {
 818     Q_ASSERT(index.isValid());
 819
 820     int row = index.row();
 821     int column = index.column();
 822
 823     Q_ASSERT( row >= 0 && row < _sessions.count() );
 824     Q_ASSERT( column >= 0 && column < 2 );
 825
 826     switch (role)
 827     {
 828         case Qt::DisplayRole:
 829             if (column == 1)
 830                 return _sessions[row]->title(Session::DisplayedTitleRole);
 831             else if (column == 0)
 832                 return _sessions[row]->sessionId();
 833             break;
 834         case Qt::DecorationRole:
 835             if (column == 1)
 836                 return KIcon(_sessions[row]->iconName());
 837             else
 838                 return QVariant();
 839     }
 840
 841     return QVariant();
 842 }
 843 QVariant SessionListModel::headerData(int section, Qt::Orientation orientation,
 844                         int role) const
 845 {
 846     if (role != Qt::DisplayRole)
 847         return QVariant();
 848
 849     if (orientation == Qt::Vertical)
 850         return QVariant();
 851     else
 852     {
 853         switch (section)
 854         {
 855             case 0:
 856                 return i18n("Number");
 857             case 1:
 858                 return i18n("Title");
 859             default:
 860                 return QVariant();
 861         }
 862     }
 863 }
 864
 865 int SessionListModel::columnCount(const QModelIndex&) const
 866 {
 867     return 2;
 868 }
 869 int SessionListModel::rowCount(const QModelIndex&) const
 870 {
 871     return _sessions.count();
 872 }
 873 QModelIndex SessionListModel::parent(const QModelIndex&) const
 874 {
 875     return QModelIndex();
 876 }
 877 void SessionListModel::sessionFinished()
 878 {
 879     Session* session = qobject_cast<Session*>(sender());
 880     int row = _sessions.indexOf(session);
 881
 882     if (row != -1)
 883     {
 884         beginRemoveRows(QModelIndex(),row,row);
 885         sessionRemoved(session);
 886         _sessions.removeAt(row);
 887         endRemoveRows();
 888     }
 889 }
 890 QModelIndex SessionListModel::index(int row, int column, const QModelIndex& parent) const
 891 {
 892     if (hasIndex(row,column,parent))
 893         return createIndex(row,column,_sessions[row]);
 894     else
 895         return QModelIndex();
 896 }
 897
 898 #include "SessionManager.moc"
 899
 900 /*
 901   Local Variables:
 902   mode: c++
 903   c-file-style: "stroustrup"
 904   indent-tabs-mode: nil
 905   tab-width: 4
 906   End:
 907 */