kalarm/itemlistmodel.cpp

   1 /*
   2  *  itemlistmodel.cpp  -  Akonadi item models
   3  *  Program:  kalarm
   4  *  Copyright © 2007-2011 by David Jarvie <djarvie@kde.org>
   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 along
  17  *  with this program; if not, write to the Free Software Foundation, Inc.,
  18  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "itemlistmodel.h"
  22 #include "collectionmodel.h"
  23 #include "kaevent.h"
  24
  25 #include <kselectionproxymodel.h>
  26
  27 using namespace Akonadi;
  28
  29
  30 /*=============================================================================
  31 = Class: ItemListModel
  32 = Filter proxy model containing all items (alarms/templates) of specified mime
  33 = types in enabled collections.
  34 =============================================================================*/
  35 ItemListModel::ItemListModel(KAlarm::CalEvent::Types allowed, QObject* parent)
  36     : EntityMimeTypeFilterModel(parent),
  37       mAllowedTypes(allowed),
  38       mHaveEvents(false)
  39 {
  40     KSelectionProxyModel* selectionModel = new KSelectionProxyModel(CollectionControlModel::instance()->selectionModel(), this);
  41     selectionModel->setSourceModel(AkonadiModel::instance());
  42     selectionModel->setFilterBehavior(KSelectionProxyModel::ChildrenOfExactSelection);
  43     setSourceModel(selectionModel);
  44
  45     addMimeTypeExclusionFilter(Collection::mimeType());
  46     setHeaderGroup(EntityTreeModel::ItemListHeaders);
  47     if (allowed)
  48     {
  49         QStringList mimeTypes = KAlarm::CalEvent::mimeTypes(allowed);
  50         foreach (const QString& mime, mimeTypes)
  51             addMimeTypeInclusionFilter(mime);
  52     }
  53     setHeaderGroup(EntityTreeModel::ItemListHeaders);
  54     setSortRole(AkonadiModel::SortRole);
  55     setDynamicSortFilter(true);
  56     connect(this, SIGNAL(rowsInserted(const QModelIndex&, int, int)), SLOT(slotRowsInserted()));
  57     connect(this, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), SLOT(slotRowsRemoved()));
  58 }
  59
  60 int ItemListModel::columnCount(const QModelIndex& /*parent*/) const
  61 {
  62     return AkonadiModel::ColumnCount;
  63 }
  64
  65 /******************************************************************************
  66 * Called when rows have been inserted into the model.
  67 */
  68 void ItemListModel::slotRowsInserted()
  69 {
  70     if (!mHaveEvents  &&  rowCount())
  71     {
  72         mHaveEvents = true;
  73         emit haveEventsStatus(true);
  74     }
  75 }
  76
  77 /******************************************************************************
  78 * Called when rows have been deleted from the model.
  79 */
  80 void ItemListModel::slotRowsRemoved()
  81 {
  82     if (mHaveEvents  &&  !rowCount())
  83     {
  84         mHaveEvents = false;
  85         emit haveEventsStatus(false);
  86     }
  87 }
  88
  89 #if 0
  90 QModelIndex ItemListModel::index(int row, int column, const QModelIndex& parent) const
  91 {
  92     if (parent.isValid())
  93         return QModelIndex();
  94     return createIndex(row, column, mEvents[row]);
  95 }
  96
  97 bool ItemListModel::setData(const QModelIndex& ix, const QVariant&, int role)
  98 {
  99     if (ix.isValid()  &&  role == Qt::EditRole)
 100     {
 101 //??? update event
 102         int row = ix.row();
 103         emit dataChanged(index(row, 0), index(row, AkonadiModel::ColumnCount - 1));
 104         return true;
 105     }
 106     return false;
 107 }
 108 #endif
 109
 110 Qt::ItemFlags ItemListModel::flags(const QModelIndex& index) const
 111 {
 112     if (!index.isValid())
 113         return Qt::ItemIsEnabled;
 114     return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled;
 115 }
 116
 117 /******************************************************************************
 118 * Return the index to a specified event.
 119 */
 120 QModelIndex ItemListModel::eventIndex(Entity::Id itemId) const
 121 {
 122     QModelIndexList list = match(QModelIndex(), AkonadiModel::ItemIdRole, itemId, 1, Qt::MatchExactly | Qt::MatchRecursive);
 123     if (list.isEmpty())
 124         return QModelIndex();
 125     return index(list[0].row(), 0, list[0].parent());
 126 }
 127
 128 /******************************************************************************
 129 * Return the event in a specified row.
 130 */
 131 KAEvent ItemListModel::event(int row) const
 132 {
 133     return event(index(row, 0));
 134 }
 135
 136 /******************************************************************************
 137 * Return the event referred to by an index.
 138 */
 139 KAEvent ItemListModel::event(const QModelIndex& index) const
 140 {
 141     return static_cast<AkonadiModel*>(sourceModel())->event(mapToSource(index));
 142 }
 143
 144 /******************************************************************************
 145 * Check whether the model contains any events.
 146 */
 147 bool ItemListModel::haveEvents() const
 148 {
 149     return rowCount();
 150 }
 151
 152
 153 /*=============================================================================
 154 = Class: AlarmListModel
 155 = Filter proxy model containing all alarms of specified mime types in enabled
 156 = collections.
 157 Equivalent to AlarmListFilterModel
 158 =============================================================================*/
 159 AlarmListModel* AlarmListModel::mAllInstance = 0;
 160
 161 AlarmListModel::AlarmListModel(QObject* parent)
 162     : ItemListModel(KAlarm::CalEvent::ACTIVE | KAlarm::CalEvent::ARCHIVED, parent),
 163       mFilterTypes(KAlarm::CalEvent::ACTIVE | KAlarm::CalEvent::ARCHIVED)
 164 {
 165 }
 166
 167 AlarmListModel::~AlarmListModel()
 168 {
 169     if (this == mAllInstance)
 170         mAllInstance = 0;
 171 }
 172
 173 AlarmListModel* AlarmListModel::all()
 174 {
 175     if (!mAllInstance)
 176     {
 177         mAllInstance = new AlarmListModel(AkonadiModel::instance());
 178         mAllInstance->sort(TimeColumn, Qt::AscendingOrder);
 179     }
 180     return mAllInstance;
 181 }
 182
 183 void AlarmListModel::setEventTypeFilter(KAlarm::CalEvent::Types types)
 184 {
 185     // Ensure that the filter isn't applied to the 'all' instance, and that
 186     // 'types' doesn't include any disallowed alarm types
 187     if (!types)
 188         types = includedTypes();
 189     if (this != mAllInstance
 190     &&  types != mFilterTypes  &&  (types & includedTypes()) == types)
 191     {
 192         mFilterTypes = types;
 193         invalidateFilter();
 194     }
 195 }
 196
 197 bool AlarmListModel::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const
 198 {
 199     if (!ItemListModel::filterAcceptsRow(sourceRow, sourceParent))
 200         return false;
 201     if (mFilterTypes == KAlarm::CalEvent::EMPTY)
 202         return false;
 203     int type = sourceModel()->data(sourceModel()->index(sourceRow, 0, sourceParent), AkonadiModel::StatusRole).toInt();
 204     return static_cast<KAlarm::CalEvent::Type>(type) & mFilterTypes;
 205 }
 206
 207 bool AlarmListModel::filterAcceptsColumn(int sourceCol, const QModelIndex&) const
 208 {
 209     return (sourceCol != AkonadiModel::TemplateNameColumn);
 210 }
 211
 212 QVariant AlarmListModel::headerData(int section, Qt::Orientation orientation, int role) const
 213 {
 214     if (orientation == Qt::Horizontal)
 215     {
 216         if (section < 0  ||  section >= ColumnCount)
 217             return QVariant();
 218     }
 219     return ItemListModel::headerData(section, orientation, role);
 220 }
 221
 222
 223 /*=============================================================================
 224 = Class: TemplateListModel
 225 = Filter proxy model containing all alarm templates for specified alarm types
 226 = in enabled collections.
 227 Equivalent to TemplateListFilterModel
 228 =============================================================================*/
 229 TemplateListModel* TemplateListModel::mAllInstance = 0;
 230
 231 TemplateListModel::TemplateListModel(QObject* parent)
 232     : ItemListModel(KAlarm::CalEvent::TEMPLATE, parent),
 233       mActionsEnabled(KAEvent::ACT_ALL),
 234       mActionsFilter(KAEvent::ACT_ALL)
 235 {
 236 }
 237
 238 TemplateListModel::~TemplateListModel()
 239 {
 240     if (this == mAllInstance)
 241         mAllInstance = 0;
 242 }
 243
 244 TemplateListModel* TemplateListModel::all()
 245 {
 246     if (!mAllInstance)
 247     {
 248         mAllInstance = new TemplateListModel(AkonadiModel::instance());
 249         mAllInstance->sort(TemplateNameColumn, Qt::AscendingOrder);
 250     }
 251     return mAllInstance;
 252 }
 253
 254 void TemplateListModel::setAlarmActionFilter(KAEvent::Actions types)
 255 {
 256     // Ensure that the filter isn't applied to the 'all' instance.
 257     if (this != mAllInstance  &&  types != mActionsFilter)
 258     {
 259         mActionsFilter = types;
 260         filterChanged();
 261     }
 262 }
 263
 264 void TemplateListModel::setAlarmActionsEnabled(KAEvent::Actions types)
 265 {
 266     // Ensure that the setting isn't applied to the 'all' instance.
 267     if (this != mAllInstance  &&  types != mActionsEnabled)
 268     {
 269         mActionsEnabled = types;
 270         filterChanged();
 271     }
 272 }
 273
 274 bool TemplateListModel::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const
 275 {
 276     if (!ItemListModel::filterAcceptsRow(sourceRow, sourceParent))
 277         return false;
 278     if (mActionsFilter == KAEvent::ACT_ALL)
 279         return true;
 280     QModelIndex sourceIndex = sourceModel()->index(sourceRow, 0, sourceParent);
 281     KAEvent::Actions actions = static_cast<KAEvent::Actions>(sourceModel()->data(sourceIndex, AkonadiModel::AlarmActionsRole).toInt());
 282     return actions & mActionsFilter;
 283 }
 284
 285 bool TemplateListModel::filterAcceptsColumn(int sourceCol, const QModelIndex&) const
 286 {
 287     return sourceCol == AkonadiModel::TemplateNameColumn
 288        ||  sourceCol == AkonadiModel::TypeColumn;
 289 }
 290
 291 QVariant TemplateListModel::headerData(int section, Qt::Orientation orientation, int role) const
 292 {
 293     if (orientation == Qt::Horizontal)
 294     {
 295         switch (section)
 296         {
 297             case TypeColumn:
 298                 section = AkonadiModel::TypeColumn;
 299                 break;
 300             case TemplateNameColumn:
 301                 section = AkonadiModel::TemplateNameColumn;
 302                 break;
 303             default:
 304                 return QVariant();
 305         }
 306     }
 307     return ItemListModel::headerData(section, orientation, role);
 308 }
 309
 310 Qt::ItemFlags TemplateListModel::flags(const QModelIndex& index) const
 311 {
 312     Qt::ItemFlags f = sourceModel()->flags(mapToSource(index));
 313     if (mActionsEnabled == KAEvent::ACT_ALL)
 314         return f;
 315     KAEvent::Actions actions = static_cast<KAEvent::Actions>(ItemListModel::data(index, AkonadiModel::AlarmActionsRole).toInt());
 316     if (!(actions & mActionsEnabled))
 317         f = static_cast<Qt::ItemFlags>(f & ~(Qt::ItemIsEnabled | Qt::ItemIsSelectable));
 318     return f;
 319 }
 320
 321 // vim: et sw=4: