workspace/plasma/applets/kickoff/core/favoritesmodel.cpp

   1 /*
   2     Copyright 2007 Robert Knight <robertknight@gmail.com>
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Library General Public
   6     License as published by the Free Software Foundation; either
   7     version 2 of the License, or (at your option) any later version.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Library General Public License for more details.
  13
  14     You should have received a copy of the GNU Library General Public License
  15     along with this library; see the file COPYING.LIB.  If not, write to
  16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17     Boston, MA 02110-1301, USA.
  18 */
  19
  20 //Own
  21 #include "core/favoritesmodel.h"
  22
  23 // Qt
  24 #include <QHash>
  25 #include <QList>
  26
  27 // KDE
  28 #include <KConfigGroup>
  29 #include <KService>
  30 #include <kdebug.h>
  31
  32 // Local
  33 #include "core/models.h"
  34
  35 using namespace Kickoff;
  36
  37 class FavoritesModel::Private
  38 {
  39 public:
  40     Private(FavoritesModel *parent)
  41         :q(parent)
  42     {
  43         headerItem = new QStandardItem(i18n("Favorites"));
  44         q->appendRow(headerItem);
  45     }
  46
  47     void addFavoriteItem(const QString& url)
  48     {
  49         QStandardItem *item = StandardItemFactory::createItemForUrl(url);
  50         headerItem->appendRow(item);
  51     }
  52     void removeFavoriteItem(const QString& url)
  53     {
  54        QModelIndexList matches = q->match(q->index(0,0),UrlRole,
  55                                           url,-1,
  56                                           Qt::MatchFlags(Qt::MatchStartsWith | Qt::MatchWrap | Qt::MatchRecursive));
  57
  58        kDebug() << "Removing item matches" << matches;
  59
  60        foreach(const QModelIndex& index,matches) {
  61          QStandardItem *item = q->itemFromIndex(index);
  62          if (item->parent()) {
  63             item->parent()->removeRow(item->row());
  64          } else {
  65             qDeleteAll(q->takeRow(item->row()));
  66          }
  67        }
  68     }
  69
  70     FavoritesModel * const q;
  71     QStandardItem *headerItem;
  72
  73     static void loadFavorites()
  74     {
  75        KConfigGroup favoritesGroup = componentData().config()->group("Favorites");
  76        QList<QString> favoriteList = favoritesGroup.readEntry("FavoriteURLs",QList<QString>());
  77        if (favoriteList.isEmpty()) {
  78            favoriteList = defaultFavorites();
  79        }
  80
  81        foreach(QString favorite,favoriteList) {
  82            FavoritesModel::add(favorite);
  83        }
  84     }
  85     static QList<QString> defaultFavorites()
  86     {
  87         QList<QString> applications;
  88         applications << "konqbrowser" << "kmail" << "systemsettings" << "dolphin";
  89
  90         QList<QString> desktopFiles;
  91
  92         foreach(const QString& application,applications) {
  93             KService::Ptr service = KService::serviceByStorageId("kde4-" + application + ".desktop");
  94             if (service) {
  95                 desktopFiles << service->entryPath();
  96             }
  97         }
  98
  99         return desktopFiles;
 100     }
 101     static void saveFavorites()
 102     {
 103         KConfigGroup favoritesGroup = componentData().config()->group("Favorites");
 104         favoritesGroup.writeEntry("FavoriteURLs",globalFavoriteList);
 105         favoritesGroup.config()->sync();
 106     }
 107     static QList<QString> globalFavoriteList;
 108     static QSet<QString> globalFavoriteSet;
 109     static QSet<FavoritesModel*> models;
 110 };
 111
 112 QList<QString> FavoritesModel::Private::globalFavoriteList;
 113 QSet<QString> FavoritesModel::Private::globalFavoriteSet;
 114 QSet<FavoritesModel*> FavoritesModel::Private::models;
 115
 116 FavoritesModel::FavoritesModel(QObject *parent)
 117     : KickoffModel(parent)
 118     , d(new Private(this))
 119 {
 120     Private::models << this;
 121     if (Private::models.count() == 1 && Private::globalFavoriteList.isEmpty()) {
 122         Private::loadFavorites();
 123     } else {
 124         foreach (QString url, Private::globalFavoriteList) {
 125             d->addFavoriteItem(url);
 126         }
 127     }
 128 }
 129 FavoritesModel::~FavoritesModel()
 130 {
 131     Private::models.remove(this);
 132
 133     if (Private::models.isEmpty()) {
 134         Private::saveFavorites();
 135     }
 136
 137     delete d;
 138 }
 139 void FavoritesModel::add(const QString& url)
 140 {
 141     Private::globalFavoriteList << url;
 142     Private::globalFavoriteSet << url;
 143
 144     foreach(FavoritesModel* model,Private::models) {
 145         model->d->addFavoriteItem(url);
 146     }
 147
 148     // save after each add in case we crash
 149     Private::saveFavorites();
 150 }
 151 void FavoritesModel::remove(const QString& url)
 152 {
 153    Private::globalFavoriteList.removeAll(url);
 154    Private::globalFavoriteSet.remove(url);
 155
 156    foreach(FavoritesModel* model,Private::models) {
 157        model->d->removeFavoriteItem(url);
 158    }
 159
 160     // save after each remove in case of crash or other mishaps
 161     Private::saveFavorites();
 162 }
 163 bool FavoritesModel::isFavorite(const QString& url)
 164 {
 165     return Private::globalFavoriteSet.contains(url);
 166 }
 167
 168 #include "favoritesmodel.moc"