~neon/juk/master

/***************************************************************************

    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 <qheader.h>

#include <qcursor.h>

#include <qdir.h>

#include <qeventloop.h>

#include <qtooltip.h>

#include <qwidgetstack.h>

#include <qfile.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 "painteater.h"

#include "upcomingplaylist.h"

#include "deletedialog.h"

#include "googlefetcher.h"

#include "coverinfo.h"

#include "tagtransactionmanager.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 QToolTip

{

public:

    PlaylistToolTip(QWidget *parent, Playlist *playlist) :

	QToolTip(parent), m_playlist(playlist) {}

    virtual void maybeTip(const QPoint &p)

    {

	PlaylistItem *item = static_cast<PlaylistItem *>(m_playlist->itemAt(p));

	if(!item)

	    return;

	QPoint 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()))

	{

	    QRect 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) {

		QMimeSourceFactory *f = QMimeSourceFactory::defaultFactory();

	        f->setImage("coverThumb",

			    QImage(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;

/**

 * 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;

    QValueList<int> m_columnOrder;

    QValueVector<bool> m_columnsVisible;

    KGlobalSettings::Completion m_inlineCompletion;

};

Playlist::SharedSettings *Playlist::SharedSettings::m_instance = 0;

////////////////////////////////////////////////////////////////////////////////

// Playlist::SharedSettings public members

////////////////////////////////////////////////////////////////////////////////

Playlist::SharedSettings *Playlist::SharedSettings::instance()

{

    if(!m_instance)

	m_instance = new SharedSettings;

    return m_instance;

}

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(QValueListConstIterator<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");

    QValueList<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(QValueList<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);

    QValueList<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;

UpcomingPlaylist *Playlist::m_upcomingPlaylist = 0;

QMap<int, PlaylistItem *> Playlist::m_backMenuItems;

int Playlist::m_leftColumn = 0;

Playlist::Playlist(PlaylistCollection *collection, const QString &name,

		   const QString &iconName) :

    KListView(collection->playlistStack(), name.latin1()),

    m_collection(collection),

    m_selectedCount(0),

    m_allowDuplicates(false),

    m_polished(false),

    m_applySharedSettings(true),

    m_mousePressed(false),

    m_disableColumnWidthUpdates(true),

    m_widthsDirty(true),

    m_searchEnabled(true),

    m_lastSelected(0),

    m_playlistName(name),

    m_rmbMenu(0),

    m_toolTip(0)

{

    setup();

    collection->setupPlaylist(this, iconName);

}

Playlist::Playlist(PlaylistCollection *collection, const PlaylistItemList &items,

		   const QString &name, const QString &iconName) :

    KListView(collection->playlistStack(), name.latin1()),

    m_collection(collection),

    m_selectedCount(0),

    m_allowDuplicates(false),

    m_polished(false),

    m_applySharedSettings(true),

    m_mousePressed(false),

    m_disableColumnWidthUpdates(true),

    m_widthsDirty(true),

    m_searchEnabled(true),

    m_lastSelected(0),

    m_playlistName(name),

    m_rmbMenu(0),

    m_toolTip(0)

{

    setup();

    collection->setupPlaylist(this, iconName);

    createItems(items);

}

Playlist::Playlist(PlaylistCollection *collection, const QFileInfo &playlistFile,

		   const QString &iconName) :

    KListView(collection->playlistStack()),

    m_collection(collection),

    m_selectedCount(0),

    m_allowDuplicates(false),

    m_polished(false),

    m_applySharedSettings(true),

    m_mousePressed(false),

    m_disableColumnWidthUpdates(true),

    m_widthsDirty(true),

    m_searchEnabled(true),

    m_lastSelected(0),

    m_fileName(playlistFile.absFilePath()),

    m_rmbMenu(0),

    m_toolTip(0)

{

    setup();

    loadFile(m_fileName, playlistFile);

    collection->setupPlaylist(this, iconName);

}

Playlist::Playlist(PlaylistCollection *collection, bool delaySetup) :

    KListView(collection->playlistStack()),

    m_collection(collection),

    m_selectedCount(0),

    m_allowDuplicates(false),

    m_polished(false),

    m_applySharedSettings(true),

    m_mousePressed(false),

    m_disableColumnWidthUpdates(true),

    m_widthsDirty(true),

    m_searchEnabled(true),

    m_lastSelected(0),

    m_rmbMenu(0),

    m_toolTip(0)

{

    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());

}

QString Playlist::name() const

{

    if(m_playlistName.isNull())

	return m_fileName.section(QDir::separator(), -1).section('.', 0, -2);

    else

	return m_playlistName;

}

FileHandle Playlist::currentFile() const

{

    return playingItem() ? playingItem()->file() : FileHandle::null();

}

int Playlist::time() const

{

    int time = 0;

    QListViewItemIterator it(const_cast<Playlist *>(this));

    while (it.current()) {

	PlaylistItem *item = static_cast<PlaylistItem *>(it.current());

	time += item->file().tag()->seconds();

	it++;

    }

    return time;

}

void Playlist::playFirst()

{

    TrackSequenceManager::instance()->setNextItem(static_cast<PlaylistItem *>(

	QListViewItemIterator(const_cast<Playlist *>(this), QListViewItemIterator::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.

    QString 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 QString &n)

{

    m_collection->addName(n);

    m_collection->removeName(m_playlistName);

    m_playlistName = n;

    emit signalNameChanged(m_playlistName);

}

void Playlist::save()

{

    if(m_fileName.isEmpty())

	return saveAs();

    QFile file(m_fileName);

    if(!file.open(IO_WriteOnly))

	return KMessageBox::error(this, i18n("Could not save to file %1.").arg(m_fileName));

    QTextStream stream(&file);

    QStringList fileList = files();

    for(QStringList::Iterator it = fileList.begin(); it != fileList.end(); ++it)

	stream << *it << endl;

    file.close();

}

void Playlist::saveAs()

{

    m_fileName = MediaFiles::savePlaylistDialog(name(), this);

    if(!m_fileName.isEmpty()) {

	// 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);

    if(!m_randomList.isEmpty() && !m_visibleChanged)

        m_randomList.remove(item);

    m_history.remove(item);

    delete item;

    if(emitChanged)

	dataChanged();

}

void Playlist::clearItems(const PlaylistItemList &items)

{

    for(PlaylistItemList::ConstIterator it = items.begin(); it != items.end(); ++it)

	clearItem(*it, false);

    dataChanged();

}

PlaylistItem *Playlist::playingItem() // static

{

    return PlaylistItem::playingItems().isEmpty() ? 0 : PlaylistItem::playingItems().front();

}

QStringList Playlist::files() const

{

    QStringList list;

    for(QListViewItemIterator it(const_cast<Playlist *>(this)); it.current(); ++it)

	list.append(static_cast<PlaylistItem *>(*it)->file().absFilePath());

    return list;

}

PlaylistItemList Playlist::items()

{

    return items(QListViewItemIterator::IteratorFlag(0));

}

PlaylistItemList Playlist::visibleItems()

{

    return items(QListViewItemIterator::Visible);

}

PlaylistItemList Playlist::selectedItems()

{

    PlaylistItemList list;

    switch(m_selectedCount) {

    case 0:

	break;

	// case 1:

	// list.append(m_lastSelected);

	// break;

    default:

	list = items(QListViewItemIterator::IteratorFlag(QListViewItemIterator::Selected |

							 QListViewItemIterator::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;

    // Make sure that we only play visible items.

    m_randomList.clear();

    setItemsVisible(s.matchedItems(), true);

    setItemsVisible(s.unmatchedItems(), false);

}

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) {