summaryrefslogtreecommitdiffstats
path: root/juk/collectionlist.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commite2de64d6f1beb9e492daf5b886e19933c1fa41dd (patch)
tree9047cf9e6b5c43878d5bf82660adae77ceee097a /juk/collectionlist.cpp
downloadtdemultimedia-e2de64d6f1beb9e492daf5b886e19933c1fa41dd.tar.gz
tdemultimedia-e2de64d6f1beb9e492daf5b886e19933c1fa41dd.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdemultimedia@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'juk/collectionlist.cpp')
-rw-r--r--juk/collectionlist.cpp511
1 files changed, 511 insertions, 0 deletions
diff --git a/juk/collectionlist.cpp b/juk/collectionlist.cpp
new file mode 100644
index 00000000..9540be85
--- /dev/null
+++ b/juk/collectionlist.cpp
@@ -0,0 +1,511 @@
+/***************************************************************************
+ begin : Fri Sep 13 2002
+ copyright : (C) 2002 - 2004 by Scott Wheeler
+ email : wheeler@kde.org
+ ***************************************************************************/
+
+/***************************************************************************
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ ***************************************************************************/
+
+#include <kurldrag.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kdebug.h>
+#include <kpopupmenu.h>
+#include <kiconloader.h>
+#include <kconfig.h>
+#include <kaction.h>
+#include <kurl.h>
+
+#include "collectionlist.h"
+#include "playlistcollection.h"
+#include "splashscreen.h"
+#include "stringshare.h"
+#include "cache.h"
+#include "actioncollection.h"
+#include "tag.h"
+#include "viewmode.h"
+#include "coverinfo.h"
+#include "covermanager.h"
+
+using namespace ActionCollection;
+
+////////////////////////////////////////////////////////////////////////////////
+// static methods
+////////////////////////////////////////////////////////////////////////////////
+
+CollectionList *CollectionList::m_list = 0;
+
+CollectionList *CollectionList::instance()
+{
+ return m_list;
+}
+
+void CollectionList::initialize(PlaylistCollection *collection)
+{
+ if(m_list)
+ return;
+
+ // We have to delay initilaization here because dynamic_cast or comparing to
+ // the collection instance won't work in the PlaylistBox::Item initialization
+ // won't work until the CollectionList is fully constructed.
+
+ m_list = new CollectionList(collection);
+ m_list->setName(i18n("Collection List"));
+
+ FileHandleHash::Iterator end = Cache::instance()->end();
+ for(FileHandleHash::Iterator it = Cache::instance()->begin(); it != end; ++it)
+ new CollectionListItem(*it);
+
+ SplashScreen::update();
+
+ // The CollectionList is created with sorting disabled for speed. Re-enable
+ // it here, and perform the sort.
+ KConfigGroup config(KGlobal::config(), "Playlists");
+
+ SortOrder order = Descending;
+ if(config.readBoolEntry("CollectionListSortAscending", true))
+ order = Ascending;
+
+ m_list->setSortOrder(order);
+ m_list->setSortColumn(config.readNumEntry("CollectionListSortColumn", 1));
+
+ m_list->sort();
+
+ collection->setupPlaylist(m_list, "folder_sound");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// public methods
+////////////////////////////////////////////////////////////////////////////////
+
+PlaylistItem *CollectionList::createItem(const FileHandle &file, QListViewItem *, bool)
+{
+ // It's probably possible to optimize the line below away, but, well, right
+ // now it's more important to not load duplicate items.
+
+ if(m_itemsDict.find(file.absFilePath()))
+ return 0;
+
+ PlaylistItem *item = new CollectionListItem(file);
+
+ if(!item->isValid()) {
+ kdError() << "CollectionList::createItem() -- A valid tag was not created for \""
+ << file.absFilePath() << "\"" << endl;
+ delete item;
+ return 0;
+ }
+
+ setupItem(item);
+
+ return item;
+}
+
+void CollectionList::clearItems(const PlaylistItemList &items)
+{
+ for(PlaylistItemList::ConstIterator it = items.begin(); it != items.end(); ++it) {
+ Cache::instance()->remove((*it)->file());
+ clearItem(*it, false);
+ }
+
+ dataChanged();
+}
+
+void CollectionList::setupTreeViewEntries(ViewMode *viewMode) const
+{
+ TreeViewMode *treeViewMode = dynamic_cast<TreeViewMode *>(viewMode);
+ if(!treeViewMode) {
+ kdWarning(65432) << "Can't setup entries on a non-tree-view mode!\n";
+ return;
+ }
+
+ QValueList<int> columnList;
+ columnList << PlaylistItem::ArtistColumn;
+ columnList << PlaylistItem::GenreColumn;
+ columnList << PlaylistItem::AlbumColumn;
+
+ QStringList items;
+ for(QValueList<int>::Iterator colIt = columnList.begin(); colIt != columnList.end(); ++colIt) {
+ items.clear();
+ for(TagCountDictIterator it(*m_columnTags[*colIt]); it.current(); ++it)
+ items << it.currentKey();
+
+ treeViewMode->addItems(items, *colIt);
+ }
+}
+
+void CollectionList::slotNewItems(const KFileItemList &items)
+{
+ QStringList files;
+
+ for(KFileItemListIterator it(items); it.current(); ++it)
+ files.append((*it)->url().path());
+
+ addFiles(files);
+ update();
+}
+
+void CollectionList::slotRefreshItems(const KFileItemList &items)
+{
+ for(KFileItemListIterator it(items); it.current(); ++it) {
+ CollectionListItem *item = lookup((*it)->url().path());
+
+ if(item) {
+ item->refreshFromDisk();
+
+ // If the item is no longer on disk, remove it from the collection.
+
+ if(item->file().fileInfo().exists())
+ item->repaint();
+ else
+ clearItem(item);
+ }
+ }
+
+ update();
+}
+
+void CollectionList::slotDeleteItem(KFileItem *item)
+{
+ CollectionListItem *listItem = lookup(item->url().path());
+ if(listItem)
+ clearItem(listItem);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// public slots
+////////////////////////////////////////////////////////////////////////////////
+
+void CollectionList::clear()
+{
+ int result = KMessageBox::warningContinueCancel(this,
+ i18n("Removing an item from the collection will also remove it from "
+ "all of your playlists. Are you sure you want to continue?\n\n"
+ "Note, however, that if the directory that these files are in is in "
+ "your \"scan on startup\" list, they will be readded on startup."));
+
+ if(result == KMessageBox::Continue) {
+ Playlist::clear();
+ emit signalCollectionChanged();
+ }
+}
+
+void CollectionList::slotCheckCache()
+{
+ PlaylistItemList invalidItems;
+
+ for(QDictIterator<CollectionListItem>it(m_itemsDict); it.current(); ++it) {
+ if(!it.current()->checkCurrent())
+ invalidItems.append(*it);
+ processEvents();
+ }
+
+ clearItems(invalidItems);
+}
+
+void CollectionList::slotRemoveItem(const QString &file)
+{
+ clearItem(m_itemsDict[file]);
+}
+
+void CollectionList::slotRefreshItem(const QString &file)
+{
+ m_itemsDict[file]->refresh();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// protected methods
+////////////////////////////////////////////////////////////////////////////////
+
+CollectionList::CollectionList(PlaylistCollection *collection) :
+ Playlist(collection, true),
+ m_itemsDict(5003),
+ m_columnTags(15, 0)
+{
+ new KAction(i18n("Show Playing"), KShortcut(), actions(), "showPlaying");
+
+ connect(action("showPlaying"), SIGNAL(activated()), this, SLOT(slotShowPlaying()));
+
+ connect(action<KToolBarPopupAction>("back")->popupMenu(), SIGNAL(aboutToShow()),
+ this, SLOT(slotPopulateBackMenu()));
+ connect(action<KToolBarPopupAction>("back")->popupMenu(), SIGNAL(activated(int)),
+ this, SLOT(slotPlayFromBackMenu(int)));
+ setSorting(-1); // Temporarily disable sorting to add items faster.
+
+ m_columnTags[PlaylistItem::ArtistColumn] = new TagCountDict(5001, false);
+ m_columnTags[PlaylistItem::ArtistColumn]->setAutoDelete(true);
+
+ m_columnTags[PlaylistItem::AlbumColumn] = new TagCountDict(5001, false);
+ m_columnTags[PlaylistItem::AlbumColumn]->setAutoDelete(true);
+
+ m_columnTags[PlaylistItem::GenreColumn] = new TagCountDict(5001, false);
+ m_columnTags[PlaylistItem::GenreColumn]->setAutoDelete(true);
+
+ polish();
+}
+
+CollectionList::~CollectionList()
+{
+ KConfigGroup config(KGlobal::config(), "Playlists");
+ config.writeEntry("CollectionListSortColumn", sortColumn());
+ config.writeEntry("CollectionListSortAscending", sortOrder() == Ascending);
+
+ // The CollectionListItems will try to remove themselves from the
+ // m_columnTags member, so we must make sure they're gone before we
+ // are.
+
+ clearItems(items());
+ for(TagCountDicts::Iterator it = m_columnTags.begin(); it != m_columnTags.end(); ++it)
+ delete *it;
+}
+
+void CollectionList::contentsDropEvent(QDropEvent *e)
+{
+ if(e->source() == this)
+ return; // Don't rearrange in the CollectionList.
+ else
+ Playlist::contentsDropEvent(e);
+}
+
+void CollectionList::contentsDragMoveEvent(QDragMoveEvent *e)
+{
+ if(canDecode(e) && e->source() != this)
+ e->accept(true);
+ else
+ e->accept(false);
+}
+
+QString CollectionList::addStringToDict(const QString &value, unsigned column)
+{
+ if(column > m_columnTags.count() || value.stripWhiteSpace().isEmpty())
+ return QString::null;
+
+ int *refCountPtr = m_columnTags[column]->find(value);
+ if(refCountPtr)
+ ++(*refCountPtr);
+ else {
+ m_columnTags[column]->insert(value, new int(1));
+ emit signalNewTag(value, column);
+ }
+
+ return value;
+}
+
+QStringList CollectionList::uniqueSet(UniqueSetType t) const
+{
+ int column;
+
+ switch(t)
+ {
+ case Artists:
+ column = PlaylistItem::ArtistColumn;
+ break;
+
+ case Albums:
+ column = PlaylistItem::AlbumColumn;
+ break;
+
+ case Genres:
+ column = PlaylistItem::GenreColumn;
+ break;
+
+ default:
+ return QStringList();
+ }
+
+ if((unsigned) column >= m_columnTags.count())
+ return QStringList();
+
+ TagCountDictIterator it(*m_columnTags[column]);
+ QStringList list;
+
+ for(; it.current(); ++it)
+ list += it.currentKey();
+
+ return list;
+}
+
+void CollectionList::removeStringFromDict(const QString &value, unsigned column)
+{
+ if(column > m_columnTags.count() || value.isEmpty())
+ return;
+
+ int *refCountPtr = m_columnTags[column]->find(value);
+ if(refCountPtr) {
+ --(*refCountPtr);
+ if(*refCountPtr == 0) {
+ emit signalRemovedTag(value, column);
+ m_columnTags[column]->remove(value);
+ }
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// CollectionListItem public methods
+////////////////////////////////////////////////////////////////////////////////
+
+void CollectionListItem::refresh()
+{
+ int offset = static_cast<Playlist *>(listView())->columnOffset();
+ int columns = lastColumn() + offset + 1;
+
+ data()->local8Bit.resize(columns);
+ data()->cachedWidths.resize(columns);
+
+ for(int i = offset; i < columns; i++) {
+ int id = i - offset;
+ if(id != TrackNumberColumn && id != LengthColumn) {
+ // All columns other than track num and length need local-encoded data for sorting
+
+ QCString lower = text(i).lower().local8Bit();
+
+ // For some columns, we may be able to share some strings
+
+ if((id == ArtistColumn) || (id == AlbumColumn) ||
+ (id == GenreColumn) || (id == YearColumn) ||
+ (id == CommentColumn))
+ {
+ lower = StringShare::tryShare(lower);
+
+ if(id != YearColumn && id != CommentColumn && data()->local8Bit[id] != lower) {
+ CollectionList::instance()->removeStringFromDict(data()->local8Bit[id], id);
+ CollectionList::instance()->addStringToDict(text(i), id);
+ }
+ }
+
+ data()->local8Bit[id] = lower;
+ }
+
+ int newWidth = width(listView()->fontMetrics(), listView(), i);
+ data()->cachedWidths[i] = newWidth;
+
+ if(newWidth != data()->cachedWidths[i])
+ playlist()->slotWeightDirty(i);
+ }
+
+ file().coverInfo()->setCover();
+
+ if(listView()->isVisible())
+ repaint();
+
+ for(PlaylistItemList::Iterator it = m_children.begin(); it != m_children.end(); ++it) {
+ (*it)->playlist()->update();
+ (*it)->playlist()->dataChanged();
+ if((*it)->listView()->isVisible())
+ (*it)->repaint();
+ }
+
+ CollectionList::instance()->dataChanged();
+ emit CollectionList::instance()->signalCollectionChanged();
+}
+
+PlaylistItem *CollectionListItem::itemForPlaylist(const Playlist *playlist)
+{
+ if(playlist == CollectionList::instance())
+ return this;
+
+ PlaylistItemList::ConstIterator it;
+ for(it = m_children.begin(); it != m_children.end(); ++it)
+ if((*it)->playlist() == playlist)
+ return *it;
+ return 0;
+}
+
+void CollectionListItem::updateCollectionDict(const QString &oldPath, const QString &newPath)
+{
+ CollectionList *collection = CollectionList::instance();
+
+ if(!collection)
+ return;
+
+ collection->removeFromDict(oldPath);
+ collection->addToDict(newPath, this);
+}
+
+void CollectionListItem::repaint() const
+{
+ QListViewItem::repaint();
+ for(PlaylistItemList::ConstIterator it = m_children.begin(); it != m_children.end(); ++it)
+ (*it)->repaint();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// CollectionListItem protected methods
+////////////////////////////////////////////////////////////////////////////////
+
+CollectionListItem::CollectionListItem(const FileHandle &file) :
+ PlaylistItem(CollectionList::instance()),
+ m_shuttingDown(false)
+{
+ CollectionList *l = CollectionList::instance();
+ if(l) {
+ l->addToDict(file.absFilePath(), this);
+
+ data()->fileHandle = file;
+
+ if(file.tag()) {
+ refresh();
+ l->dataChanged();
+ // l->addWatched(m_path);
+ }
+ else
+ kdError() << "CollectionListItem::CollectionListItem() -- Tag() could not be created." << endl;
+ }
+ else
+ kdError(65432) << "CollectionListItems should not be created before "
+ << "CollectionList::initialize() has been called." << endl;
+
+ SplashScreen::increment();
+}
+
+CollectionListItem::~CollectionListItem()
+{
+ m_shuttingDown = true;
+
+ for(PlaylistItemList::ConstIterator it = m_children.begin();
+ it != m_children.end();
+ ++it)
+ {
+ (*it)->playlist()->clearItem(*it);
+ }
+
+ CollectionList *l = CollectionList::instance();
+ if(l) {
+ l->removeFromDict(file().absFilePath());
+ l->removeStringFromDict(file().tag()->album(), AlbumColumn);
+ l->removeStringFromDict(file().tag()->artist(), ArtistColumn);
+ l->removeStringFromDict(file().tag()->genre(), GenreColumn);
+ }
+}
+
+void CollectionListItem::addChildItem(PlaylistItem *child)
+{
+ m_children.append(child);
+}
+
+void CollectionListItem::removeChildItem(PlaylistItem *child)
+{
+ if(!m_shuttingDown)
+ m_children.remove(child);
+}
+
+bool CollectionListItem::checkCurrent()
+{
+ if(!file().fileInfo().exists() || !file().fileInfo().isFile())
+ return false;
+
+ if(!file().current()) {
+ file().refresh();
+ refresh();
+ }
+
+ return true;
+}
+
+#include "collectionlist.moc"