just move the outcommented view code over

parent 1c84e6ee
......@@ -157,166 +157,6 @@ private:
bool Playlist::m_visibleChanged = false;
bool Playlist::m_shuttingDown = false;
//### TODO: VIEW
/**
* 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;
// QList<int> m_columnOrder;
// QVector<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 >= m_columnsVisible.size())
// m_columnsVisible.fill(true, column + 1);
//
// 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;
// foreach(int column, m_columnOrder)
// l->header()->moveSection(i++ + offset, column + offset);
//
// for(int 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.readEntry("ResizeColumnsManually", false);
// action("resizeColumnsManually")->setChecked(resizeColumnsManually);
//
// // Preallocate spaces so we don't need to check later.
// m_columnsVisible.fill(true, PlaylistItem::lastColumn() + 1);
//
// // save column order
// m_columnOrder = config.readEntry("ColumnOrder", QList<int>());
//
// QList<int> l = config.readEntry("VisibleColumns", QList<int>());
//
// if(l.isEmpty()) {
//
// // Provide some default values for column visibility if none were
// // read from the configuration file.
//
// m_columnsVisible[PlaylistItem::BitrateColumn] = false;
// m_columnsVisible[PlaylistItem::CommentColumn] = false;
// m_columnsVisible[PlaylistItem::FileNameColumn] = false;
// m_columnsVisible[PlaylistItem::FullPathColumn] = false;
// }
// else {
// // Convert the int list into a bool list.
//
// m_columnsVisible.fill(false);
// for(int i = 0; i < l.size() && i < m_columnsVisible.size(); ++i)
// m_columnsVisible[i] = bool(l[i]);
// }
//
// m_inlineCompletion = KGlobalSettings::Completion(
// config.readEntry("InlineCompletionMode", int(KGlobalSettings::CompletionAuto)));
// }
////////////////////////////////////////////////////////////////////////////////
// Playlist::SharedSettings private members
////////////////////////////////////////////////////////////////////////////////
// void Playlist::SharedSettings::writeConfig()
// {
// KConfigGroup config(KGlobal::config(), "PlaylistShared");
// config.writeEntry("ColumnOrder", m_columnOrder);
//
// QList<int> l;
// for(int i = 0; i < m_columnsVisible.size(); i++)
// l.append(int(m_columnsVisible[i]));
//
// config.writeEntry("VisibleColumns", l);
// config.writeEntry("InlineCompletionMode", int(m_inlineCompletion));
//
// config.writeEntry("ResizeColumnsManually", manualResize());
//
// KGlobal::config()->sync();
// }
////////////////////////////////////////////////////////////////////////////////
// public members
......@@ -630,69 +470,6 @@ QStringList Playlist::files() const
return list;
}
// ### TODO: View
// PlaylistItemList Playlist::visibleItems()
// {
// return items(Q3ListViewItemIterator::Visible);
// }
// void Playlist::updateLeftColumn()
// {
// int newLeftColumn = leftMostVisibleColumn();
//
// if(m_leftColumn != newLeftColumn) {
// updatePlaying();
// m_leftColumn = newLeftColumn;
// }
// }
// ### TODO: View
// void Playlist::setItemsVisible(const PlaylistItemList &items, bool visible) // static
// {
// m_visibleChanged = true;
//
// foreach(PlaylistItem *playlistItem, items)
// playlistItem->setVisible(visible);
// }
// ### TODO: View, move to a proxy model
// 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);
// }
// ### TODO: View
// void Playlist::markItemSelected(PlaylistItem *item, bool selected)
// {
// if(selected && !item->isSelected()) {
// m_selectedCount++;
// }
// else if(!selected && item->isSelected())
// m_selectedCount--;
// }
void Playlist::synchronizePlayingItems(const PlaylistList &sources, bool setMaster)
{
......@@ -715,169 +492,6 @@ void Playlist::synchronizePlayingItems(const PlaylistList &sources, bool setMast
////////////////////////////////////////////////////////////////////////////////
// public slots
////////////////////////////////////////////////////////////////////////////////
// ### TODO: View
// void Playlist::copy()
// {
// PlaylistItemList items = selectedItems();
// KUrl::List urls;
//
// foreach(PlaylistItem *item, items) {
// urls << KUrl::fromPath(item->file().absFilePath());
// }
//
// QMimeData *mimeData = new QMimeData;
// urls.populateMimeData(mimeData);
//
// QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
// }
//
// void Playlist::paste()
// {
// decode(QApplication::clipboard()->mimeData(), 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(Qt::waitCursor);
// foreach(PlaylistItem *item, l) {
// item->refreshFromDisk();
//
// if(!item->file().tag() || !item->file().fileInfo().exists()) {
// kDebug() << "Error while trying to refresh the tag. "
// << "This file has probably been removed."
// << endl;
// delete item->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()
// {
// const PlaylistItemList items = selectedItems();
// if (items.isEmpty())
// return;
// foreach(const PlaylistItem *item, items)
// item->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?"),
// QString(),
// KGuiItem(i18n("&Delete Covers")));
// if(button == KMessageBox::Continue)
// refreshAlbums(items);
// }
//
// void Playlist::slotShowCoverManager()
// {
// static CoverDialog *managerDialog = 0;
//
// if(!managerDialog)
// managerDialog = new CoverDialog(this);
//
// managerDialog->show();
// }
//
// void Playlist::slotAddCover(bool retrieveLocal)
// {
// PlaylistItemList items = selectedItems();
//
// if(items.isEmpty())
// return;
//
// if(!retrieveLocal) {
// m_fetcher->setFile((*items.begin())->file());
// m_fetcher->searchCover();
// return;
// }
//
// KUrl file = KFileDialog::getImageOpenUrl(
// KUrl( "kfiledialog://homedir" ), this, i18n("Select Cover Image File"));
//
// if(file.isEmpty())
// return;
//
// QString artist = items.front()->file().tag()->artist();
// QString album = items.front()->file().tag()->album();
//
// coverKey newId = CoverManager::addCover(file, artist, album);
//
// if(newId != CoverManager::NoMatch)
// refreshAlbums(items, newId);
// }
//
// // Called when image fetcher has added a new cover.
// void Playlist::slotCoverChanged(int coverId)
// {
// kDebug() << "Refreshing information for newly changed covers.\n";
// refreshAlbums(selectedItems(), coverId);
// }
//
// void Playlist::slotGuessTagInfo(TagGuesser::Type type)
// {
// KApplication::setOverrideCursor(Qt::waitCursor);
// const PlaylistItemList items = selectedItems();
// setDynamicListsFrozen(true);
//
// m_blockDataChanged = true;
//
// foreach(PlaylistItem *item, items) {
// item->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()
{
QFileInfo fileInfo(m_fileName);
......@@ -887,55 +501,6 @@ void Playlist::slotReload()
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.contains(column))
// 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->ensureItemVisible(playingItem());
// }
//
// void Playlist::slotColumnResizeModeChanged()
// {
// if(manualResize())
// setHScrollBarMode(Auto);
// else
// setHScrollBarMode(AlwaysOff);
//
// if(!manualResize())
// slotUpdateColumnWidths();
//
// SharedSettings::instance()->sync();
// }
//### TODO: Nuke me
void Playlist::dataChanged()
......@@ -948,286 +513,6 @@ void Playlist::dataChanged()
////////////////////////////////////////////////////////////////////////////////
// protected members
////////////////////////////////////////////////////////////////////////////////
//### TODO: View
// void Playlist::removeFromDisk(const PlaylistItemList &items)
// {
// if(isVisible() && !items.isEmpty()) {
//
// QStringList files;
// foreach(const PlaylistItem *item, items)
// files.append(item->file().absFilePath());
//
// DeleteDialog dialog(this);
//
// m_blockDataChanged = true;
//
// if(dialog.confirmDeleteList(files)) {
// bool shouldDelete = dialog.shouldDelete();
// QStringList errorFiles;
//
// foreach(PlaylistItem *item, items) {
// if(playingItem() == item)
// action("forward")->trigger();
//
// QString removePath = item->file().absFilePath();
// if((!shouldDelete && KIO::NetAccess::synchronousRun(KIO::trash(removePath), this)) ||
// (shouldDelete && QFile::remove(removePath)))
// {
// delete item->collectionItem();
// }
// else
// errorFiles.append(item->file().absFilePath());
// }
//
// if(!errorFiles.isEmpty()) {
// QString 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();
// }
// }
//
// Q3DragObject *Playlist::dragObject(QWidget *parent)
// {
// PlaylistItemList items = selectedItems();
// KUrl::List urls;
//
// foreach(PlaylistItem *item, items) {
// urls << KUrl::fromPath(item->file().absFilePath());
// }
//
// K3URLDrag *urlDrag = new K3URLDrag(urls, parent);
//
// urlDrag->setPixmap(BarIcon("audio-x-generic"));
//
// return urlDrag;
// }
//
// void Playlist::contentsDragEnterEvent(QDragEnterEvent *e)
// {
// K3ListView::contentsDragEnterEvent(e);
//
// if(CoverDrag::isCover(e->mimeData())) {
// setDropHighlighter(true);
// setDropVisualizer(false);
//
// e->accept();
// return;
// }
//
// setDropHighlighter(false);
// setDropVisualizer(true);
//
// KUrl::List urls;
// if(!K3URLDrag::decode(e, urls) || urls.isEmpty()) {
// e->ignore();
// return;
// }
//
// e->accept();
// return;
// }
//
// bool Playlist::acceptDrag(QDropEvent *e) const
// {
// return CoverDrag::isCover(e->mimeData()) || K3URLDrag::canDecode(e);
// }
//
// void Playlist::decode(const QMimeData *s, PlaylistItem *item)
// {
// if(!KUrl::List::canDecode(s))
// return;
//
// const KUrl::List urls = KUrl::List::fromMimeData(s);
//
// if(urls.isEmpty())
// return;
//
// // handle dropped images
//
// if(!MediaFiles::isMediaFile(urls.front().path())) {
//
// QString 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(QLatin1String("image/"))) {
// item->file().coverInfo()->setCover(QImage(file));
// refreshAlbum(item->file().tag()->artist(),
// item->file().tag()->album());
// }
//
// KIO::NetAccess::removeTempFile(file);
// }
//
// QStringList fileList = MediaFiles::convertURLsToLocal(urls, this);
//
// addFiles(fileList, item);
// }
//
// bool Playlist::eventFilter(QObject *watched, QEvent *e)
// {
// if(watched == header()) {
// switch(e->type()) {
// case QEvent::MouseMove:
// {
// if((static_cast<QMouseEvent *>(e)->modifiers() & Qt::LeftButton) == Qt::LeftButton &&
// !action<KToggleAction>("resizeColumnsManually")->isChecked())
// {
// m_columnWidthModeChanged = true;
//
// action<KToggleAction>("resizeColumnsManually")->setChecked(true);
// slotColumnResizeModeChanged();
// }
//
// break;
// }
// case QEvent::MouseButtonPress:
// {
// if(static_cast<QMouseEvent *>(e)->button() == Qt::RightButton)
// m_headerMenu->popup(QCursor::pos());
//
// break;
// }
// case QEvent::MouseButtonRelease:
// {
// if(m_columnWidthModeChanged) {
// m_columnWidthModeChanged = false;
// notifyUserColumnWidthModeChanged();
// }
//
// if(!manualResize() && m_widthsDirty)
// QTimer::singleShot(0, this, SLOT(slotUpdateColumnWidths()));
// break;
// }
// default:
// break;
// }
// }
//
// return K3ListView::eventFilter(watched, e);
// }
//
// void Playlist::keyPressEvent(QKeyEvent *event)
// {
// if(event->key() == Qt::Key_Up) {
// Q3ListViewItemIterator selected(this, Q3ListViewItemIterator::IteratorFlag(
// Q3ListViewItemIterator::Selected |
// Q3ListViewItemIterator::Visible));
// if(selected.current()) {
// Q3ListViewItemIterator visible(this, Q3ListViewItemIterator::IteratorFlag(
// Q3ListViewItemIterator::Visible));
// if(selected.current() == visible.current())
// KApplication::postEvent(parent(), new FocusUpEvent);
// }
//
// }
//
// K3ListView::keyPressEvent(event);
// }
//
// void Playlist::contentsDropEvent(QDropEvent *e)
// {
// QPoint 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::isCover(e->mimeData())) {
// coverKey id = CoverDrag::idFromData(e->mimeData());
//
// // If the item we dropped on is selected, apply cover to all selected
// // items, otherwise just apply to the dropped item.
//
// if(item->isSelected()) {
// const PlaylistItemList selItems = selectedItems();
// foreach(PlaylistItem *playlistItem, selItems) {
// playlistItem->file().coverInfo()->setCoverId(id);
// playlistItem->refresh();
// }
// }
// else {
// item->file().coverInfo()->setCoverId(id);
// item->refresh();
// }
//
// return;
// }
//
// // When dropping on the toUpper 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);
//
// const QList<Q3ListViewItem *> items = K3ListView::selectedItems();
//
// foreach(Q3ListViewItem *listViewItem, items) {
// if(!item) {
//
// // Insert the item at the top of the list. This is a bit ugly,
// // but I don't see another way.
//
// takeItem(listViewItem);
// insertItem(listViewItem);
// }
// else
// listViewItem->moveItem(item);