Differential D10832 Diff 28884 src/kitemviews/kfileitemmodelrolesupdater.cpp

Changeset View

Standalone View

View Options

src/kitemviews/kfileitemmodelrolesupdater.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Line(s)50namespace {
58 58​
59 // Not only the visible area, but up to ReadAheadPages before and after 59​ // Not only the visible area, but up to ReadAheadPages before and after
60 // this area will be resolved. 60​ // this area will be resolved.
61 const int ReadAheadPages = 5; 61​ const int ReadAheadPages = 5;
62} 62​}
63 63​
64KFileItemModelRolesUpdater::KFileItemModelRolesUpdater(KFileItemModel* model, QObject* parent) : 64​KFileItemModelRolesUpdater::KFileItemModelRolesUpdater(KFileItemModel* model, QObject* parent) :
65 QObject(parent), 65​ QObject(parent),
66 m_state(Idle), 66​ m_state(State::Idle),
67 m_previewChangedDuringPausing(false), 67​ m_previewChangedDuringPausing(false),
68 m_iconSizeChangedDuringPausing(false), 68​ m_iconSizeChangedDuringPausing(false),
69 m_rolesChangedDuringPausing(false), 69​ m_rolesChangedDuringPausing(false),
70 m_previewShown(false), 70​ m_previewShown(false),
71 m_enlargeSmallPreviews(true), 71​ m_enlargeSmallPreviews(true),
72 m_clearPreviews(false), 72​ m_clearPreviews(false),
73 m_finishedItems(), 73​ m_finishedItems(),
74 m_model(model), 74​ m_model(model),
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Line(s)
142{ 142​{
143 killPreviewJob(); 143​ killPreviewJob();
144} 144​}
145 145​
146void KFileItemModelRolesUpdater::setIconSize(const QSize& size) 146​void KFileItemModelRolesUpdater::setIconSize(const QSize& size)
147{ 147​{
148 if (size != m_iconSize) { 148​ if (size != m_iconSize) {
149 m_iconSize = size; 149​ m_iconSize = size;
150 if (m_state == Paused) { 150​ if (m_state == State::Paused) {
151 m_iconSizeChangedDuringPausing = true; 151​ m_iconSizeChangedDuringPausing = true;
152 } else if (m_previewShown) { 152​ } else if (m_previewShown) {
153 // An icon size change requires the regenerating of 153​ // An icon size change requires the regenerating of
154 // all previews 154​ // all previews
155 m_finishedItems.clear(); 155​ m_finishedItems.clear();
156 startUpdating(); 156​ startUpdating();
157 } 157​ }
158 } 158​ }
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Line(s)227 if (m_enabledPlugins != list) {
229 if (m_previewShown) { 229​ if (m_previewShown) {
230 updateAllPreviews(); 230​ updateAllPreviews();
231 } 231​ }
232 } 232​ }
233} 233​}
234 234​
235void KFileItemModelRolesUpdater::setPaused(bool paused) 235​void KFileItemModelRolesUpdater::setPaused(bool paused)
236{ 236​{
237 if (paused == (m_state == Paused)) { 237​ if (paused == (m_state == State::Paused)) {
238 return; 238​ return;
239 } 239​ }
240 240​
241 if (paused) { 241​ if (paused) {
242 m_state = Paused; 242​ m_state = State::Paused;
243 killPreviewJob(); 243​ killPreviewJob();
244 } else { 244​ } else {
245 const bool updatePreviews = (m_iconSizeChangedDuringPausing && m_previewShown) || 245​ const bool updatePreviews = (m_iconSizeChangedDuringPausing && m_previewShown) ||
246 m_previewChangedDuringPausing; 246​ m_previewChangedDuringPausing;
247 const bool resolveAll = updatePreviews || m_rolesChangedDuringPausing; 247​ const bool resolveAll = updatePreviews || m_rolesChangedDuringPausing;
248 if (resolveAll) { 248​ if (resolveAll) {
249 m_finishedItems.clear(); 249​ m_finishedItems.clear();
250 } 250​ }
251 251​
252 m_iconSizeChangedDuringPausing = false; 252​ m_iconSizeChangedDuringPausing = false;
253 m_previewChangedDuringPausing = false; 253​ m_previewChangedDuringPausing = false;
254 m_rolesChangedDuringPausing = false; 254​ m_rolesChangedDuringPausing = false;
255 255​
256 if (!m_pendingSortRoleItems.isEmpty()) { 256​ if (!m_pendingSortRoleItems.isEmpty()) {
257 m_state = ResolvingSortRole; 257​ m_state = State::ResolvingSortRole;
258 resolveNextSortRole(); 258​ resolveNextSortRole();
259 } else { 259​ } else {
260 m_state = Idle; 260​ m_state = State::Idle;
261 } 261​ }
262 262​
263 startUpdating(); 263​ startUpdating();
264 } 264​ }
265} 265​}
266 266​
267void KFileItemModelRolesUpdater::setRoles(const QSet<QByteArray>& roles) 267​void KFileItemModelRolesUpdater::setRoles(const QSet<QByteArray>& roles)
268{ 268​{
Show All 21 Lines288 if (hasBalooRole && m_balooConfig.fileIndexingEnabled() && !m_balooFileMonitor) {
290 connect(m_balooFileMonitor, &Baloo::FileMonitor::fileMetaDataChanged, 290​ connect(m_balooFileMonitor, &Baloo::FileMonitor::fileMetaDataChanged,
291 this, &KFileItemModelRolesUpdater::applyChangedBalooRoles); 291​ this, &KFileItemModelRolesUpdater::applyChangedBalooRoles);
292 } else if (!hasBalooRole && m_balooFileMonitor) { 292​ } else if (!hasBalooRole && m_balooFileMonitor) {
293 delete m_balooFileMonitor; 293​ delete m_balooFileMonitor;
294 m_balooFileMonitor = nullptr; 294​ m_balooFileMonitor = nullptr;
295 } 295​ }
296#endif 296​#endif
297 297​
298 if (m_state == Paused) { 298​ if (m_state == State::Paused) {
299 m_rolesChangedDuringPausing = true; 299​ m_rolesChangedDuringPausing = true;
300 } else { 300​ } else {
301 startUpdating(); 301​ startUpdating();
302 } 302​ }
303 } 303​ }
304} 304​}
305 305​
306QSet<QByteArray> KFileItemModelRolesUpdater::roles() const 306​QSet<QByteArray> KFileItemModelRolesUpdater::roles() const
307{ 307​{
308 return m_roles; 308​ return m_roles;
309} 309​}
310 310​
311bool KFileItemModelRolesUpdater::isPaused() const 311​bool KFileItemModelRolesUpdater::isPaused() const
312{ 312​{
313 return m_state == Paused; 313​ return m_state == State::Paused;
314} 314​}
315 315​
316QStringList KFileItemModelRolesUpdater::enabledPlugins() const 316​QStringList KFileItemModelRolesUpdater::enabledPlugins() const
317{ 317​{
318 return m_enabledPlugins; 318​ return m_enabledPlugins;
319} 319​}
320 320​
321void KFileItemModelRolesUpdater::slotItemsInserted(const KItemRangeList& itemRanges) 321​void KFileItemModelRolesUpdater::slotItemsInserted(const KItemRangeList& itemRanges)
Show All 16 Lines329 foreach (const KItemRange& range, itemRanges) {
338 insertedCount += range.count; 338​ insertedCount += range.count;
339 } 339​ }
340 340​
341 applySortProgressToModel(); 341​ applySortProgressToModel();
342 342​
343 // If there are still items whose sort role is unknown, check if the 343​ // If there are still items whose sort role is unknown, check if the
344 // asynchronous determination of the sort role is already in progress, 344​ // asynchronous determination of the sort role is already in progress,
345 // and start it if that is not the case. 345​ // and start it if that is not the case.
346 if (!m_pendingSortRoleItems.isEmpty() && m_state != ResolvingSortRole) { 346​ if (!m_pendingSortRoleItems.isEmpty() && m_state != State::ResolvingSortRole) {
347 killPreviewJob(); 347​ killPreviewJob();
348 m_state = ResolvingSortRole; 348​ m_state = State::ResolvingSortRole;
349 resolveNextSortRole(); 349​ resolveNextSortRole();
350 } 350​ }
351 } 351​ }
352 352​
353 startUpdating(); 353​ startUpdating();
354} 354​}
355 355​
356void KFileItemModelRolesUpdater::slotItemsRemoved(const KItemRangeList& itemRanges) 356​void KFileItemModelRolesUpdater::slotItemsRemoved(const KItemRangeList& itemRanges)
Show All 15 Lines369 foreach (const QString& file, m_balooFileMonitor->files()) {
372 } 372​ }
373 } 373​ }
374 m_balooFileMonitor->setFiles(newFileList); 374​ m_balooFileMonitor->setFiles(newFileList);
375 } 375​ }
376 } 376​ }
377#endif 377​#endif
378 378​
379 if (allItemsRemoved) { 379​ if (allItemsRemoved) {
380 m_state = Idle; 380​ m_state = State::Idle;
381 381​
382 m_finishedItems.clear(); 382​ m_finishedItems.clear();
383 m_pendingSortRoleItems.clear(); 383​ m_pendingSortRoleItems.clear();
384 m_pendingIndexes.clear(); 384​ m_pendingIndexes.clear();
385 m_pendingPreviewItems.clear(); 385​ m_pendingPreviewItems.clear();
386 m_recentlyChangedItems.clear(); 386​ m_recentlyChangedItems.clear();
387 m_recentlyChangedItemsTimer->stop(); 387​ m_recentlyChangedItemsTimer->stop();
388 m_changedItems.clear(); 388​ m_changedItems.clear();
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Line(s)460 for (int index = 0; index < count; ++index) {
465 } 465​ }
466 } 466​ }
467 467​
468 applySortProgressToModel(); 468​ applySortProgressToModel();
469 469​
470 if (!m_pendingSortRoleItems.isEmpty()) { 470​ if (!m_pendingSortRoleItems.isEmpty()) {
471 // Trigger the asynchronous determination of the sort role. 471​ // Trigger the asynchronous determination of the sort role.
472 killPreviewJob(); 472​ killPreviewJob();
473 m_state = ResolvingSortRole; 473​ m_state = State::ResolvingSortRole;
474 resolveNextSortRole(); 474​ resolveNextSortRole();
475 } 475​ }
476 } else { 476​ } else {
477 m_state = Idle; 477​ m_state = State::Idle;
478 m_pendingSortRoleItems.clear(); 478​ m_pendingSortRoleItems.clear();
479 applySortProgressToModel(); 479​ applySortProgressToModel();
480 } 480​ }
481} 481​}
482 482​
483void KFileItemModelRolesUpdater::slotGotPreview(const KFileItem& item, const QPixmap& pixmap) 483​void KFileItemModelRolesUpdater::slotGotPreview(const KFileItem& item, const QPixmap& pixmap)
484{ 484​{
485 if (m_state != PreviewJobRunning) { 485​ if (m_state != State::PreviewJobRunning) {
486 return; 486​ return;
487 } 487​ }
488 488​
489 m_changedItems.remove(item); 489​ m_changedItems.remove(item);
490 490​
491 const int index = m_model->index(item); 491​ const int index = m_model->index(item);
492 if (index < 0) { 492​ if (index < 0) {
493 return; 493​ return;
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Line(s)
560 connect(m_model, &KFileItemModel::itemsChanged, 560​ connect(m_model, &KFileItemModel::itemsChanged,
561 this, &KFileItemModelRolesUpdater::slotItemsChanged); 561​ this, &KFileItemModelRolesUpdater::slotItemsChanged);
562 562​
563 m_finishedItems.insert(item); 563​ m_finishedItems.insert(item);
564} 564​}
565 565​
566void KFileItemModelRolesUpdater::slotPreviewFailed(const KFileItem& item) 566​void KFileItemModelRolesUpdater::slotPreviewFailed(const KFileItem& item)
567{ 567​{
568 if (m_state != PreviewJobRunning) { 568​ if (m_state != State::PreviewJobRunning) {
569 return; 569​ return;
570 } 570​ }
571 571​
572 m_changedItems.remove(item); 572​ m_changedItems.remove(item);
573 573​
574 const int index = m_model->index(item); 574​ const int index = m_model->index(item);
575 if (index >= 0) { 575​ if (index >= 0) {
576 QHash<QByteArray, QVariant> data; 576​ QHash<QByteArray, QVariant> data;
577 data.insert("iconPixmap", QPixmap()); 577​ data.insert("iconPixmap", QPixmap());
578 578​
579 disconnect(m_model, &KFileItemModel::itemsChanged, 579​ disconnect(m_model, &KFileItemModel::itemsChanged,
580 this, &KFileItemModelRolesUpdater::slotItemsChanged); 580​ this, &KFileItemModelRolesUpdater::slotItemsChanged);
581 m_model->setData(index, data); 581​ m_model->setData(index, data);
582 connect(m_model, &KFileItemModel::itemsChanged, 582​ connect(m_model, &KFileItemModel::itemsChanged,
583 this, &KFileItemModelRolesUpdater::slotItemsChanged); 583​ this, &KFileItemModelRolesUpdater::slotItemsChanged);
584 584​
585 applyResolvedRoles(index, ResolveAll); 585​ applyResolvedRoles(index, ResolveHint::ResolveAll);
586 m_finishedItems.insert(item); 586​ m_finishedItems.insert(item);
587 } 587​ }
588} 588​}
589 589​
590void KFileItemModelRolesUpdater::slotPreviewJobFinished() 590​void KFileItemModelRolesUpdater::slotPreviewJobFinished()
591{ 591​{
592 m_previewJob = nullptr; 592​ m_previewJob = nullptr;
593 593​
594 if (m_state != PreviewJobRunning) { 594​ if (m_state != State::PreviewJobRunning) {
595 return; 595​ return;
596 } 596​ }
597 597​
598 m_state = Idle; 598​ m_state = State::Idle;
599 599​
600 if (!m_pendingPreviewItems.isEmpty()) { 600​ if (!m_pendingPreviewItems.isEmpty()) {
601 startPreviewJob(); 601​ startPreviewJob();
602 } else { 602​ } else {
603 if (!m_changedItems.isEmpty()) { 603​ if (!m_changedItems.isEmpty()) {
604 updateChangedItems(); 604​ updateChangedItems();
605 } 605​ }
606 } 606​ }
607} 607​}
608 608​
609void KFileItemModelRolesUpdater::resolveNextSortRole() 609​void KFileItemModelRolesUpdater::resolveNextSortRole()
610{ 610​{
611 if (m_state != ResolvingSortRole) { 611​ if (m_state != State::ResolvingSortRole) {
612 return; 612​ return;
613 } 613​ }
614 614​
615 QSet<KFileItem>::iterator it = m_pendingSortRoleItems.begin(); 615​ QSet<KFileItem>::iterator it = m_pendingSortRoleItems.begin();
616 while (it != m_pendingSortRoleItems.end()) { 616​ while (it != m_pendingSortRoleItems.end()) {
617 const KFileItem item = *it; 617​ const KFileItem item = *it;
618 const int index = m_model->index(item); 618​ const int index = m_model->index(item);
619 619​
620 // Continue if the sort role has already been determined for the 620​ // Continue if the sort role has already been determined for the
621 // item, and the item has not been changed recently. 621​ // item, and the item has not been changed recently.
622 if (!m_changedItems.contains(item) && m_model->data(index).contains(m_model->sortRole())) { 622​ if (!m_changedItems.contains(item) && m_model->data(index).contains(m_model->sortRole())) {
623 it = m_pendingSortRoleItems.erase(it); 623​ it = m_pendingSortRoleItems.erase(it);
624 continue; 624​ continue;
625 } 625​ }
626 626​
627 applySortRole(index); 627​ applySortRole(index);
628 m_pendingSortRoleItems.erase(it); 628​ m_pendingSortRoleItems.erase(it);
629 break; 629​ break;
630 } 630​ }
631 631​
632 if (!m_pendingSortRoleItems.isEmpty()) { 632​ if (!m_pendingSortRoleItems.isEmpty()) {
633 applySortProgressToModel(); 633​ applySortProgressToModel();
634 QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextSortRole); 634​ QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextSortRole);
635 } else { 635​ } else {
636 m_state = Idle; 636​ m_state = State::Idle;
637 637​
638 // Prevent that we try to update the items twice. 638​ // Prevent that we try to update the items twice.
639 disconnect(m_model, &KFileItemModel::itemsMoved, 639​ disconnect(m_model, &KFileItemModel::itemsMoved,
640 this, &KFileItemModelRolesUpdater::slotItemsMoved); 640​ this, &KFileItemModelRolesUpdater::slotItemsMoved);
641 applySortProgressToModel(); 641​ applySortProgressToModel();
642 connect(m_model, &KFileItemModel::itemsMoved, 642​ connect(m_model, &KFileItemModel::itemsMoved,
643 this, &KFileItemModelRolesUpdater::slotItemsMoved); 643​ this, &KFileItemModelRolesUpdater::slotItemsMoved);
644 startUpdating(); 644​ startUpdating();
645 } 645​ }
646} 646​}
647 647​
648void KFileItemModelRolesUpdater::resolveNextPendingRoles() 648​void KFileItemModelRolesUpdater::resolveNextPendingRoles()
649{ 649​{
650 if (m_state != ResolvingAllRoles) { 650​ if (m_state != State::ResolvingAllRoles) {
651 return; 651​ return;
652 } 652​ }
653 653​
654 while (!m_pendingIndexes.isEmpty()) { 654​ while (!m_pendingIndexes.isEmpty()) {
655 const int index = m_pendingIndexes.takeFirst(); 655​ const int index = m_pendingIndexes.takeFirst();
656 const KFileItem item = m_model->fileItem(index); 656​ const KFileItem item = m_model->fileItem(index);
657 657​
658 if (m_finishedItems.contains(item)) { 658​ if (m_finishedItems.contains(item)) {
659 continue; 659​ continue;
660 } 660​ }
661 661​
662 applyResolvedRoles(index, ResolveAll); 662​ applyResolvedRoles(index, ResolveHint::ResolveAll);
663 m_finishedItems.insert(item); 663​ m_finishedItems.insert(item);
664 m_changedItems.remove(item); 664​ m_changedItems.remove(item);
665 break; 665​ break;
666 } 666​ }
667 667​
668 if (!m_pendingIndexes.isEmpty()) { 668​ if (!m_pendingIndexes.isEmpty()) {
669 QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextPendingRoles); 669​ QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextPendingRoles);
670 } else { 670​ } else {
671 m_state = Idle; 671​ m_state = State::Idle;
672 672​
673 if (m_clearPreviews) { 673​ if (m_clearPreviews) {
674 // Only go through the list if there are items which might still have previews. 674​ // Only go through the list if there are items which might still have previews.
675 if (m_finishedItems.count() != m_model->count()) { 675​ if (m_finishedItems.count() != m_model->count()) {
676 QHash<QByteArray, QVariant> data; 676​ QHash<QByteArray, QVariant> data;
677 data.insert("iconPixmap", QPixmap()); 677​ data.insert("iconPixmap", QPixmap());
678 678​
679 disconnect(m_model, &KFileItemModel::itemsChanged, 679​ disconnect(m_model, &KFileItemModel::itemsChanged,
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Line(s)762 if (index >= 0) {
775 connect(m_model, &KFileItemModel::itemsChanged, 775​ connect(m_model, &KFileItemModel::itemsChanged,
776 this, &KFileItemModelRolesUpdater::slotItemsChanged); 776​ this, &KFileItemModelRolesUpdater::slotItemsChanged);
777 } 777​ }
778 } 778​ }
779} 779​}
780 780​
781void KFileItemModelRolesUpdater::startUpdating() 781​void KFileItemModelRolesUpdater::startUpdating()
782{ 782​{
783 if (m_state == Paused) { 783​ if (m_state == State::Paused) {
784 return; 784​ return;
785 } 785​ }
786 786​
787 if (m_finishedItems.count() == m_model->count()) { 787​ if (m_finishedItems.count() == m_model->count()) {
788 // All roles have been resolved already. 788​ // All roles have been resolved already.
789 m_state = Idle; 789​ m_state = State::Idle;
790 return; 790​ return;
791 } 791​ }
792 792​
793 // Terminate all updates that are currently active. 793​ // Terminate all updates that are currently active.
794 killPreviewJob(); 794​ killPreviewJob();
795 m_pendingIndexes.clear(); 795​ m_pendingIndexes.clear();
796 796​
797 QElapsedTimer timer; 797​ QElapsedTimer timer;
798 timer.start(); 798​ timer.start();
799 799​
800 // Determine the icons for the visible items synchronously. 800​ // Determine the icons for the visible items synchronously.
801 updateVisibleIcons(); 801​ updateVisibleIcons();
802 802​
803 // A detailed update of the items in and near the visible area 803​ // A detailed update of the items in and near the visible area
804 // only makes sense if sorting is finished. 804​ // only makes sense if sorting is finished.
805 if (m_state == ResolvingSortRole) { 805​ if (m_state == State::ResolvingSortRole) {
806 return; 806​ return;
807 } 807​ }
808 808​
809 // Start the preview job or the asynchronous resolving of all roles. 809​ // Start the preview job or the asynchronous resolving of all roles.
810 QList<int> indexes = indexesToResolve(); 810​ QList<int> indexes = indexesToResolve();
811 811​
812 if (m_previewShown) { 812​ if (m_previewShown) {
813 m_pendingPreviewItems.clear(); 813​ m_pendingPreviewItems.clear();
814 m_pendingPreviewItems.reserve(indexes.count()); 814​ m_pendingPreviewItems.reserve(indexes.count());
815 815​
816 foreach (int index, indexes) { 816​ foreach (int index, indexes) {
817 const KFileItem item = m_model->fileItem(index); 817​ const KFileItem item = m_model->fileItem(index);
818 if (!m_finishedItems.contains(item)) { 818​ if (!m_finishedItems.contains(item)) {
819 m_pendingPreviewItems.append(item); 819​ m_pendingPreviewItems.append(item);
820 } 820​ }
821 } 821​ }
822 822​
823 startPreviewJob(); 823​ startPreviewJob();
824 } else { 824​ } else {
825 m_pendingIndexes = indexes; 825​ m_pendingIndexes = indexes;
826 // Trigger the asynchronous resolving of all roles. 826​ // Trigger the asynchronous resolving of all roles.
827 m_state = ResolvingAllRoles; 827​ m_state = State::ResolvingAllRoles;
828 QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextPendingRoles); 828​ QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextPendingRoles);
829 } 829​ }
830} 830​}
831 831​
832void KFileItemModelRolesUpdater::updateVisibleIcons() 832​void KFileItemModelRolesUpdater::updateVisibleIcons()
833{ 833​{
834 int lastVisibleIndex = m_lastVisibleIndex; 834​ int lastVisibleIndex = m_lastVisibleIndex;
835 if (lastVisibleIndex <= 0) { 835​ if (lastVisibleIndex <= 0) {
836 // Guess a reasonable value for the last visible index if the view 836​ // Guess a reasonable value for the last visible index if the view
837 // has not told us about the real value yet. 837​ // has not told us about the real value yet.
838 lastVisibleIndex = qMin(m_firstVisibleIndex + m_maximumVisibleItems, m_model->count() - 1); 838​ lastVisibleIndex = qMin(m_firstVisibleIndex + m_maximumVisibleItems, m_model->count() - 1);
839 if (lastVisibleIndex <= 0) { 839​ if (lastVisibleIndex <= 0) {
840 lastVisibleIndex = qMin(200, m_model->count() - 1); 840​ lastVisibleIndex = qMin(200, m_model->count() - 1);
841 } 841​ }
842 } 842​ }
843 843​
844 QElapsedTimer timer; 844​ QElapsedTimer timer;
845 timer.start(); 845​ timer.start();
846 846​
847 // Try to determine the final icons for all visible items. 847​ // Try to determine the final icons for all visible items.
848 int index; 848​ int index;
849 for (index = m_firstVisibleIndex; index <= lastVisibleIndex && timer.elapsed() < MaxBlockTimeout; ++index) { 849​ for (index = m_firstVisibleIndex; index <= lastVisibleIndex && timer.elapsed() < MaxBlockTimeout; ++index) {
850 applyResolvedRoles(index, ResolveFast); 850​ applyResolvedRoles(index, ResolveHint::ResolveFast);
851 } 851​ }
852 852​
853 // KFileItemListView::initializeItemListWidget(KItemListWidget*) will load 853​ // KFileItemListView::initializeItemListWidget(KItemListWidget*) will load
854 // preliminary icons (i.e., without mime type determination) for the 854​ // preliminary icons (i.e., without mime type determination) for the
855 // remaining items. 855​ // remaining items.
856} 856​}
857 857​
858void KFileItemModelRolesUpdater::startPreviewJob() 858​void KFileItemModelRolesUpdater::startPreviewJob()
859{ 859​{
860 m_state = PreviewJobRunning; 860​ m_state = State::PreviewJobRunning;
861 861​
862 if (m_pendingPreviewItems.isEmpty()) { 862​ if (m_pendingPreviewItems.isEmpty()) {
863 QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::slotPreviewJobFinished); 863​ QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::slotPreviewJobFinished);
864 return; 864​ return;
865 } 865​ }
866 866​
867 // PreviewJob internally caches items always with the size of 867​ // PreviewJob internally caches items always with the size of
868 // 128 x 128 pixels or 256 x 256 pixels. A (slow) downscaling is done 868​ // 128 x 128 pixels or 256 x 256 pixels. A (slow) downscaling is done
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Line(s)
914 connect(job, &KIO::PreviewJob::finished, 914​ connect(job, &KIO::PreviewJob::finished,
915 this, &KFileItemModelRolesUpdater::slotPreviewJobFinished); 915​ this, &KFileItemModelRolesUpdater::slotPreviewJobFinished);
916 916​
917 m_previewJob = job; 917​ m_previewJob = job;
918} 918​}
919 919​
920void KFileItemModelRolesUpdater::updateChangedItems() 920​void KFileItemModelRolesUpdater::updateChangedItems()
921{ 921​{
922 if (m_state == Paused) { 922​ if (m_state == State::Paused) {
923 return; 923​ return;
924 } 924​ }
925 925​
926 if (m_changedItems.isEmpty()) { 926​ if (m_changedItems.isEmpty()) {
927 return; 927​ return;
928 } 928​ }
929 929​
930 m_finishedItems -= m_changedItems; 930​ m_finishedItems -= m_changedItems;
931 931​
932 if (m_resolvableRoles.contains(m_model->sortRole())) { 932​ if (m_resolvableRoles.contains(m_model->sortRole())) {
933 m_pendingSortRoleItems += m_changedItems; 933​ m_pendingSortRoleItems += m_changedItems;
934 934​
935 if (m_state != ResolvingSortRole) { 935​ if (m_state != State::ResolvingSortRole) {
936 // Stop the preview job if necessary, and trigger the 936​ // Stop the preview job if necessary, and trigger the
937 // asynchronous determination of the sort role. 937​ // asynchronous determination of the sort role.
938 killPreviewJob(); 938​ killPreviewJob();
939 m_state = ResolvingSortRole; 939​ m_state = State::ResolvingSortRole;
940 QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextSortRole); 940​ QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextSortRole);
941 } 941​ }
942 942​
943 return; 943​ return;
944 } 944​ }
945 945​
946 QList<int> visibleChangedIndexes; 946​ QList<int> visibleChangedIndexes;
947 QList<int> invisibleChangedIndexes; 947​ QList<int> invisibleChangedIndexes;
Show All 27 Lines966 if (m_previewShown) {
975 if (!m_previewJob) { 975​ if (!m_previewJob) {
976 startPreviewJob(); 976​ startPreviewJob();
977 } 977​ }
978 } else { 978​ } else {
979 const bool resolvingInProgress = !m_pendingIndexes.isEmpty(); 979​ const bool resolvingInProgress = !m_pendingIndexes.isEmpty();
980 m_pendingIndexes = visibleChangedIndexes + m_pendingIndexes + invisibleChangedIndexes; 980​ m_pendingIndexes = visibleChangedIndexes + m_pendingIndexes + invisibleChangedIndexes;
981 if (!resolvingInProgress) { 981​ if (!resolvingInProgress) {
982 // Trigger the asynchronous resolving of the changed roles. 982​ // Trigger the asynchronous resolving of the changed roles.
983 m_state = ResolvingAllRoles; 983​ m_state = State::ResolvingAllRoles;
984 QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextPendingRoles); 984​ QTimer::singleShot(0, this, &KFileItemModelRolesUpdater::resolveNextPendingRoles);
985 } 985​ }
986 } 986​ }
987} 987​}
988 988​
989void KFileItemModelRolesUpdater::applySortRole(int index) 989​void KFileItemModelRolesUpdater::applySortRole(int index)
990{ 990​{
991 QHash<QByteArray, QVariant> data; 991​ QHash<QByteArray, QVariant> data;
Show All 26 Lines1016{
1018 // so that it can give an indication when the sorting has been finished. 1018​ // so that it can give an indication when the sorting has been finished.
1019 const int resolvedCount = m_model->count() - m_pendingSortRoleItems.count(); 1019​ const int resolvedCount = m_model->count() - m_pendingSortRoleItems.count();
1020 m_model->emitSortProgress(resolvedCount); 1020​ m_model->emitSortProgress(resolvedCount);
1021} 1021​}
1022 1022​
1023bool KFileItemModelRolesUpdater::applyResolvedRoles(int index, ResolveHint hint) 1023​bool KFileItemModelRolesUpdater::applyResolvedRoles(int index, ResolveHint hint)
1024{ 1024​{
1025 const KFileItem item = m_model->fileItem(index); 1025​ const KFileItem item = m_model->fileItem(index);
1026 const bool resolveAll = (hint == ResolveAll); 1026​ const bool resolveAll = (hint == ResolveHint::ResolveAll);
1027 1027​
1028 bool iconChanged = false; 1028​ bool iconChanged = false;
1029 if (!item.isMimeTypeKnown() || !item.isFinalIconKnown()) { 1029​ if (!item.isMimeTypeKnown() || !item.isFinalIconKnown()) {
1030 item.determineMimeType(); 1030​ item.determineMimeType();
1031 iconChanged = true; 1031​ iconChanged = true;
1032 } else if (!m_model->data(index).contains("iconName")) { 1032​ } else if (!m_model->data(index).contains("iconName")) {
1033 iconChanged = true; 1033​ iconChanged = true;
1034 } 1034​ }
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Line(s)1109 foreach (KOverlayIconPlugin *it, m_overlayIconsPlugin) {
1110 overlays.append(it->getOverlays(url)); 1110​ overlays.append(it->getOverlays(url));
1111 } 1111​ }
1112 data.insert("iconOverlays", overlays); 1112​ data.insert("iconOverlays", overlays);
1113 m_model->setData(index, data); 1113​ m_model->setData(index, data);
1114} 1114​}
1115 1115​
1116void KFileItemModelRolesUpdater::updateAllPreviews() 1116​void KFileItemModelRolesUpdater::updateAllPreviews()
1117{ 1117​{
1118 if (m_state == Paused) { 1118​ if (m_state == State::Paused) {
1119 m_previewChangedDuringPausing = true; 1119​ m_previewChangedDuringPausing = true;
1120 } else { 1120​ } else {
1121 m_finishedItems.clear(); 1121​ m_finishedItems.clear();
1122 startUpdating(); 1122​ startUpdating();
1123 } 1123​ }
1124} 1124​}
1125 1125​
1126void KFileItemModelRolesUpdater::killPreviewJob() 1126​void KFileItemModelRolesUpdater::killPreviewJob()
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines