kfile/kfileplacesitem.cpp

   1 /*  This file is part of the KDE project
   2     Copyright (C) 2007 Kevin Ottens <ervin@kde.org>
   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 version 2 as published by the Free Software Foundation.
   7
   8     This library is distributed in the hope that it will be useful,
   9     but WITHOUT ANY WARRANTY; without even the implied warranty of
  10     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11     Library General Public License for more details.
  12
  13     You should have received a copy of the GNU Library General Public License
  14     along with this library; see the file COPYING.LIB.  If not, write to
  15     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  16     Boston, MA 02110-1301, USA.
  17
  18 */
  19
  20 #include "kfileplacesitem_p.h"
  21 #include "kfileplacesmodel.h"
  22
  23 #include <QtCore/QDateTime>
  24
  25 #include <kbookmarkmanager.h>
  26 #include <kiconloader.h>
  27 #include <kdirlister.h>
  28 #include <solid/opticaldisc.h>
  29 #include <solid/storageaccess.h>
  30 #include <solid/storagevolume.h>
  31
  32
  33 KFilePlacesItem::KFilePlacesItem(KBookmarkManager *manager,
  34                                  const QString &address,
  35                                  const QString &udi)
  36     : m_manager(manager), m_lister(0), m_folderIsEmpty(true)
  37 {
  38     m_bookmark = m_manager->findByAddress(address);
  39
  40     if (udi.isEmpty() && m_bookmark.metaDataItem("ID").isEmpty()) {
  41         m_bookmark.setMetaDataItem("ID", generateNewId());
  42     } else if (udi.isEmpty()) {
  43         if (hasFullIcon(m_bookmark)) {
  44             // TODO if this is only for the trash, it would be much faster to just read trashrc
  45             m_lister = new KDirLister(this);
  46             m_lister->setAutoErrorHandlingEnabled(false, 0); // don't bother the user if trash:/ doesn't exist
  47             m_lister->setDelayedMimeTypes(true); // we don't need the mimetypes, so don't penalize other KDirLister users
  48             connect(m_lister, SIGNAL(completed()),
  49                     this, SLOT(onListerCompleted()));
  50             m_lister->openUrl(m_bookmark.url());
  51         }
  52     } else if (!udi.isEmpty()) {
  53         Solid::Device dev(udi);
  54         Solid::StorageAccess *access = dev.as<Solid::StorageAccess>();
  55         if (access!=0) {
  56             connect(access, SIGNAL(accessibilityChanged(bool, const QString &)),
  57                     this, SLOT(onAccessibilityChanged()));
  58         }
  59     }
  60 }
  61
  62 KFilePlacesItem::~KFilePlacesItem()
  63 {
  64 }
  65
  66 QString KFilePlacesItem::id() const
  67 {
  68     if (isDevice()) {
  69         return bookmark().metaDataItem("UDI");
  70     } else {
  71         return bookmark().metaDataItem("ID");
  72     }
  73 }
  74
  75 bool KFilePlacesItem::isDevice() const
  76 {
  77     return !bookmark().metaDataItem("UDI").isEmpty();
  78 }
  79
  80 KBookmark KFilePlacesItem::bookmark() const
  81 {
  82     return m_bookmark;
  83 }
  84
  85 void KFilePlacesItem::setBookmark(const KBookmark &bookmark)
  86 {
  87     m_bookmark = bookmark;
  88 }
  89
  90 Solid::Device KFilePlacesItem::device() const
  91 {
  92     return Solid::Device(bookmark().metaDataItem("UDI"));
  93 }
  94
  95 QVariant KFilePlacesItem::data(int role) const
  96 {
  97     QVariant returnData;
  98
  99     if (role!=KFilePlacesModel::HiddenRole && role!=Qt::BackgroundRole && isDevice()) {
 100         returnData = deviceData(role);
 101     } else {
 102         returnData = bookmarkData(role);
 103     }
 104
 105     return returnData;
 106 }
 107
 108 QVariant KFilePlacesItem::bookmarkData(int role) const
 109 {
 110     KBookmark b = bookmark();
 111
 112     if (b.isNull()) return QVariant();
 113
 114     switch (role)
 115     {
 116     case Qt::DisplayRole:
 117         return b.text();
 118     case Qt::DecorationRole:
 119         return KIcon(iconNameForBookmark(b));
 120     case Qt::BackgroundRole:
 121         if (b.metaDataItem("IsHidden")=="true") {
 122             return Qt::lightGray;
 123         } else {
 124             return QVariant();
 125         }
 126     case KFilePlacesModel::UrlRole:
 127         return QUrl(b.url());
 128     case KFilePlacesModel::SetupNeededRole:
 129         return false;
 130     case KFilePlacesModel::HiddenRole:
 131         return b.metaDataItem("IsHidden")=="true";
 132     default:
 133         return QVariant();
 134     }
 135 }
 136
 137 QVariant KFilePlacesItem::deviceData(int role) const
 138 {
 139     Solid::Device d = device();
 140
 141     if (d.isValid()) {
 142         const Solid::StorageAccess *access = d.as<Solid::StorageAccess>();
 143         const Solid::StorageVolume *volume = d.as<Solid::StorageVolume>();
 144         const Solid::OpticalDisc *disc = d.as<Solid::OpticalDisc>();
 145         QStringList overlays;
 146
 147         switch (role)
 148         {
 149         case Qt::DisplayRole:
 150             return d.product();
 151         case Qt::DecorationRole:
 152             if (access && access->isAccessible()) {
 153                 overlays << "emblem-mounted";
 154             } else {
 155                 overlays << QString(); // We have to guarantee the placement of the next emblem
 156             }
 157             if (volume && volume->usage()==Solid::StorageVolume::Encrypted) {
 158                 overlays << "security-high";
 159             }
 160             return KIcon(d.icon(), 0, overlays);
 161         case KFilePlacesModel::UrlRole:
 162             if (access) {
 163                 return QUrl(KUrl(access->filePath()));
 164             } else if (disc && (disc->availableContent() & Solid::OpticalDisc::Audio)!=0) {
 165                 return QUrl("audiocd:/");
 166             } else {
 167                 return QVariant();
 168             }
 169         case KFilePlacesModel::SetupNeededRole:
 170             if (access) {
 171                 return !access->isAccessible();
 172             } else {
 173                 return QVariant();
 174             }
 175         default:
 176             return QVariant();
 177         }
 178     } else {
 179         return QVariant();
 180     }
 181 }
 182
 183 KBookmark KFilePlacesItem::createBookmark(KBookmarkManager *manager,
 184                                           const QString &label,
 185                                           const KUrl &url,
 186                                           const QString &iconName)
 187 {
 188     KBookmarkGroup root = manager->root();
 189     if (root.isNull())
 190         return KBookmark();
 191     QString empty_icon = iconName;
 192     if (url==KUrl("trash:/")) {
 193         if (empty_icon.endsWith("-full")) {
 194             empty_icon.chop(5);
 195         } else if (empty_icon.isEmpty()) {
 196             empty_icon = "user-trash";
 197         }
 198     }
 199     KBookmark bookmark = root.addBookmark(label, url, empty_icon);
 200     bookmark.setMetaDataItem("ID", generateNewId());
 201
 202     return bookmark;
 203 }
 204
 205 KBookmark KFilePlacesItem::createSystemBookmark(KBookmarkManager *manager,
 206                                           const QString &label,
 207                                           const KUrl &url,
 208                                           const QString &iconName)
 209 {
 210     KBookmark bookmark = createBookmark(manager, label, url, iconName);
 211     if (!bookmark.isNull())
 212         bookmark.setMetaDataItem("isSystemItem", "true");
 213     return bookmark;
 214 }
 215
 216
 217 KBookmark KFilePlacesItem::createDeviceBookmark(KBookmarkManager *manager,
 218                                                 const QString &udi)
 219 {
 220     KBookmarkGroup root = manager->root();
 221     if (root.isNull())
 222         return KBookmark();
 223     KBookmark bookmark = root.createNewSeparator();
 224     bookmark.setMetaDataItem("UDI", udi);
 225     bookmark.setMetaDataItem("isSystemItem", "true");
 226     return bookmark;
 227 }
 228
 229 QString KFilePlacesItem::generateNewId()
 230 {
 231     static int count = 0;
 232
 233 //    return QString::number(count++);
 234
 235     return QString::number(QDateTime::currentDateTime().toTime_t())
 236       + '/' + QString::number(count++);
 237
 238
 239 //    return QString::number(QDateTime::currentDateTime().toTime_t())
 240 //         + '/' + QString::number(qrand());
 241 }
 242
 243 void KFilePlacesItem::onAccessibilityChanged()
 244 {
 245     emit itemChanged(id());
 246 }
 247
 248 bool KFilePlacesItem::hasFullIcon(const KBookmark &bookmark) const
 249 {
 250     return bookmark.url()==KUrl("trash:/");
 251 }
 252
 253 QString KFilePlacesItem::iconNameForBookmark(const KBookmark &bookmark) const
 254 {
 255     if (!m_folderIsEmpty && hasFullIcon(bookmark)) {
 256         return bookmark.icon()+"-full";
 257     } else {
 258         return bookmark.icon();
 259     }
 260 }
 261
 262 void KFilePlacesItem::onListerCompleted()
 263 {
 264     m_folderIsEmpty = m_lister->items().isEmpty();
 265     emit itemChanged(id());
 266 }
 267
 268 #include "kfileplacesitem_p.moc"