• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • graphics API Reference
  • KDE Home
  • Contact Us
 

digikam

  • extragear
  • graphics
  • digikam
  • core
  • utilities
  • import
  • models
importfiltermodel.cpp
Go to the documentation of this file.
1 /* ============================================================
2  *
3  * This file is a part of digiKam project
4  * https://www.digikam.org
5  *
6  * Date : 2012-21-06
7  * Description : Qt filter model for import items
8  *
9  * Copyright (C) 2012 by Islam Wazery <wazery at ubuntu dot com>
10  *
11  * This program is free software; you can redistribute it
12  * and/or modify it under the terms of the GNU General
13  * Public License as published by the Free Software Foundation;
14  * either version 2, or (at your option)
15  * any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * ============================================================ */
23 
24 #include "importfiltermodel.h"
25 
26 // Local includes
27 
28 #include "camiteminfo.h"
29 #include "filter.h"
30 #include "importimagemodel.h"
31 
32 namespace Digikam
33 {
34 
35 ImportSortFilterModel::ImportSortFilterModel(QObject* const parent)
36  : DCategorizedSortFilterProxyModel(parent),
37  m_chainedModel(nullptr)
38 {
39 }
40 
41 ImportSortFilterModel::~ImportSortFilterModel()
42 {
43 }
44 
45 void ImportSortFilterModel::setSourceImportModel(ImportItemModel* const sourceModel)
46 {
47  if (m_chainedModel)
48  {
49  m_chainedModel->setSourceImportModel(sourceModel);
50  }
51  else
52  {
53  setDirectSourceImportModel(sourceModel);
54  }
55 }
56 
57 ImportItemModel* ImportSortFilterModel::sourceImportModel() const
58 {
59  if (m_chainedModel)
60  {
61  return m_chainedModel->sourceImportModel();
62  }
63 
64  return static_cast<ImportItemModel*>(sourceModel());
65 }
66 
67 void ImportSortFilterModel::setSourceFilterModel(ImportSortFilterModel* const sourceModel)
68 {
69  if (sourceModel)
70  {
71  ImportItemModel* const model = sourceImportModel();
72 
73  if (model)
74  {
75  sourceModel->setSourceImportModel(model);
76  }
77  }
78 
79  m_chainedModel = sourceModel;
80  setSourceModel(sourceModel);
81 }
82 
83 ImportSortFilterModel* ImportSortFilterModel::sourceFilterModel() const
84 {
85  return m_chainedModel;
86 }
87 
88 QModelIndex ImportSortFilterModel::mapToSourceImportModel(const QModelIndex& proxyIndex) const
89 {
90  if (!proxyIndex.isValid())
91  {
92  return QModelIndex();
93  }
94 
95  if (m_chainedModel)
96  {
97  return m_chainedModel->mapToSourceImportModel(mapToSource(proxyIndex));
98  }
99 
100  return mapToSource(proxyIndex);
101 }
102 
103 QModelIndex ImportSortFilterModel::mapFromSourceImportModel(const QModelIndex& importModelIndex) const
104 {
105  if (!importModelIndex.isValid())
106  {
107  return QModelIndex();
108  }
109 
110  if (m_chainedModel)
111  {
112  return mapFromSource(m_chainedModel->mapFromSourceImportModel(importModelIndex));
113  }
114 
115  return mapFromSource(importModelIndex);
116 }
117 
118 QModelIndex ImportSortFilterModel::mapFromDirectSourceToSourceImportModel(const QModelIndex& sourceModelIndex) const
119 {
120  if (!sourceModelIndex.isValid())
121  {
122  return QModelIndex();
123  }
124 
125  if (m_chainedModel)
126  {
127  return m_chainedModel->mapToSourceImportModel(sourceModelIndex);
128  }
129 
130  return sourceModelIndex;
131 }
132 
133 QList<QModelIndex> ImportSortFilterModel::mapListToSource(const QList<QModelIndex>& indexes) const
134 {
135  QList<QModelIndex> sourceIndexes;
136 
137  foreach (const QModelIndex& index, indexes)
138  {
139  sourceIndexes << mapToSourceImportModel(index);
140  }
141 
142  return sourceIndexes;
143 }
144 
145 QList<QModelIndex> ImportSortFilterModel::mapListFromSource(const QList<QModelIndex>& sourceIndexes) const
146 {
147  QList<QModelIndex> indexes;
148 
149  foreach (const QModelIndex& index, sourceIndexes)
150  {
151  indexes << mapFromSourceImportModel(index);
152  }
153 
154  return indexes;
155 }
156 
157 CamItemInfo ImportSortFilterModel::camItemInfo(const QModelIndex& index) const
158 {
159  return sourceImportModel()->camItemInfo(mapToSourceImportModel(index));
160 }
161 
162 qlonglong ImportSortFilterModel::camItemId(const QModelIndex& index) const
163 {
164  return sourceImportModel()->camItemId(mapToSourceImportModel(index));
165 }
166 
167 QList<CamItemInfo> ImportSortFilterModel::camItemInfos(const QList<QModelIndex>& indexes) const
168 {
169  QList<CamItemInfo> infos;
170 
171  foreach (const QModelIndex& index, indexes)
172  {
173  infos << camItemInfo(index);
174  }
175 
176  return infos;
177 }
178 
179 QList<qlonglong> ImportSortFilterModel::camItemIds(const QList<QModelIndex>& indexes) const
180 {
181  QList<qlonglong> ids;
182 
183  foreach (const QModelIndex& index, indexes)
184  {
185  ids << camItemId(index);
186  }
187 
188  return ids;
189 }
190 
191 QModelIndex ImportSortFilterModel::indexForPath(const QString& filePath) const
192 {
193  QUrl fileUrl = QUrl::fromLocalFile(filePath);
194  return mapFromSourceImportModel(sourceImportModel()->indexForUrl(fileUrl));
195 }
196 
197 QModelIndex ImportSortFilterModel::indexForCamItemInfo(const CamItemInfo& info) const
198 {
199  return mapFromSourceImportModel(sourceImportModel()->indexForCamItemInfo(info));
200 }
201 
202 QModelIndex ImportSortFilterModel::indexForCamItemId(qlonglong id) const
203 {
204  return mapFromSourceImportModel(sourceImportModel()->indexForCamItemId(id));
205 }
206 
207 QList<CamItemInfo> ImportSortFilterModel::camItemInfosSorted() const
208 {
209  QList<CamItemInfo> infos;
210  const int size = rowCount();
211 
212  for (int i = 0 ; i < size ; ++i)
213  {
214  infos << camItemInfo(index(i, 0));
215  }
216 
217  return infos;
218 }
219 
220 ImportFilterModel* ImportSortFilterModel::importFilterModel() const
221 {
222  if (m_chainedModel)
223  {
224  return m_chainedModel->importFilterModel();
225  }
226 
227  return nullptr;
228 }
229 
230 void ImportSortFilterModel::setSourceModel(QAbstractItemModel* sourceModel)
231 {
232  DCategorizedSortFilterProxyModel::setSourceModel(sourceModel);
233 }
234 
235 void ImportSortFilterModel::setDirectSourceImportModel(ImportItemModel* const sourceModel)
236 {
237  setSourceModel(sourceModel);
238 }
239 
240 //--- ImportFilterModel methods ---------------------------------
241 
242 class Q_DECL_HIDDEN ImportFilterModel::ImportFilterModelPrivate : public QObject
243 {
244 
245 public:
246 
247  ImportFilterModelPrivate()
248  {
249  q = nullptr;
250  importItemModel = nullptr;
251  filter = nullptr;
252  }
253 
254  void init(ImportFilterModel* const _q);
255 
256 Q_SIGNALS:
257 
258  void reAddCamItemInfos(const QList<CamItemInfo>&);
259  void reAddingFinished();
260 
261 public:
262 
263  ImportFilterModel* q;
264  ImportItemModel* importItemModel;
265  CamItemSortSettings sorter;
266  Filter* filter;
267 };
268 
269 void ImportFilterModel::ImportFilterModelPrivate::init(ImportFilterModel* const _q)
270 {
271  q = _q;
272 }
273 
274 ImportFilterModel::ImportFilterModel(QObject* const parent)
275  : ImportSortFilterModel(parent),
276  d_ptr(new ImportFilterModelPrivate)
277 {
278  d_ptr->init(this);
279 }
280 
281 ImportFilterModel::~ImportFilterModel()
282 {
283  Q_D(ImportFilterModel);
284  delete d;
285 }
286 
287 QVariant ImportFilterModel::data(const QModelIndex& index, int role) const
288 {
289  Q_D(const ImportFilterModel);
290 
291  if (!index.isValid())
292  {
293  return QVariant();
294  }
295 
296  switch (role)
297  {
298  case DCategorizedSortFilterProxyModel::CategoryDisplayRole:
299  return categoryIdentifier(d->importItemModel->camItemInfoRef(mapToSource(index)));
300 
301  case CategorizationModeRole:
302  return d->sorter.categorizationMode;
303 
304  case SortOrderRole:
305  return d->sorter.sortRole;
306 
307  case CategoryFormatRole:
308  return d->importItemModel->camItemInfoRef(mapToSource(index)).mime;
309 
310  case CategoryDateRole:
311  return d->importItemModel->camItemInfoRef(mapToSource(index)).ctime;
312 
313  case ImportFilterModelPointerRole:
314  return QVariant::fromValue(const_cast<ImportFilterModel*>(this));
315  }
316 
317  return DCategorizedSortFilterProxyModel::data(index, role);
318 }
319 
320 ImportFilterModel* ImportFilterModel::importFilterModel() const
321 {
322  return const_cast<ImportFilterModel*>(this);
323 }
324 
325 // --- Sorting and Categorization ----------------------------------------------
326 
327 void ImportFilterModel::setCamItemSortSettings(const CamItemSortSettings& sorter)
328 {
329  Q_D(ImportFilterModel);
330  d->sorter = sorter;
331  setCategorizedModel(d->sorter.categorizationMode != CamItemSortSettings::NoCategories);
332  invalidate();
333 }
334 
335 void ImportFilterModel::setCategorizationMode(CamItemSortSettings::CategorizationMode mode)
336 {
337  Q_D(ImportFilterModel);
338  d->sorter.setCategorizationMode(mode);
339  setCamItemSortSettings(d->sorter);
340 }
341 
342 void ImportFilterModel::setSortRole(CamItemSortSettings::SortRole role)
343 {
344  Q_D(ImportFilterModel);
345  d->sorter.setSortRole(role);
346  setCamItemSortSettings(d->sorter);
347 }
348 
349 void ImportFilterModel::setSortOrder(CamItemSortSettings::SortOrder order)
350 {
351  Q_D(ImportFilterModel);
352  d->sorter.setSortOrder(order);
353  setCamItemSortSettings(d->sorter);
354 }
355 
356 void ImportFilterModel::setStringTypeNatural(bool natural)
357 {
358  Q_D(ImportFilterModel);
359  d->sorter.setStringTypeNatural(natural);
360  setCamItemSortSettings(d->sorter);
361 }
362 
363 void ImportFilterModel::setFilter(Digikam::Filter* filter)
364 {
365  Q_D(ImportFilterModel);
366  d->filter = filter;
367  invalidateFilter();
368 }
369 
370 void ImportFilterModel::setCameraThumbsController(CameraThumbsCtrl* const thumbsCtrl)
371 {
372  Q_D(ImportFilterModel);
373  d->importItemModel->setCameraThumbsController(thumbsCtrl);
374 }
375 
376 void ImportFilterModel::setSendCamItemInfoSignals(bool sendSignals)
377 {
378  if (sendSignals)
379  {
380  connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)),
381  this, SLOT(slotRowsInserted(QModelIndex,int,int)));
382 
383  connect(this, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
384  this, SLOT(slotRowsAboutToBeRemoved(QModelIndex,int,int)));
385  }
386  else
387  {
388  disconnect(this, SIGNAL(rowsInserted(QModelIndex,int,int)),
389  this, SLOT(slotRowsInserted(QModelIndex,int,int)));
390 
391  disconnect(this, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
392  this, SLOT(slotRowsAboutToBeRemoved(QModelIndex,int,int)));
393  }
394 }
395 
396 void ImportFilterModel::slotRowsInserted(const QModelIndex& /*parent*/, int start, int end)
397 {
398  QList<CamItemInfo> infos;
399 
400  for (int i = start ; i < end ; ++i)
401  {
402  infos << camItemInfo(index(i, 0));
403  }
404 
405  emit camItemInfosAdded(infos);
406 }
407 
408 void ImportFilterModel::slotRowsAboutToBeRemoved(const QModelIndex& /*parent*/, int start, int end)
409 {
410  QList<CamItemInfo> infos;
411 
412  for (int i = start ; i < end ; ++i)
413  {
414  infos << camItemInfo(index(i, 0));
415  }
416 
417  emit camItemInfosAboutToBeRemoved(infos);
418 }
419 
420 void ImportFilterModel::setDirectSourceImportModel(ImportItemModel* const sourceModel)
421 {
422  Q_D(ImportFilterModel);
423 
424  if (d->importItemModel)
425  {
426  //disconnect(d->importItemModel, SIGNAL(modelReset()),
427  //this, SLOT(slotModelReset()));
428  //TODO: slotModelReset(); will be added when implementing filtering options
429  disconnect(d->importItemModel, SIGNAL(processAdded(QList<CamItemInfo>)), this, SLOT(slotProcessAdded(QList<CamItemInfo>)));
430  }
431 
432  // TODO do we need to delete the old one?
433  d->importItemModel = sourceModel;
434 
435  if (d->importItemModel)
436  {
437  //connect(d, SIGNAL(reAddCamItemInfos(QList<CamItemInfo>)),
438  //d->importItemModel, SLOT(reAddCamItemInfos(QList<CamItemInfo>)));
439 
440  //connect(d, SIGNAL(reAddingFinished()),
441  //d->importItemModel, SLOT(reAddingFinished()));
442 
443  //TODO: connect(d->importItemModel, SIGNAL(modelReset()), this, SLOT(slotModelReset()));
444  connect(d->importItemModel, SIGNAL(processAdded(QList<CamItemInfo>)), this, SLOT(slotProcessAdded(QList<CamItemInfo>)));
445  }
446 
447  setSourceModel(d->importItemModel);
448 }
449 
450 void ImportFilterModel::slotProcessAdded(const QList<CamItemInfo>&)
451 {
452  invalidate();
453 }
454 
455 int ImportFilterModel::compareCategories(const QModelIndex& left, const QModelIndex& right) const
456 {
457  Q_D(const ImportFilterModel);
458 
459  if (!d->sorter.isCategorized())
460  {
461  return 0;
462  }
463 
464  if (!left.isValid() || !right.isValid())
465  {
466  return -1;
467  }
468 
469  return compareInfosCategories(d->importItemModel->camItemInfoRef(left), d->importItemModel->camItemInfoRef(right));
470 }
471 
472 bool ImportFilterModel::subSortLessThan(const QModelIndex& left, const QModelIndex& right) const
473 {
474  Q_D(const ImportFilterModel);
475 
476  if (!left.isValid() || !right.isValid())
477  {
478  return true;
479  }
480 
481  if (left == right)
482  {
483  return false;
484  }
485 
486  const CamItemInfo& leftInfo = d->importItemModel->camItemInfoRef(left);
487  const CamItemInfo& rightInfo = d->importItemModel->camItemInfoRef(right);
488 
489  if (leftInfo == rightInfo)
490  {
491  return d->sorter.lessThan(left.data(ImportItemModel::ExtraDataRole), right.data(ImportItemModel::ExtraDataRole));
492  }
493 
494  return infosLessThan(leftInfo, rightInfo);
495 }
496 
497 int ImportFilterModel::compareInfosCategories(const CamItemInfo& left, const CamItemInfo& right) const
498 {
499  Q_D(const ImportFilterModel);
500  return d->sorter.compareCategories(left, right);
501 }
502 
503 bool ImportFilterModel::infosLessThan(const CamItemInfo& left, const CamItemInfo& right) const
504 {
505  Q_D(const ImportFilterModel);
506  return d->sorter.lessThan(left, right);
507 }
508 
509 QString ImportFilterModel::categoryIdentifier(const CamItemInfo& info) const
510 {
511  Q_D(const ImportFilterModel);
512 
513  switch (d->sorter.categorizationMode)
514  {
515  case CamItemSortSettings::NoCategories:
516  return QString();
517  case CamItemSortSettings::CategoryByFolder:
518  return info.folder;
519  case CamItemSortSettings::CategoryByFormat:
520  return info.mime;
521  case CamItemSortSettings::CategoryByDate:
522  return info.ctime.date().toString(Qt::ISODate);
523  default:
524  return QString();
525  }
526 }
527 
528 bool ImportFilterModel::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const
529 {
530  Q_D(const ImportFilterModel);
531 
532  if (!d->filter)
533  {
534  return true;
535  }
536 
537  QModelIndex idx = sourceModel()->index(source_row, 0, source_parent);
538  const CamItemInfo &info = d->importItemModel->camItemInfo(idx);
539 
540  if (d->filter->matchesCurrentFilter(info))
541  {
542  return true;
543  }
544 
545  return false;
546 }
547 
548 // -------------------------------------------------------------------------------------------------------
549 
550 NoDuplicatesImportFilterModel::NoDuplicatesImportFilterModel(QObject* const parent)
551  : ImportSortFilterModel(parent)
552 {
553 }
554 
555 bool NoDuplicatesImportFilterModel::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const
556 {
557  QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
558 
559  if (index.data(ImportItemModel::ExtraDataDuplicateCount).toInt() <= 1)
560  {
561  return true;
562  }
563 
564  QModelIndex previousIndex = sourceModel()->index(source_row - 1, 0, source_parent);
565 
566  if (!previousIndex.isValid())
567  {
568  return true;
569  }
570 
571  if (sourceImportModel()->camItemId(mapFromDirectSourceToSourceImportModel(index)) ==
572  sourceImportModel()->camItemId(mapFromDirectSourceToSourceImportModel(previousIndex)))
573  {
574  return false;
575  }
576 
577  return true;
578 }
579 
580 } // namespace Digikam
QSortFilterProxyModel::index
virtual QModelIndex index(int row, int column, const QModelIndex &parent) const
Digikam::ImportSortFilterModel::importFilterModel
virtual ImportFilterModel * importFilterModel() const
Returns this, any chained ImportFilterModel, or 0.
Definition: importfiltermodel.cpp:220
QModelIndex
Digikam::NoDuplicatesImportFilterModel::NoDuplicatesImportFilterModel
NoDuplicatesImportFilterModel(QObject *const parent=nullptr)
Definition: importfiltermodel.cpp:550
Digikam::ImportSortFilterModel::sourceImportModel
ImportItemModel * sourceImportModel() const
Definition: importfiltermodel.cpp:57
QAbstractItemModel::index
virtual QModelIndex index(int row, int column, const QModelIndex &parent) const =0
Digikam::ImportSortFilterModel::ImportSortFilterModel
ImportSortFilterModel(QObject *const parent=nullptr)
Definition: importfiltermodel.cpp:35
Digikam::ImportSortFilterModel::setSourceImportModel
void setSourceImportModel(ImportItemModel *const sourceModel)
Definition: importfiltermodel.cpp:45
QSortFilterProxyModel::setSourceModel
virtual void setSourceModel(QAbstractItemModel *sourceModel)
filter.h
Digikam::NoDuplicatesImportFilterModel::filterAcceptsRow
virtual bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
Definition: importfiltermodel.cpp:555
Digikam::ImportSortFilterModel::indexForCamItemId
QModelIndex indexForCamItemId(qlonglong id) const
Definition: importfiltermodel.cpp:202
Digikam::CamItemSortSettings::SortOrder
SortOrder
Definition: camitemsortsettings.h:72
Digikam::ImportSortFilterModel::~ImportSortFilterModel
~ImportSortFilterModel()
Definition: importfiltermodel.cpp:41
end
static struct timeval start end
Definition: dcraw_emu.cpp:142
Digikam::CamItemInfo
Definition: camiteminfo.h:47
Digikam::ImportSortFilterModel::indexForCamItemInfo
QModelIndex indexForCamItemInfo(const CamItemInfo &info) const
Definition: importfiltermodel.cpp:197
Digikam::ImportSortFilterModel::setDirectSourceImportModel
virtual void setDirectSourceImportModel(ImportItemModel *const sourceModel)
Reimplement if needed. Called only when model shall be set as (direct) sourceModel.
Definition: importfiltermodel.cpp:235
Digikam::ImportSortFilterModel::mapFromDirectSourceToSourceImportModel
QModelIndex mapFromDirectSourceToSourceImportModel(const QModelIndex &sourceModelIndex) const
Definition: importfiltermodel.cpp:118
Digikam::CamItemSortSettings::CategoryByFolder
Definition: camitemsortsettings.h:84
QSortFilterProxyModel::rowCount
virtual int rowCount(const QModelIndex &parent) const
Digikam::ImportSortFilterModel::camItemId
qlonglong camItemId(const QModelIndex &index) const
Definition: importfiltermodel.cpp:162
Digikam::ImportSortFilterModel::camItemInfosSorted
QList< CamItemInfo > camItemInfosSorted() const
Returns a list of all camera infos, sorted according to this model.
Definition: importfiltermodel.cpp:207
Digikam::CamItemSortSettings::CategoryByFormat
Definition: camitemsortsettings.h:85
Digikam::ImportSortFilterModel::camItemInfos
QList< CamItemInfo > camItemInfos(const QList< QModelIndex > &indexes) const
Definition: importfiltermodel.cpp:167
QModelIndex::isValid
bool isValid() const
Digikam::ImportSortFilterModel::m_chainedModel
ImportSortFilterModel * m_chainedModel
Definition: importfiltermodel.h:92
Digikam::DCategorizedSortFilterProxyModel::CategoryDisplayRole
This role is used for asking the category to a given index.
Definition: dcategorizedsortfilterproxymodel.h:61
order
#define order
Definition: var_defines.h:166
QVariant::toInt
int toInt(bool *ok) const
Digikam::ImportSortFilterModel::mapListToSource
QList< QModelIndex > mapListToSource(const QList< QModelIndex > &indexes) const
Definition: importfiltermodel.cpp:133
QObject
source_row
int source_row
Definition: 62/jpegint.h:373
Digikam::ImportSortFilterModel::setSourceModel
virtual void setSourceModel(QAbstractItemModel *sourceModel)
Definition: importfiltermodel.cpp:230
Digikam::ImportSortFilterModel::mapListFromSource
QList< QModelIndex > mapListFromSource(const QList< QModelIndex > &sourceIndexes) const
Definition: importfiltermodel.cpp:145
QString
QList< QModelIndex >
model
#define model
Definition: var_defines.h:25
Digikam::ImportSortFilterModel::mapFromSourceImportModel
QModelIndex mapFromSourceImportModel(const QModelIndex &importModelIndex) const
Definition: importfiltermodel.cpp:103
Digikam::ImportSortFilterModel::setSourceFilterModel
void setSourceFilterModel(ImportSortFilterModel *const sourceModel)
Definition: importfiltermodel.cpp:67
QUrl
Digikam::ImportSortFilterModel::camItemIds
QList< qlonglong > camItemIds(const QList< QModelIndex > &indexes) const
Definition: importfiltermodel.cpp:179
camiteminfo.h
QVariant::fromValue
QVariant fromValue(const T &value)
Digikam::Filter
Definition: filter.h:43
Digikam::CamItemSortSettings::CategoryByDate
Definition: camitemsortsettings.h:86
QAbstractProxyModel::sourceModel
QAbstractItemModel * sourceModel() const
QSortFilterProxyModel::mapToSource
virtual QModelIndex mapToSource(const QModelIndex &proxyIndex) const
Digikam::ImportSortFilterModel::sourceFilterModel
ImportSortFilterModel * sourceFilterModel() const
Definition: importfiltermodel.cpp:83
QModelIndex::data
QVariant data(int role) const
importimagemodel.h
QSortFilterProxyModel::mapFromSource
virtual QModelIndex mapFromSource(const QModelIndex &sourceIndex) const
Digikam::ImportSortFilterModel::indexForPath
QModelIndex indexForPath(const QString &filePath) const
Definition: importfiltermodel.cpp:191
QAbstractItemModel
Digikam::cimg_library::cimg::info
void info()
Print information about CImg environment variables.
Definition: CImg.h:5763
Digikam::CamItemSortSettings::NoCategories
Definition: camitemsortsettings.h:83
Digikam::ImportSortFilterModel::camItemInfo
CamItemInfo camItemInfo(const QModelIndex &index) const
Definition: importfiltermodel.cpp:157
Digikam::DCategorizedSortFilterProxyModel
This class lets you categorize a view.
Definition: dcategorizedsortfilterproxymodel.h:52
Digikam::CamItemSortSettings::CategorizationMode
CategorizationMode
— Categories ------------—
Definition: camitemsortsettings.h:81
importfiltermodel.h
Digikam::ImportSortFilterModel
Definition: importfiltermodel.h:42
q
#define q
Digikam::ImportSortFilterModel::mapToSourceImportModel
QModelIndex mapToSourceImportModel(const QModelIndex &proxyIndex) const
Convenience methods mapped to ImportItemModel.
Definition: importfiltermodel.cpp:88
Digikam::CamItemSortSettings::SortRole
SortRole
— Camera Items Sorting ------------—
Definition: camitemsortsettings.h:103
QSortFilterProxyModel::data
virtual QVariant data(const QModelIndex &index, int role) const
QUrl::fromLocalFile
QUrl fromLocalFile(const QString &localFile)
QVariant
This file is part of the KDE documentation.
Documentation copyright © 1996-2019 The KDE developers.
Generated on Thu Dec 12 2019 03:09:59 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

digikam

Skip menu "digikam"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages
-->

graphics API Reference

Skip menu "graphics API Reference"
  • digikam
  • KDiagram
  •     KChart
  •     KGantt
  • KPhotoAlbum
  •   AndroidRemoteControl
  • Krita
  •   libs
  •     KritaBasicFlakes
  •     brush
  •     KritaUndo2
  •     KritaFlake
  •     image
  •     KritaPlugin
  •     Krita
  •     KritaOdf
  •     KritaPigment
  •     KritaStore
  •     ui
  •     KritaWidgets
  •     KritaWidgetUtils
  •   plugins
  •     Assitants
  •     Extensions
  •     Filters
  •         KritaText
  •         KritaTextLayout
  •     Generators
  •     Formats
  •             src
  •     PaintOps
  •       libpaintop
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal