TDE
/
tdemultimedia
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdemultimedia
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '537ccfa7e6'
${ noResults }
tdemultimedia/juk/playlist.cpp

2362 lines
62 KiB
Raw Blame History

/***************************************************************************
begin : Sat Feb 16 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 <kconfig.h>
#include <kmessagebox.h>
#include <kurldrag.h>
#include <kiconloader.h>
#include <klineedit.h>
#include <kaction.h>
#include <kpopupmenu.h>
#include <klocale.h>
#include <kdebug.h>
#include <kinputdialog.h>
#include <kfiledialog.h>
#include <kglobalsettings.h>
#include <kurl.h>
#include <kio/netaccess.h>
#include <kio/job.h>
#include <dcopclient.h>
#include <tqheader.h>
#include <tqcursor.h>
#include <tqdir.h>
#include <tqeventloop.h>
#include <tqtooltip.h>
#include <tqwidgetstack.h>
#include <tqfile.h>
#include <tqhbox.h>
#include <id3v1genres.h>
#include <time.h>
#include <math.h>
#include <dirent.h>
#include "playlist.h"
#include "playlistitem.h"
#include "playlistcollection.h"
#include "playlistsearch.h"
#include "mediafiles.h"
#include "collectionlist.h"
#include "filerenamer.h"
#include "actioncollection.h"
#include "tracksequencemanager.h"
#include "juk.h"
#include "tag.h"
#include "k3bexporter.h"
#include "upcomingplaylist.h"
#include "deletedialog.h"
#include "webimagefetcher.h"
#include "coverinfo.h"
#include "coverdialog.h"
#include "tagtransactionmanager.h"
#include "cache.h"
using namespace ActionCollection;
/**
* Just a shortcut of sorts.
*/
static bool manualResize()
{
return action<KToggleAction>("resizeColumnsManually")->isChecked();
}
/**
* A tooltip specialized to show full filenames over the file name column.
*/
class PlaylistToolTip : public TQToolTip
{
public:
PlaylistToolTip(TQWidget *parent, Playlist *playlist) :
TQToolTip(parent), m_playlist(playlist) {}
virtual void maybeTip(const TQPoint &p)
{
PlaylistItem *item = static_cast<PlaylistItem *>(m_playlist->itemAt(p));
if(!item)
return;
TQPoint contentsPosition = m_playlist->viewportToContents(p);
int column = m_playlist->header()->sectionAt(contentsPosition.x());
if(column == m_playlist->columnOffset() + PlaylistItem::FileNameColumn ||
item->cachedWidths()[column] > m_playlist->columnWidth(column) ||
(column == m_playlist->columnOffset() + PlaylistItem::CoverColumn &&
item->file().coverInfo()->hasCover()))
{
TQRect r = m_playlist->itemRect(item);
int headerPosition = m_playlist->header()->sectionPos(column);
r.setLeft(headerPosition);
r.setRight(headerPosition + m_playlist->header()->sectionSize(column));
if(column == m_playlist->columnOffset() + PlaylistItem::FileNameColumn)
tip(r, item->file().absFilePath());
else if(column == m_playlist->columnOffset() + PlaylistItem::CoverColumn) {
TQMimeSourceFactory *f = TQMimeSourceFactory::defaultFactory();
f->setImage("coverThumb",
TQImage(item->file().coverInfo()->pixmap(CoverInfo::Thumbnail).convertToImage()));
tip(r, "<center><img source=\"coverThumb\"/></center>");
}
else
tip(r, item->text(column));
}
}
private:
Playlist *m_playlist;
};
////////////////////////////////////////////////////////////////////////////////
// Playlist::SharedSettings definition
////////////////////////////////////////////////////////////////////////////////
bool Playlist::m_visibleChanged = false;
bool Playlist::m_shuttingDown = false;
/**
* Shared settings between the playlists.
*/
class Playlist::SharedSettings
{
public:
static SharedSettings *instance();
/**
* Sets the default column order to that of Playlist @param p.
*/
void setColumnOrder(const Playlist *l);
void toggleColumnVisible(int column);
void setInlineCompletionMode(KGlobalSettings::Completion mode);
/**
* Apply the settings.
*/
void apply(Playlist *l) const;
void sync() { writeConfig(); }
protected:
SharedSettings();
~SharedSettings() {}
private:
void writeConfig();
static SharedSettings *m_instance;
TQValueList<int> m_columnOrder;
TQValueVector<bool> m_columnsVisible;
KGlobalSettings::Completion m_inlineCompletion;
};
Playlist::SharedSettings *Playlist::SharedSettings::m_instance = 0;
////////////////////////////////////////////////////////////////////////////////
// Playlist::SharedSettings public members
////////////////////////////////////////////////////////////////////////////////
Playlist::SharedSettings *Playlist::SharedSettings::instance()
{
static SharedSettings settings;
return &settings;
}
void Playlist::SharedSettings::setColumnOrder(const Playlist *l)
{
if(!l)
return;
m_columnOrder.clear();
for(int i = l->columnOffset(); i < l->columns(); ++i)
m_columnOrder.append(l->header()->mapToIndex(i));
writeConfig();
}
void Playlist::SharedSettings::toggleColumnVisible(int column)
{
if(column >= int(m_columnsVisible.size()))
m_columnsVisible.resize(column + 1, true);
m_columnsVisible[column] = !m_columnsVisible[column];
writeConfig();
}
void Playlist::SharedSettings::setInlineCompletionMode(KGlobalSettings::Completion mode)
{
m_inlineCompletion = mode;
writeConfig();
}
void Playlist::SharedSettings::apply(Playlist *l) const
{
if(!l)
return;
int offset = l->columnOffset();
int i = 0;
for(TQValueListConstIterator<int> it = m_columnOrder.begin(); it != m_columnOrder.end(); ++it)
l->header()->moveSection(i++ + offset, *it + offset);
for(uint i = 0; i < m_columnsVisible.size(); i++) {
if(m_columnsVisible[i] && !l->isColumnVisible(i + offset))
l->showColumn(i + offset, false);
else if(!m_columnsVisible[i] && l->isColumnVisible(i + offset))
l->hideColumn(i + offset, false);
}
l->updateLeftColumn();
l->renameLineEdit()->setCompletionMode(m_inlineCompletion);
l->slotColumnResizeModeChanged();
}
////////////////////////////////////////////////////////////////////////////////
// Playlist::ShareSettings protected members
////////////////////////////////////////////////////////////////////////////////
Playlist::SharedSettings::SharedSettings()
{
KConfigGroup config(KGlobal::config(), "PlaylistShared");
bool resizeColumnsManually = config.readBoolEntry("ResizeColumnsManually", false);
action<KToggleAction>("resizeColumnsManually")->setChecked(resizeColumnsManually);
// save column order
m_columnOrder = config.readIntListEntry("ColumnOrder");
TQValueList<int> l = config.readIntListEntry("VisibleColumns");
if(l.isEmpty()) {
// Provide some default values for column visibility if none were
// read from the configuration file.
for(int i = 0; i <= PlaylistItem::lastColumn(); i++) {
switch(i) {
case PlaylistItem::BitrateColumn:
case PlaylistItem::CommentColumn:
case PlaylistItem::FileNameColumn:
case PlaylistItem::FullPathColumn:
m_columnsVisible.append(false);
break;
default:
m_columnsVisible.append(true);
}
}
}
else {
// Convert the int list into a bool list.
m_columnsVisible.resize(l.size(), true);
uint i = 0;
for(TQValueList<int>::Iterator it = l.begin(); it != l.end(); ++it) {
if(! bool(*it))
m_columnsVisible[i] = bool(*it);
i++;
}
}
m_inlineCompletion = KGlobalSettings::Completion(
config.readNumEntry("InlineCompletionMode", KGlobalSettings::CompletionAuto));
}
////////////////////////////////////////////////////////////////////////////////
// Playlist::SharedSettings private members
////////////////////////////////////////////////////////////////////////////////
void Playlist::SharedSettings::writeConfig()
{
KConfigGroup config(KGlobal::config(), "PlaylistShared");
config.writeEntry("ColumnOrder", m_columnOrder);
TQValueList<int> l;
for(uint i = 0; i < m_columnsVisible.size(); i++)
l.append(int(m_columnsVisible[i]));
config.writeEntry("VisibleColumns", l);
config.writeEntry("InlineCompletionMode", m_inlineCompletion);
config.writeEntry("ResizeColumnsManually", manualResize());
KGlobal::config()->sync();
}
////////////////////////////////////////////////////////////////////////////////
// public members
////////////////////////////////////////////////////////////////////////////////
PlaylistItemList Playlist::m_history;
TQMap<int, PlaylistItem *> Playlist::m_backMenuItems;
int Playlist::m_leftColumn = 0;
Playlist::Playlist(PlaylistCollection *collection, const TQString &name,
const TQString &iconName) :
KListView(collection->playlistStack(), name.latin1()),
m_collection(collection),
m_fetcher(new WebImageFetcher(TQT_TQOBJECT(this))),
m_selectedCount(0),
m_allowDuplicates(false),
m_polished(false),
m_applySharedSettings(true),
m_columnWidthModeChanged(false),
m_disableColumnWidthUpdates(true),
m_time(0),
m_widthsDirty(true),
m_searchEnabled(true),
m_lastSelected(0),
m_playlistName(name),
m_rmbMenu(0),
m_toolTip(0),
m_blockDataChanged(false)
{
setup();
collection->setupPlaylist(this, iconName);
}
Playlist::Playlist(PlaylistCollection *collection, const PlaylistItemList &items,
const TQString &name, const TQString &iconName) :
KListView(collection->playlistStack(), name.latin1()),
m_collection(collection),
m_fetcher(new WebImageFetcher(TQT_TQOBJECT(this))),
m_selectedCount(0),
m_allowDuplicates(false),
m_polished(false),
m_applySharedSettings(true),
m_columnWidthModeChanged(false),
m_disableColumnWidthUpdates(true),
m_time(0),
m_widthsDirty(true),
m_searchEnabled(true),
m_lastSelected(0),
m_playlistName(name),
m_rmbMenu(0),
m_toolTip(0),
m_blockDataChanged(false)
{
setup();
collection->setupPlaylist(this, iconName);
createItems(items);
}
Playlist::Playlist(PlaylistCollection *collection, const TQFileInfo &playlistFile,
const TQString &iconName) :
KListView(collection->playlistStack()),
m_collection(collection),
m_fetcher(new WebImageFetcher(TQT_TQOBJECT(this))),
m_selectedCount(0),
m_allowDuplicates(false),
m_polished(false),
m_applySharedSettings(true),
m_columnWidthModeChanged(false),
m_disableColumnWidthUpdates(true),
m_time(0),
m_widthsDirty(true),
m_searchEnabled(true),
m_lastSelected(0),
m_fileName(playlistFile.absFilePath()),
m_rmbMenu(0),
m_toolTip(0),
m_blockDataChanged(false)
{
setup();
loadFile(m_fileName, playlistFile);
collection->setupPlaylist(this, iconName);
}
Playlist::Playlist(PlaylistCollection *collection, bool delaySetup) :
KListView(collection->playlistStack()),
m_collection(collection),
m_fetcher(new WebImageFetcher(TQT_TQOBJECT(this))),
m_selectedCount(0),
m_allowDuplicates(false),
m_polished(false),
m_applySharedSettings(true),
m_columnWidthModeChanged(false),
m_disableColumnWidthUpdates(true),
m_time(0),
m_widthsDirty(true),
m_searchEnabled(true),
m_lastSelected(0),
m_rmbMenu(0),
m_toolTip(0),
m_blockDataChanged(false)
{
setup();
if(!delaySetup)
collection->setupPlaylist(this, "midi");
}
Playlist::~Playlist()
{
// clearItem() will take care of removing the items from the history,
// so call clearItems() to make sure it happens.
clearItems(items());
delete m_toolTip;
// Select a different playlist if we're the selected one
if(isVisible() && this != CollectionList::instance())
m_collection->raise(CollectionList::instance());
if(!m_shuttingDown)
m_collection->removePlaylist(this);
}
TQString Playlist::name() const
{
if(m_playlistName.isNull())
return m_fileName.section(TQDir::separator(), -1).section('.', 0, -2);
else
return m_playlistName;
}
FileHandle Playlist::currentFile() const
{
return playingItem() ? playingItem()->file() : FileHandle::null();
}
int Playlist::time() const
{
// Since this method gets a lot of traffic, let's optimize for such.
if(!m_addTime.isEmpty()) {
for(PlaylistItemList::ConstIterator it = m_addTime.begin();
it != m_addTime.end(); ++it)
{
if(*it)
m_time += (*it)->file().tag()->seconds();
}
m_addTime.clear();
}
if(!m_subtractTime.isEmpty()) {
for(PlaylistItemList::ConstIterator it = m_subtractTime.begin();
it != m_subtractTime.end(); ++it)
{
if(*it)
m_time -= (*it)->file().tag()->seconds();
}
m_subtractTime.clear();
}
return m_time;
}
void Playlist::playFirst()
{
TrackSequenceManager::instance()->setNextItem(static_cast<PlaylistItem *>(
TQListViewItemIterator(const_cast<Playlist *>(this), TQListViewItemIterator::Visible).current()));
action("forward")->activate();
}
void Playlist::playNextAlbum()
{
PlaylistItem *current = TrackSequenceManager::instance()->currentItem();
if(!current)
return; // No next album if we're not already playing.
TQString currentAlbum = current->file().tag()->album();
current = TrackSequenceManager::instance()->nextItem();
while(current && current->file().tag()->album() == currentAlbum)
current = TrackSequenceManager::instance()->nextItem();
TrackSequenceManager::instance()->setNextItem(current);
action("forward")->activate();
}
void Playlist::playNext()
{
TrackSequenceManager::instance()->setCurrentPlaylist(this);
setPlaying(TrackSequenceManager::instance()->nextItem());
}
void Playlist::stop()
{
m_history.clear();
setPlaying(0);
}
void Playlist::playPrevious()
{
if(!playingItem())
return;
bool random = action("randomPlay") && action<KToggleAction>("randomPlay")->isChecked();
PlaylistItem *previous = 0;
if(random && !m_history.isEmpty()) {
PlaylistItemList::Iterator last = m_history.fromLast();
previous = *last;
m_history.remove(last);
}
else {
m_history.clear();
previous = TrackSequenceManager::instance()->previousItem();
}
if(!previous)
previous = static_cast<PlaylistItem *>(playingItem()->itemAbove());
setPlaying(previous, false);
}
void Playlist::setName(const TQString &n)
{
m_collection->addNameToDict(n);
m_collection->removeNameFromDict(m_playlistName);
m_playlistName = n;
emit signalNameChanged(m_playlistName);
}
void Playlist::save()
{
if(m_fileName.isEmpty())
return saveAs();
TQFile file(m_fileName);
if(!file.open(IO_WriteOnly))
return KMessageBox::error(this, i18n("Could not save to file %1.").arg(m_fileName));
TQTextStream stream(&file);
TQStringList fileList = files();
for(TQStringList::Iterator it = fileList.begin(); it != fileList.end(); ++it)
stream << *it << endl;
file.close();
}
void Playlist::saveAs()
{
m_collection->removeFileFromDict(m_fileName);
m_fileName = MediaFiles::savePlaylistDialog(name(), this);
if(!m_fileName.isEmpty()) {
m_collection->addFileToDict(m_fileName);
// If there's no playlist name set, use the file name.
if(m_playlistName.isEmpty())
emit signalNameChanged(name());
save();
}
}
void Playlist::clearItem(PlaylistItem *item, bool emitChanged)
{
emit signalAboutToRemove(item);
m_members.remove(item->file().absFilePath());
m_search.clearItem(item);
m_history.remove(item);
m_addTime.remove(item);
m_subtractTime.remove(item);
delete item;
if(emitChanged)
dataChanged();
}
void Playlist::clearItems(const PlaylistItemList &items)
{
m_blockDataChanged = true;
for(PlaylistItemList::ConstIterator it = items.begin(); it != items.end(); ++it)
clearItem(*it, false);
m_blockDataChanged = false;
dataChanged();
}
PlaylistItem *Playlist::playingItem() // static
{
return PlaylistItem::playingItems().isEmpty() ? 0 : PlaylistItem::playingItems().front();
}
TQStringList Playlist::files() const
{
TQStringList list;
for(TQListViewItemIterator it(const_cast<Playlist *>(this)); it.current(); ++it)
list.append(static_cast<PlaylistItem *>(*it)->file().absFilePath());
return list;
}
PlaylistItemList Playlist::items()
{
return items(TQListViewItemIterator::IteratorFlag(0));
}
PlaylistItemList Playlist::visibleItems()
{
return items(TQListViewItemIterator::Visible);
}
PlaylistItemList Playlist::selectedItems()
{
PlaylistItemList list;
switch(m_selectedCount) {
case 0:
break;
// case 1:
// list.append(m_lastSelected);
// break;
default:
list = items(TQListViewItemIterator::IteratorFlag(TQListViewItemIterator::Selected |
TQListViewItemIterator::Visible));
break;
}
return list;
}
PlaylistItem *Playlist::firstChild() const
{
return static_cast<PlaylistItem *>(KListView::firstChild());
}
void Playlist::updateLeftColumn()
{
int newLeftColumn = leftMostVisibleColumn();
if(m_leftColumn != newLeftColumn) {
updatePlaying();
m_leftColumn = newLeftColumn;
}
}
void Playlist::setItemsVisible(const PlaylistItemList &items, bool visible) // static
{
m_visibleChanged = true;
for(PlaylistItemList::ConstIterator it = items.begin(); it != items.end(); ++it)
(*it)->setVisible(visible);
}
void Playlist::setSearch(const PlaylistSearch &s)
{
m_search = s;
if(!m_searchEnabled)
return;
setItemsVisible(s.matchedItems(), true);
setItemsVisible(s.unmatchedItems(), false);
TrackSequenceManager::instance()->iterator()->playlistChanged();
}
void Playlist::setSearchEnabled(bool enabled)
{
if(m_searchEnabled == enabled)
return;
m_searchEnabled = enabled;
if(enabled) {
setItemsVisible(m_search.matchedItems(), true);
setItemsVisible(m_search.unmatchedItems(), false);
}
else
setItemsVisible(items(), true);
}
void Playlist::markItemSelected(PlaylistItem *item, bool selected)
{
if(selected && !item->isSelected()) {
m_selectedCount++;
m_lastSelected = item;
}
else if(!selected && item->isSelected())
m_selectedCount--;
}
void Playlist::synchronizePlayingItems(const PlaylistList &sources, bool setMaster)
{
for(PlaylistList::ConstIterator it = sources.begin(); it != sources.end(); ++it) {
if((*it)->playing()) {
CollectionListItem *base = playingItem()->collectionItem();
for(TQListViewItemIterator itemIt(this); itemIt.current(); ++itemIt) {
PlaylistItem *item = static_cast<PlaylistItem *>(itemIt.current());
if(base == item->collectionItem()) {
item->setPlaying(true, setMaster);
PlaylistItemList playing = PlaylistItem::playingItems();
TrackSequenceManager::instance()->setCurrent(item);
return;
}
}
return;
}
}
}
////////////////////////////////////////////////////////////////////////////////
// public slots
////////////////////////////////////////////////////////////////////////////////
void Playlist::copy()
{
kapp->tqclipboard()->setData(dragObject(0), TQClipboard::Clipboard);
}
void Playlist::paste()
{
decode(kapp->tqclipboard()->data(), static_cast<PlaylistItem *>(currentItem()));
}
void Playlist::clear()
{
PlaylistItemList l = selectedItems();
if(l.isEmpty())
l = items();
clearItems(l);
}
void Playlist::slotRefresh()
{
PlaylistItemList l = selectedItems();
if(l.isEmpty())
l = visibleItems();
KApplication::setOverrideCursor(TQt::waitCursor);
for(PlaylistItemList::Iterator it = l.begin(); it != l.end(); ++it) {
(*it)->refreshFromDisk();
if(!(*it)->file().tag() || !(*it)->file().fileInfo().exists()) {
kdDebug(65432) << "Error while trying to refresh the tag. "
<< "This file has probably been removed."
<< endl;
clearItem((*it)->collectionItem());
}
processEvents();
}
KApplication::restoreOverrideCursor();
}
void Playlist::slotRenameFile()
{
FileRenamer renamer;
PlaylistItemList items = selectedItems();
if(items.isEmpty())
return;
emit signalEnableDirWatch(false);
m_blockDataChanged = true;
renamer.rename(items);
m_blockDataChanged = false;
dataChanged();
emit signalEnableDirWatch(true);
}
void Playlist::slotViewCover()
{
PlaylistItemList items = selectedItems();
if (items.isEmpty())
return;
for(PlaylistItemList::Iterator it = items.begin(); it != items.end(); ++it)
(*it)->file().coverInfo()->popup();
}
void Playlist::slotRemoveCover()
{
PlaylistItemList items = selectedItems();
if(items.isEmpty())
return;
int button = KMessageBox::warningContinueCancel(this,
i18n("Are you sure you want to delete these covers?"),
TQString(),
i18n("&Delete Covers"));
if(button == KMessageBox::Continue)
refreshAlbums(items);
}
void Playlist::slotShowCoverManager()
{
static CoverDialog *managerDialog = 0;
if(!managerDialog)
managerDialog = new CoverDialog(this);
managerDialog->show();
}
unsigned int Playlist::eligibleCoverItems(const PlaylistItemList &items)
{
// This used to count the number of tracks with an artist and album, that
// is not strictly required anymore. This may prove useful in the future
// so I'm leaving it in for now, right now we just mark every item as
// eligible.
return items.count();
}
void Playlist::slotAddCover(bool retrieveLocal)
{
PlaylistItemList items = selectedItems();
if(items.isEmpty())
return;
if(eligibleCoverItems(items) == 0) {
// No items in the list can be assigned a cover, inform the user and
// bail.
// KDE 4.0 Fix this string.
KMessageBox::sorry(this, i18n("None of the items you have selected can "
"be assigned a cover. A track must have both the Artist "
"and Album tags set to be assigned a cover."));
return;
}
TQPixmap newCover;
if(retrieveLocal) {
KURL file = KFileDialog::getImageOpenURL(
":homedir", this, i18n("Select Cover Image File"));
newCover = TQPixmap(file.directory() + "/" + file.fileName());
}
else {
m_fetcher->setFile((*items.begin())->file());
m_fetcher->chooseCover();
return;
}
if(newCover.isNull())
return;
TQString artist = items.front()->file().tag()->artist();
TQString album = items.front()->file().tag()->album();
coverKey newId = CoverManager::addCover(newCover, artist, album);
refreshAlbums(items, newId);
}
// Called when image fetcher has added a new cover.
void Playlist::slotCoverChanged(int coverId)
{
kdDebug(65432) << "Refreshing information for newly changed covers.\n";
refreshAlbums(selectedItems(), coverId);
}
void Playlist::slotGuessTagInfo(TagGuesser::Type type)
{
KApplication::setOverrideCursor(TQt::waitCursor);
PlaylistItemList items = selectedItems();
setDynamicListsFrozen(true);
m_blockDataChanged = true;
for(PlaylistItemList::Iterator it = items.begin(); it != items.end(); ++it) {
(*it)->guessTagInfo(type);
processEvents();
}
// MusicBrainz queries automatically commit at this point. What would
// be nice is having a signal emitted when the last query is completed.
if(type == TagGuesser::FileName)
TagTransactionManager::instance()->commit();
m_blockDataChanged = false;
dataChanged();
setDynamicListsFrozen(false);
KApplication::restoreOverrideCursor();
}
void Playlist::slotReload()
{
TQFileInfo fileInfo(m_fileName);
if(!fileInfo.exists() || !fileInfo.isFile() || !fileInfo.isReadable())
return;
clearItems(items());
loadFile(m_fileName, fileInfo);
}
void Playlist::slotWeightDirty(int column)
{
if(column < 0) {
m_weightDirty.clear();
for(int i = 0; i < columns(); i++) {
if(isColumnVisible(i))
m_weightDirty.append(i);
}
return;
}
if(m_weightDirty.find(column) == m_weightDirty.end())
m_weightDirty.append(column);
}
void Playlist::slotShowPlaying()
{
if(!playingItem())
return;
Playlist *l = playingItem()->playlist();
l->clearSelection();
// Raise the playlist before selecting the items otherwise the tag editor
// will not update when it gets the selectionChanged() notification
// because it will think the user is choosing a different playlist but not
// selecting a different item.
m_collection->raise(l);
l->setSelected(playingItem(), true);
l->setCurrentItem(playingItem());
l->ensureItemVisible(playingItem());
}
void Playlist::slotColumnResizeModeChanged()
{
if(manualResize())
setHScrollBarMode(Auto);
else
setHScrollBarMode(AlwaysOff);
if(!manualResize())
slotUpdateColumnWidths();
SharedSettings::instance()->sync();
}
void Playlist::dataChanged()
{
if(m_blockDataChanged)
return;
PlaylistInterface::dataChanged();
}
////////////////////////////////////////////////////////////////////////////////
// protected members
////////////////////////////////////////////////////////////////////////////////
void Playlist::removeFromDisk(const PlaylistItemList &items)
{
if(isVisible() && !items.isEmpty()) {
TQStringList files;
for(PlaylistItemList::ConstIterator it = items.begin(); it != items.end(); ++it)
files.append((*it)->file().absFilePath());
DeleteDialog dialog(this);
m_blockDataChanged = true;
if(dialog.confirmDeleteList(files)) {
bool shouldDelete = dialog.shouldDelete();
TQStringList errorFiles;
for(PlaylistItemList::ConstIterator it = items.begin(); it != items.end(); ++it) {
if(playingItem() == *it)
action("forward")->activate();
TQString removePath = (*it)->file().absFilePath();
if((!shouldDelete && KIO::NetAccess::synchronousRun(KIO::trash(removePath), this)) ||
(shouldDelete && TQFile::remove(removePath)))
{
CollectionList::instance()->clearItem((*it)->collectionItem());
}
else
errorFiles.append((*it)->file().absFilePath());
}
if(!errorFiles.isEmpty()) {
TQString errorMsg = shouldDelete ?
i18n("Could not delete these files") :
i18n("Could not move these files to the Trash");
KMessageBox::errorList(this, errorMsg, errorFiles);
}
}
m_blockDataChanged = false;
dataChanged();
}
}
TQDragObject *Playlist::dragObject(TQWidget *parent)
{
PlaylistItemList items = selectedItems();
KURL::List urls;
for(PlaylistItemList::Iterator it = items.begin(); it != items.end(); ++it) {
KURL url;
url.setPath((*it)->file().absFilePath());
urls.append(url);
}
KURLDrag *drag = new KURLDrag(urls, parent, "Playlist Items");
drag->setPixmap(BarIcon("sound"));
return drag;
}
void Playlist::contentsDragEnterEvent(TQDragEnterEvent *e)
{
KListView::contentsDragEnterEvent(e);
if(CoverDrag::canDecode(e)) {
setDropHighlighter(true);
setDropVisualizer(false);
e->accept();
return;
}
setDropHighlighter(false);
setDropVisualizer(true);
KURL::List urls;
if(!KURLDrag::decode(e, urls) || urls.isEmpty()) {
e->ignore();
return;
}
e->accept();
return;
}
bool Playlist::acceptDrag(TQDropEvent *e) const
{
return CoverDrag::canDecode(e) || KURLDrag::canDecode(e);
}
bool Playlist::canDecode(TQMimeSource *s)
{
KURL::List urls;
if(CoverDrag::canDecode(s))
return true;
return KURLDrag::decode(s, urls) && !urls.isEmpty();
}
void Playlist::decode(TQMimeSource *s, PlaylistItem *item)
{
KURL::List urls;
if(!KURLDrag::decode(s, urls) || urls.isEmpty())
return;
// handle dropped images
if(!MediaFiles::isMediaFile(urls.front().path())) {
TQString file;
if(urls.front().isLocalFile())
file = urls.front().path();
else
KIO::NetAccess::download(urls.front(), file, 0);
KMimeType::Ptr mimeType = KMimeType::findByPath(file);
if(item && mimeType->name().startsWith("image/")) {
item->file().coverInfo()->setCover(TQImage(file));
refreshAlbum(item->file().tag()->artist(),
item->file().tag()->album());
}
KIO::NetAccess::removeTempFile(file);
}
TQStringList fileList;
for(KURL::List::Iterator it = urls.begin(); it != urls.end(); ++it)
fileList += MediaFiles::convertURLsToLocal((*it).path(), this);
addFiles(fileList, item);
}
bool Playlist::eventFilter(TQObject *watched, TQEvent *e)
{
if(TQT_BASE_OBJECT(watched) == TQT_BASE_OBJECT(header())) {
switch(e->type()) {
case TQEvent::MouseMove:
{
if((TQT_TQMOUSEEVENT(e)->state() & Qt::LeftButton) == Qt::LeftButton &&
!action<KToggleAction>("resizeColumnsManually")->isChecked())
{
m_columnWidthModeChanged = true;
action<KToggleAction>("resizeColumnsManually")->setChecked(true);
slotColumnResizeModeChanged();
}
break;
}
case TQEvent::MouseButtonPress:
{
if(TQT_TQMOUSEEVENT(e)->button() == Qt::RightButton)
m_headerMenu->popup(TQCursor::pos());
break;
}
case TQEvent::MouseButtonRelease:
{
if(m_columnWidthModeChanged) {
m_columnWidthModeChanged = false;
notifyUserColumnWidthModeChanged();
}
if(!manualResize() && m_widthsDirty)
TQTimer::singleShot(0, this, TQT_SLOT(slotUpdateColumnWidths()));
break;
}
default:
break;
}
}
return KListView::eventFilter(watched, e);
}
void Playlist::keyPressEvent(TQKeyEvent *event)
{
if(event->key() == Key_Up) {
TQListViewItemIterator selected(this, TQListViewItemIterator::IteratorFlag(
TQListViewItemIterator::Selected |
TQListViewItemIterator::Visible));
if(selected.current()) {
TQListViewItemIterator visible(this, TQListViewItemIterator::IteratorFlag(
TQListViewItemIterator::Visible));
if(selected.current() == visible.current())
KApplication::postEvent(parent(), new FocusUpEvent);
}
}
KListView::keyPressEvent(event);
}
void Playlist::contentsDropEvent(TQDropEvent *e)
{
TQPoint vp = contentsToViewport(e->pos());
PlaylistItem *item = static_cast<PlaylistItem *>(itemAt(vp));
// First see if we're dropping a cover, if so we can get it out of the
// way early.
if(item && CoverDrag::canDecode(e)) {
coverKey id;
CoverDrag::decode(e, id);
// If the item we dropped on is selected, apply cover to all selected
// items, otherwise just apply to the dropped item.
if(item->isSelected()) {
PlaylistItemList selItems = selectedItems();
for(PlaylistItemList::Iterator it = selItems.begin(); it != selItems.end(); ++it) {
(*it)->file().coverInfo()->setCoverId(id);
(*it)->refresh();
}
}
else {
item->file().coverInfo()->setCoverId(id);
item->refresh();
}
return;
}
// When dropping on the upper half of an item, insert before this item.
// This is what the user expects, and also allows the insertion at
// top of the list
if(!item)
item = static_cast<PlaylistItem *>(lastItem());
else if(vp.y() < item->itemPos() + item->height() / 2)
item = static_cast<PlaylistItem *>(item->itemAbove());
m_blockDataChanged = true;
if(e->source() == this) {
// Since we're trying to arrange things manually, turn off sorting.
setSorting(columns() + 1);
TQPtrList<TQListViewItem> items = KListView::selectedItems();
for(TQPtrListIterator<TQListViewItem> it(items); it.current(); ++it) {
if(!item) {
// Insert the item at the top of the list. This is a bit ugly,
// but I don't see another way.
takeItem(it.current());
insertItem(it.current());
}
else
it.current()->moveItem(item);
item = static_cast<PlaylistItem *>(it.current());
}
}
else
decode(e, item);
m_blockDataChanged = false;
dataChanged();
emit signalPlaylistItemsDropped(this);
KListView::contentsDropEvent(e);
}
void Playlist::contentsMouseDoubleClickEvent(TQMouseEvent *e)
{
// Filter out non left button double clicks, that way users don't have the
// weird experience of switching songs from a double right-click.
if(e->button() == Qt::LeftButton)
KListView::contentsMouseDoubleClickEvent(e);
}
void Playlist::showEvent(TQShowEvent *e)
{
if(m_applySharedSettings) {
SharedSettings::instance()->apply(this);
m_applySharedSettings = false;
}
KListView::showEvent(e);
}
void Playlist::applySharedSettings()
{
m_applySharedSettings = true;
}
void Playlist::read(TQDataStream &s)
{
TQString buffer;
s >> m_playlistName
>> m_fileName;
TQStringList files;
s >> files;
TQListViewItem *after = 0;
m_blockDataChanged = true;
for(TQStringList::ConstIterator it = files.begin(); it != files.end(); ++it)
after = createItem(FileHandle(*it), after, false);
m_blockDataChanged = false;
dataChanged();
m_collection->setupPlaylist(this, "midi");
}
void Playlist::viewportPaintEvent(TQPaintEvent *pe)
{
// If there are columns that need to be updated, well, update them.
if(!m_weightDirty.isEmpty() && !manualResize())
{
calculateColumnWeights();
slotUpdateColumnWidths();
}
KListView::viewportPaintEvent(pe);
}
void Playlist::viewportResizeEvent(TQResizeEvent *re)
{
// If the width of the view has changed, manually update the column
// widths.
if(re->size().width() != re->oldSize().width() && !manualResize())
slotUpdateColumnWidths();
KListView::viewportResizeEvent(re);
}
void Playlist::insertItem(TQListViewItem *item)
{
// Because we're called from the PlaylistItem ctor, item may not be a
// PlaylistItem yet (it would be TQListViewItem when being inserted. But,
// it will be a PlaylistItem by the time it matters, but be careful if
// you need to use the PlaylistItem from here.
m_addTime.append(static_cast<PlaylistItem *>(item));
KListView::insertItem(item);
}
void Playlist::takeItem(TQListViewItem *item)
{
// See the warning in Playlist::insertItem.
m_subtractTime.append(static_cast<PlaylistItem *>(item));
KListView::takeItem(item);
}
void Playlist::addColumn(const TQString &label)
{
slotWeightDirty(columns());
KListView::addColumn(label, 30);
}
PlaylistItem *Playlist::createItem(const FileHandle &file,
TQListViewItem *after, bool emitChanged)
{
return createItem<PlaylistItem, CollectionListItem, CollectionList>(file, after, emitChanged);
}
void Playlist::createItems(const PlaylistItemList &siblings, PlaylistItem *after)
{
createItems<CollectionListItem, PlaylistItem, PlaylistItem>(siblings, after);
}
void Playlist::addFiles(const TQStringList &files, PlaylistItem *after)
{
if(!after)
after = static_cast<PlaylistItem *>(lastItem());
KApplication::setOverrideCursor(TQt::waitCursor);
m_blockDataChanged = true;
FileHandleList queue;
const TQStringList::ConstIterator filesEnd = files.end();
for(TQStringList::ConstIterator it = files.begin(); it != filesEnd; ++it)
addFile(*it, queue, true, &after);
addFileHelper(queue, &after, true);
m_blockDataChanged = false;
slotWeightDirty();
dataChanged();
KApplication::restoreOverrideCursor();
}
void Playlist::refreshAlbums(const PlaylistItemList &items, coverKey id)
{
TQValueList< TQPair<TQString, TQString> > albums;
bool setAlbumCovers = items.count() == 1;
for(PlaylistItemList::ConstIterator it = items.begin(); it != items.end(); ++it) {
TQString artist = (*it)->file().tag()->artist();
TQString album = (*it)->file().tag()->album();
if(albums.find(tqMakePair(artist, album)) == albums.end())
albums.append(tqMakePair(artist, album));
(*it)->file().coverInfo()->setCoverId(id);
if(setAlbumCovers)
(*it)->file().coverInfo()->applyCoverToWholeAlbum(true);
}
for(TQValueList< TQPair<TQString, TQString> >::ConstIterator it = albums.begin();
it != albums.end(); ++it)
{
refreshAlbum((*it).first, (*it).second);
}
}
void Playlist::updatePlaying() const
{
for(PlaylistItemList::ConstIterator it = PlaylistItem::playingItems().begin();
it != PlaylistItem::playingItems().end(); ++it)
{
(*it)->listView()->triggerUpdate();
}
}
void Playlist::refreshAlbum(const TQString &artist, const TQString &album)
{
ColumnList columns;
columns.append(PlaylistItem::ArtistColumn);
PlaylistSearch::Component artistComponent(artist, false, columns,
PlaylistSearch::Component::Exact);
columns.clear();
columns.append(PlaylistItem::AlbumColumn);
PlaylistSearch::Component albumComponent(album, false, columns,
PlaylistSearch::Component::Exact);
PlaylistSearch::ComponentList components;
components.append(artist);
components.append(album);
PlaylistList playlists;
playlists.append(CollectionList::instance());
PlaylistSearch search(playlists, components);
PlaylistItemList matches = search.matchedItems();
for(PlaylistItemList::Iterator it = matches.begin(); it != matches.end(); ++it)
(*it)->refresh();
}
void Playlist::hideColumn(int c, bool updateSearch)
{
m_headerMenu->setItemChecked(c, false);
if(!isColumnVisible(c))
return;
setColumnWidthMode(c, Manual);
setColumnWidth(c, 0);
// Moving the column to the end seems to prevent it from randomly
// popping up.
header()->moveSection(c, header()->count());
header()->setResizeEnabled(false, c);
if(c == m_leftColumn) {
updatePlaying();
m_leftColumn = leftMostVisibleColumn();
}
if(!manualResize()) {
slotUpdateColumnWidths();
triggerUpdate();
}
if(this != CollectionList::instance())
CollectionList::instance()->hideColumn(c, false);
if(updateSearch)
redisplaySearch();
}
void Playlist::showColumn(int c, bool updateSearch)
{
m_headerMenu->setItemChecked(c, true);
if(isColumnVisible(c))
return;
// Just set the width to one to mark the column as visible -- we'll update
// the real size in the next call.
if(manualResize())
setColumnWidth(c, 35); // Make column at least slightly visible.
else
setColumnWidth(c, 1);
header()->setResizeEnabled(true, c);
header()->moveSection(c, c); // Approximate old position
if(c == leftMostVisibleColumn()) {
updatePlaying();
m_leftColumn = leftMostVisibleColumn();
}
if(!manualResize()) {
slotUpdateColumnWidths();
triggerUpdate();
}
if(this != CollectionList::instance())
CollectionList::instance()->showColumn(c, false);
if(updateSearch)
redisplaySearch();
}
bool Playlist::isColumnVisible(int c) const
{
return columnWidth(c) != 0;
}
void Playlist::polish()
{
KListView::polish();
if(m_polished)
return;
m_polished = true;
addColumn(i18n("Track Name"));
addColumn(i18n("Artist"));
addColumn(i18n("Album"));
addColumn(i18n("Cover"));
addColumn(i18n("Track"));
addColumn(i18n("Genre"));
addColumn(i18n("Year"));
addColumn(i18n("Length"));
addColumn(i18n("Bitrate"));
addColumn(i18n("Comment"));
addColumn(i18n("File Name"));
addColumn(i18n("File Name (full path)"));
setRenameable(PlaylistItem::TrackColumn, true);
setRenameable(PlaylistItem::ArtistColumn, true);
setRenameable(PlaylistItem::AlbumColumn, true);
setRenameable(PlaylistItem::TrackNumberColumn, true);
setRenameable(PlaylistItem::GenreColumn, true);
setRenameable(PlaylistItem::YearColumn, true);
setAllColumnsShowFocus(true);
setSelectionMode(TQListView::Extended);
setShowSortIndicator(true);
setDropVisualizer(true);
m_columnFixedWidths.resize(columns(), 0);
//////////////////////////////////////////////////
// setup header RMB menu
//////////////////////////////////////////////////
m_columnVisibleAction = new KActionMenu(i18n("&Show Columns"), TQT_TQOBJECT(this), "showColumns");
m_headerMenu = m_columnVisibleAction->popupMenu();
m_headerMenu->insertTitle(i18n("Show"));
m_headerMenu->setCheckable(true);
for(int i = 0; i < header()->count(); ++i) {
if(i == PlaylistItem::FileNameColumn)
m_headerMenu->insertSeparator();
m_headerMenu->insertItem(header()->label(i), i);
m_headerMenu->setItemChecked(i, true);
adjustColumn(i);
}
connect(m_headerMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotToggleColumnVisible(int)));
connect(this, TQT_SIGNAL(contextMenuRequested(TQListViewItem *, const TQPoint &, int)),
this, TQT_SLOT(slotShowRMBMenu(TQListViewItem *, const TQPoint &, int)));
connect(this, TQT_SIGNAL(itemRenamed(TQListViewItem *, const TQString &, int)),
this, TQT_SLOT(slotInlineEditDone(TQListViewItem *, const TQString &, int)));
connect(this, TQT_SIGNAL(doubleClicked(TQListViewItem *)),
this, TQT_SLOT(slotPlayCurrent()));
connect(this, TQT_SIGNAL(returnPressed(TQListViewItem *)),
this, TQT_SLOT(slotPlayCurrent()));
connect(header(), TQT_SIGNAL(sizeChange(int, int, int)),
this, TQT_SLOT(slotColumnSizeChanged(int, int, int)));
connect(renameLineEdit(), TQT_SIGNAL(completionModeChanged(KGlobalSettings::Completion)),
this, TQT_SLOT(slotInlineCompletionModeChanged(KGlobalSettings::Completion)));
connect(action("resizeColumnsManually"), TQT_SIGNAL(activated()),
this, TQT_SLOT(slotColumnResizeModeChanged()));
if(action<KToggleAction>("resizeColumnsManually")->isChecked())
setHScrollBarMode(Auto);
else
setHScrollBarMode(AlwaysOff);
setAcceptDrops(true);
setDropVisualizer(true);
m_disableColumnWidthUpdates = false;
setShowToolTips(false);
m_toolTip = new PlaylistToolTip(viewport(), this);
}
void Playlist::setupItem(PlaylistItem *item)
{
if(!m_search.isEmpty())
item->setVisible(m_search.checkItem(item));
if(childCount() <= 2 && !manualResize()) {
slotWeightDirty();
slotUpdateColumnWidths();
triggerUpdate();
}
}
void Playlist::setDynamicListsFrozen(bool frozen)
{
m_collection->setDynamicListsFrozen(frozen);
}
////////////////////////////////////////////////////////////////////////////////
// protected slots
////////////////////////////////////////////////////////////////////////////////
void Playlist::slotPopulateBackMenu() const
{
if(!playingItem())
return;
KPopupMenu *menu = action<KToolBarPopupAction>("back")->popupMenu();
menu->clear();
m_backMenuItems.clear();
int count = 0;
PlaylistItemList::ConstIterator it = m_history.end();
while(it != m_history.begin() && count < 10) {
++count;
--it;
int index = menu->insertItem((*it)->file().tag()->title());
m_backMenuItems[index] = *it;
}
}
void Playlist::slotPlayFromBackMenu(int number) const
{
if(!m_backMenuItems.contains(number))
return;
TrackSequenceManager::instance()->setNextItem(m_backMenuItems[number]);
action("forward")->activate();
}
////////////////////////////////////////////////////////////////////////////////
// private members
////////////////////////////////////////////////////////////////////////////////
void Playlist::setup()
{
setItemMargin(3);
connect(header(), TQT_SIGNAL(indexChange(int, int, int)), this, TQT_SLOT(slotColumnOrderChanged(int, int, int)));
connect(m_fetcher, TQT_SIGNAL(signalCoverChanged(int)), this, TQT_SLOT(slotCoverChanged(int)));
// Prevent list of selected items from changing while internet search is in
// progress.
connect(this, TQT_SIGNAL(selectionChanged()), m_fetcher, TQT_SLOT(abortSearch()));
setSorting(1);
}
void Playlist::loadFile(const TQString &fileName, const TQFileInfo &fileInfo)
{
TQFile file(fileName);
if(!file.open(IO_ReadOnly))
return;
TQTextStream stream(&file);
// Turn off non-explicit sorting.
setSorting(PlaylistItem::lastColumn() + columnOffset() + 1);
PlaylistItem *after = 0;
m_disableColumnWidthUpdates = true;
m_blockDataChanged = true;
while(!stream.atEnd()) {
TQString itemName = stream.readLine().stripWhiteSpace();
TQFileInfo item(itemName);
if(item.isRelative())
item.setFile(TQDir::cleanDirPath(fileInfo.dirPath(true) + "/" + itemName));
if(item.exists() && item.isFile() && item.isReadable() &&
MediaFiles::isMediaFile(item.fileName()))
{
if(after)
after = createItem(FileHandle(item, item.absFilePath()), after, false);
else
after = createItem(FileHandle(item, item.absFilePath()), 0, false);
}
}
m_blockDataChanged = false;
file.close();
dataChanged();
m_disableColumnWidthUpdates = false;
}
void Playlist::setPlaying(PlaylistItem *item, bool addToHistory)
{
if(playingItem() == item)
return;
if(playingItem()) {
if(addToHistory) {
if(playingItem()->playlist() ==
playingItem()->playlist()->m_collection->upcomingPlaylist())
m_history.append(playingItem()->collectionItem());
else
m_history.append(playingItem());
}
playingItem()->setPlaying(false);
}
TrackSequenceManager::instance()->setCurrent(item);
TQByteArray data;
kapp->dcopClient()->emitDCOPSignal("Player", "trackChanged()", data);
if(!item)
return;
item->setPlaying(true);
bool enableBack = !m_history.isEmpty();
action<KToolBarPopupAction>("back")->popupMenu()->setEnabled(enableBack);
}
bool Playlist::playing() const
{
return playingItem() && this == playingItem()->playlist();
}
int Playlist::leftMostVisibleColumn() const
{
int i = 0;
while(!isColumnVisible(header()->mapToSection(i)) && i < PlaylistItem::lastColumn())
i++;
return header()->mapToSection(i);
}
PlaylistItemList Playlist::items(TQListViewItemIterator::IteratorFlag flags)
{
PlaylistItemList list;
for(TQListViewItemIterator it(this, flags); it.current(); ++it)
list.append(static_cast<PlaylistItem *>(it.current()));
return list;
}
void Playlist::calculateColumnWeights()
{
if(m_disableColumnWidthUpdates)
return;
PlaylistItemList l = items();
TQValueListConstIterator<int> columnIt;
TQValueVector<double> averageWidth(columns(), 0);
double itemCount = l.size();
TQValueVector<int> cachedWidth;
// Here we're not using a real average, but averaging the squares of the
// column widths and then using the square root of that value. This gives
// a nice weighting to the longer columns without doing something arbitrary
// like adding a fixed amount of padding.
for(PlaylistItemList::ConstIterator it = l.begin(); it != l.end(); ++it) {
cachedWidth = (*it)->cachedWidths();
for(columnIt = m_weightDirty.begin(); columnIt != m_weightDirty.end(); ++columnIt)
averageWidth[*columnIt] += pow(double(cachedWidth[*columnIt]), 2.0) / itemCount;
}
m_columnWeights.resize(columns(), -1);
for(columnIt = m_weightDirty.begin(); columnIt != m_weightDirty.end(); ++columnIt) {
m_columnWeights[*columnIt] = int(sqrt(averageWidth[*columnIt]) + 0.5);
// kdDebug(65432) << k_funcinfo << "m_columnWeights[" << *columnIt << "] == "
// << m_columnWeights[*columnIt] << endl;
}
m_weightDirty.clear();
}
void Playlist::addFile(const TQString &file, FileHandleList &files, bool importPlaylists,
PlaylistItem **after)
{
if(hasItem(file) && !m_allowDuplicates)
return;
processEvents();
addFileHelper(files, after);
// Our biggest thing that we're fighting during startup is too many stats
// of files. Make sure that we don't do one here if it's not needed.
FileHandle cached = Cache::instance()->value(file);
if(!cached.isNull()) {
cached.tag();
files.append(cached);
return;
}
const TQFileInfo fileInfo = TQDir::cleanDirPath(file);
if(!fileInfo.exists())
return;
if(fileInfo.isFile() && fileInfo.isReadable()) {
if(MediaFiles::isMediaFile(file)) {
FileHandle f(fileInfo, fileInfo.absFilePath());
f.tag();
files.append(f);
}
}
if(importPlaylists && MediaFiles::isPlaylistFile(file) &&
!m_collection->containsPlaylistFile(fileInfo.absFilePath()))
{
new Playlist(m_collection, fileInfo);
return;
}
if(fileInfo.isDir()) {
// Resorting to the POSIX API because TQDir::listEntries() stats every
// file and blocks while it's doing so.
DIR *dir = ::opendir(TQFile::encodeName(fileInfo.filePath()));
if(dir) {
struct dirent *dirEntry;
for(dirEntry = ::readdir(dir); dirEntry; dirEntry = ::readdir(dir)) {
if(strcmp(dirEntry->d_name, ".") != 0 && strcmp(dirEntry->d_name, "..") != 0) {
// We set importPlaylists to the value from the add directories
// dialog as we want to load all of the ones that the user has
// explicitly asked for, but not those that we find in lower
// directories.
addFile(fileInfo.filePath() + TQDir::separator() + TQFile::decodeName(dirEntry->d_name),
files, m_collection->importPlaylists(), after);
}
}
::closedir(dir);
}
else {
kdWarning(65432) << "Unable to open directory "
<< fileInfo.filePath()
<< ", make sure it is readable.\n";
}
}
}
void Playlist::addFileHelper(FileHandleList &files, PlaylistItem **after, bool ignoreTimer)
{
static TQTime time = TQTime::currentTime();
// Process new items every 10 seconds, when we've loaded 1000 items, or when
// it's been requested in the API.
if(ignoreTimer || time.elapsed() > 10000 ||
(files.count() >= 1000 && time.elapsed() > 1000))
{
time.restart();
const bool focus = hasFocus();
const bool visible = isVisible() && files.count() > 20;
if(visible)
m_collection->raiseDistraction();
const FileHandleList::ConstIterator filesEnd = files.end();
for(FileHandleList::ConstIterator it = files.begin(); it != filesEnd; ++it)
*after = createItem(*it, *after, false);
files.clear();
if(visible)
m_collection->lowerDistraction();
if(focus)
setFocus();
processEvents();
}
}
////////////////////////////////////////////////////////////////////////////////
// private slots
////////////////////////////////////////////////////////////////////////////////
void Playlist::slotUpdateColumnWidths()
{
if(m_disableColumnWidthUpdates || manualResize())
return;
// Make sure that the column weights have been initialized before trying to
// update the columns.
TQValueList<int> visibleColumns;
for(int i = 0; i < columns(); i++) {
if(isColumnVisible(i))
visibleColumns.append(i);
}
TQValueListConstIterator<int> it;
if(count() == 0) {
for(it = visibleColumns.begin(); it != visibleColumns.end(); ++it)
setColumnWidth(*it, header()->fontMetrics().width(header()->label(*it)) + 10);
return;
}
if(m_columnWeights.isEmpty())
return;
// First build a list of minimum widths based on the strings in the listview
// header. We won't let the width of the column go below this width.
TQValueVector<int> minimumWidth(columns(), 0);
int minimumWidthTotal = 0;
// Also build a list of either the minimum *or* the fixed width -- whichever is
// greater.
TQValueVector<int> minimumFixedWidth(columns(), 0);
int minimumFixedWidthTotal = 0;
for(it = visibleColumns.begin(); it != visibleColumns.end(); ++it) {
int column = *it;
minimumWidth[column] = header()->fontMetrics().width(header()->label(column)) + 10;
minimumWidthTotal += minimumWidth[column];
minimumFixedWidth[column] = TQMAX(minimumWidth[column], m_columnFixedWidths[column]);
minimumFixedWidthTotal += minimumFixedWidth[column];
}
// Make sure that the width won't get any smaller than this. We have to
// account for the scrollbar as well. Since this method is called from the
// resize event this will set a pretty hard lower bound on the size.
setMinimumWidth(minimumWidthTotal + verticalScrollBar()->width());
// If we've got enough room for the fixed widths (larger than the minimum
// widths) then instead use those for our "minimum widths".
if(minimumFixedWidthTotal < visibleWidth()) {
minimumWidth = minimumFixedWidth;
minimumWidthTotal = minimumFixedWidthTotal;
}
// We've got a list of columns "weights" based on some statistics gathered
// about the widths of the items in that column. We need to find the total
// useful weight to use as a divisor for each column's weight.
double totalWeight = 0;
for(it = visibleColumns.begin(); it != visibleColumns.end(); ++it)
totalWeight += m_columnWeights[*it];
// Computed a "weighted width" for each visible column. This would be the
// width if we didn't have to handle the cases of minimum and maximum widths.
TQValueVector<int> weightedWidth(columns(), 0);
for(it = visibleColumns.begin(); it != visibleColumns.end(); ++it)
weightedWidth[*it] = int(double(m_columnWeights[*it]) / totalWeight * visibleWidth() + 0.5);
// The "extra" width for each column. This is the weighted width less the
// minimum width or zero if the minimum width is greater than the weighted
// width.
TQValueVector<int> extraWidth(columns(), 0);
// This is used as an indicator if we have any columns where the weighted
// width is less than the minimum width. If this is false then we can
// just use the weighted width with no problems, otherwise we have to
// "readjust" the widths.
bool readjust = false;
// If we have columns where the weighted width is less than the minimum width
// we need to steal that space from somewhere. The amount that we need to
// steal is the "neededWidth".
int neededWidth = 0;
// While we're on the topic of stealing -- we have to have somewhere to steal
// from. availableWidth is the sum of the amount of space beyond the minimum
// width that each column has been allocated -- the sum of the values of
// extraWidth[].
int availableWidth = 0;
// Fill in the values discussed above.
for(it = visibleColumns.begin(); it != visibleColumns.end(); ++it) {
if(weightedWidth[*it] < minimumWidth[*it]) {
readjust = true;
extraWidth[*it] = 0;
neededWidth += minimumWidth[*it] - weightedWidth[*it];
}
else {
extraWidth[*it] = weightedWidth[*it] - minimumWidth[*it];
availableWidth += extraWidth[*it];
}
}
// The adjustmentRatio is the amount of the "extraWidth[]" that columns will
// actually be given.
double adjustmentRatio = (double(availableWidth) - double(neededWidth)) / double(availableWidth);
// This will be the sum of the total space that we actually use. Because of
// rounding error this won't be the exact available width.
int usedWidth = 0;
// Now set the actual column widths. If the weighted widths are all greater
// than the minimum widths, just use those, otherwise use the "reajusted
// weighted width".
for(it = visibleColumns.begin(); it != visibleColumns.end(); ++it) {
int width;
if(readjust) {
int adjustedExtraWidth = int(double(extraWidth[*it]) * adjustmentRatio + 0.5);
width = minimumWidth[*it] + adjustedExtraWidth;
}
else
width = weightedWidth[*it];
setColumnWidth(*it, width);
usedWidth += width;
}
// Fill the remaining gap for a clean fit into the available space.
int remainingWidth = visibleWidth() - usedWidth;
setColumnWidth(visibleColumns.back(), columnWidth(visibleColumns.back()) + remainingWidth);
m_widthsDirty = false;
}
void Playlist::slotAddToUpcoming()
{
m_collection->setUpcomingPlaylistEnabled(true);
m_collection->upcomingPlaylist()->appendItems(selectedItems());
}
void Playlist::slotShowRMBMenu(TQListViewItem *item, const TQPoint &point, int column)
{
if(!item)
return;
// Create the RMB menu on demand.
if(!m_rmbMenu) {
// A bit of a hack to get a pointer to the action collection.
// Probably more of these actions should be ported over to using KActions.
m_rmbMenu = new KPopupMenu(this);
m_rmbUpcomingID = m_rmbMenu->insertItem(SmallIcon("today"),
i18n("Add to Play Queue"), this, TQT_SLOT(slotAddToUpcoming()));
m_rmbMenu->insertSeparator();
if(!readOnly()) {
action("edit_cut")->plug(m_rmbMenu);
action("edit_copy")->plug(m_rmbMenu);
action("edit_paste")->plug(m_rmbMenu);
m_rmbMenu->insertSeparator();
action("removeFromPlaylist")->plug(m_rmbMenu);
}
else
action("edit_copy")->plug(m_rmbMenu);
m_rmbEditID = m_rmbMenu->insertItem(
i18n("Edit"), this, TQT_SLOT(slotRenameTag()));
action("refresh")->plug(m_rmbMenu);
action("removeItem")->plug(m_rmbMenu);
m_rmbMenu->insertSeparator();
action("guessTag")->plug(m_rmbMenu);
action("renameFile")->plug(m_rmbMenu);
action("coverManager")->plug(m_rmbMenu);
m_rmbMenu->insertSeparator();
m_rmbMenu->insertItem(
SmallIcon("folder_new"), i18n("Create Playlist From Selected Items..."), this, TQT_SLOT(slotCreateGroup()));
K3bExporter *exporter = new K3bExporter(this);
KAction *k3bAction = exporter->action();
if(k3bAction)
k3bAction->plug(m_rmbMenu);
}
// Ignore any columns added by subclasses.
column -= columnOffset();
bool showEdit =
(column == PlaylistItem::TrackColumn) ||
(column == PlaylistItem::ArtistColumn) ||
(column == PlaylistItem::AlbumColumn) ||
(column == PlaylistItem::TrackNumberColumn) ||
(column == PlaylistItem::GenreColumn) ||
(column == PlaylistItem::YearColumn);
if(showEdit)
m_rmbMenu->changeItem(m_rmbEditID,
i18n("Edit '%1'").arg(columnText(column + columnOffset())));
m_rmbMenu->setItemVisible(m_rmbEditID, showEdit);
// Disable edit menu if only one file is selected, and it's read-only
FileHandle file = static_cast<PlaylistItem*>(item)->file();
m_rmbMenu->setItemEnabled(m_rmbEditID, file.fileInfo().isWritable() ||
selectedItems().count() > 1);
action("viewCover")->setEnabled(file.coverInfo()->hasCover());
action("removeCover")->setEnabled(file.coverInfo()->hasCover());
m_rmbMenu->popup(point);
m_currentColumn = column + columnOffset();
}
void Playlist::slotRenameTag()
{
// kdDebug(65432) << "Playlist::slotRenameTag()" << endl;
// setup completions and validators
CollectionList *list = CollectionList::instance();
KLineEdit *edit = renameLineEdit();
switch(m_currentColumn - columnOffset())
{
case PlaylistItem::ArtistColumn:
edit->completionObject()->setItems(list->uniqueSet(CollectionList::Artists));
break;
case PlaylistItem::AlbumColumn:
edit->completionObject()->setItems(list->uniqueSet(CollectionList::Albums));
break;
case PlaylistItem::GenreColumn:
{
TQStringList genreList;
TagLib::StringList genres = TagLib::ID3v1::genreList();
for(TagLib::StringList::ConstIterator it = genres.begin(); it != genres.end(); ++it)
genreList.append(TStringToQString((*it)));
edit->completionObject()->setItems(genreList);
break;
}
default:
edit->completionObject()->clear();
break;
}
m_editText = currentItem()->text(m_currentColumn);
rename(currentItem(), m_currentColumn);
}
bool Playlist::editTag(PlaylistItem *item, const TQString &text, int column)
{
Tag *newTag = TagTransactionManager::duplicateTag(item->file().tag());
switch(column - columnOffset())
{
case PlaylistItem::TrackColumn:
newTag->setTitle(text);
break;
case PlaylistItem::ArtistColumn:
newTag->setArtist(text);
break;
case PlaylistItem::AlbumColumn:
newTag->setAlbum(text);
break;
case PlaylistItem::TrackNumberColumn:
{
bool ok;
int value = text.toInt(&ok);
if(ok)
newTag->setTrack(value);
break;
}
case PlaylistItem::GenreColumn:
newTag->setGenre(text);
break;
case PlaylistItem::YearColumn:
{
bool ok;
int value = text.toInt(&ok);
if(ok)
newTag->setYear(value);
break;
}
}
TagTransactionManager::instance()->changeTagOnItem(item, newTag);
return true;
}
void Playlist::slotInlineEditDone(TQListViewItem *, const TQString &, int column)
{
TQString text = renameLineEdit()->text();
bool changed = false;
PlaylistItemList l = selectedItems();
// See if any of the files have a tag different from the input.
for(PlaylistItemList::ConstIterator it = l.begin(); it != l.end() && !changed; ++it)
if((*it)->text(column - columnOffset()) != text)
changed = true;
if(!changed ||
(l.count() > 1 && KMessageBox::warningContinueCancel(
0,
i18n("This will edit multiple files. Are you sure?"),
TQString(),
i18n("Edit"),
"DontWarnMultipleTags") == KMessageBox::Cancel))
{
return;
}
for(PlaylistItemList::ConstIterator it = l.begin(); it != l.end(); ++it)
editTag(*it, text, column);
TagTransactionManager::instance()->commit();
CollectionList::instance()->dataChanged();
dataChanged();
update();
}
void Playlist::slotColumnOrderChanged(int, int from, int to)
{
if(from == 0 || to == 0) {
updatePlaying();
m_leftColumn = header()->mapToSection(0);
}
SharedSettings::instance()->setColumnOrder(this);
}
void Playlist::slotToggleColumnVisible(int column)
{
if(!isColumnVisible(column)) {
int fileNameColumn = PlaylistItem::FileNameColumn + columnOffset();
int fullPathColumn = PlaylistItem::FullPathColumn + columnOffset();
if(column == fileNameColumn && isColumnVisible(fullPathColumn)) {
hideColumn(fullPathColumn, false);
SharedSettings::instance()->toggleColumnVisible(fullPathColumn);
}
if(column == fullPathColumn && isColumnVisible(fileNameColumn)) {
hideColumn(fileNameColumn, false);
SharedSettings::instance()->toggleColumnVisible(fileNameColumn);
}
}
if(isColumnVisible(column))
hideColumn(column);
else
showColumn(column);
SharedSettings::instance()->toggleColumnVisible(column - columnOffset());
}
void Playlist::slotCreateGroup()
{
TQString name = m_collection->playlistNameDialog(i18n("Create New Playlist"));
if(!name.isEmpty())
new Playlist(m_collection, selectedItems(), name);
}
void Playlist::notifyUserColumnWidthModeChanged()
{
KMessageBox::information(this,
i18n("Manual column widths have been enabled. You can "
"switch back to automatic column sizes in the view "
"menu."),
i18n("Manual Column Widths Enabled"),
"ShowManualColumnWidthInformation");
}
void Playlist::slotColumnSizeChanged(int column, int, int newSize)
{
m_widthsDirty = true;
m_columnFixedWidths[column] = newSize;
}
void Playlist::slotInlineCompletionModeChanged(KGlobalSettings::Completion mode)
{
SharedSettings::instance()->setInlineCompletionMode(mode);
}
void Playlist::slotPlayCurrent()
{
TQListViewItemIterator it(this, TQListViewItemIterator::Selected);
PlaylistItem *next = static_cast<PlaylistItem *>(it.current());
TrackSequenceManager::instance()->setNextItem(next);
action("forward")->activate();
}
////////////////////////////////////////////////////////////////////////////////
// helper functions
////////////////////////////////////////////////////////////////////////////////
TQDataStream &operator<<(TQDataStream &s, const Playlist &p)
{
s << p.name();
s << p.fileName();
s << p.files();
return s;
}
TQDataStream &operator>>(TQDataStream &s, Playlist &p)
{
p.read(s);
return s;
}
bool processEvents()
{
static TQTime time = TQTime::currentTime();
if(time.elapsed() > 100) {
time.restart();
kapp->processEvents();
return true;
}
return false;
}
#include "playlist.moc"
View Git Blame Copy Permalink