diff --git a/CMakeLists.txt b/CMakeLists.txt
index d89b6d86..8f71d85b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,197 +1,196 @@
 cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
 
 project(juk)
 
 set(QT_MIN_VERSION "5.6.0")
 set(KF5_MIN_VERSION "5.35.0")
 
 find_package(ECM ${KF5_MIN_VERSION} REQUIRED NO_MODULE)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
 include(CMakePushCheckState)
 include(CheckIncludeFileCXX)
 include(KDEInstallDirs)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings NO_POLICY_SCOPE)
 include(FeatureSummary)
 include(ECMInstallIcons)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 
 find_package(Qt5 ${QT_MIN_VERSION} REQUIRED COMPONENTS Gui Svg Network Test Widgets)
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS CoreAddons Completion Config GlobalAccel
 	I18n IconThemes DocTools TextWidgets XmlGui Wallet
 	WidgetsAddons WindowSystem KDELibs4Support)
 find_package(Phonon4Qt5 4.6.60 REQUIRED NO_MODULE)
 
 find_package(Taglib 1.6 REQUIRED)
 
 include_directories(${CMAKE_BINARY_DIR} ${PHONON_INCLUDES})
 
 add_subdirectory( doc )
 add_subdirectory( tests )
 add_subdirectory( pics )
 
 find_package(TunePimp)
 set_package_properties(FEATURE PROPERTIES DESCRIPTION "A library for developing MusicBrainz enabled tagging applications" URL "http://www.musicbrainz.org/products/tunepimp" TYPE OPTIONAL PURPOSE "Provides MusicBrainz tagging in Juk.")
 if(TUNEPIMP_FOUND)
 	set(HAVE_TUNEPIMP 1)
 	if(TUNEPIMP_FOUND_VERSION_4)
 		set(HAVE_TUNEPIMP 4)
         endif(TUNEPIMP_FOUND_VERSION_4)	
         if(TUNEPIMP_FOUND_VERSION_5)
                 set(HAVE_TUNEPIMP 5)
         endif(TUNEPIMP_FOUND_VERSION_5) 	
 else(TUNEPIMP_FOUND)
 	set(HAVE_TUNEPIMP 0)
 endif(TUNEPIMP_FOUND)	
 
 ########### next target ###############
 
 include_directories( ${TAGLIB_INCLUDES} )
 add_definitions(-DQT_STL)
 
 # Look for Ogg Opus support in taglib (not released yet)
 cmake_push_check_state()
 set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${TAGLIB_INCLUDES})
 check_include_file_cxx(opusfile.h TAGLIB_HAS_OPUSFILE)
 cmake_pop_check_state()
 
 configure_file (config-juk.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-juk.h )
 
 set(tunepimp_SRCS)
 if(TUNEPIMP_FOUND)
 	set(tunepimp_SRCS trackpickerdialog.cpp)
 	include_directories( ${TUNEPIMP_INCLUDE_DIR} )
 endif(TUNEPIMP_FOUND)	
 
 set(juk_SRCS  ${tunepimp_SRCS}
    advancedsearchdialog.cpp
    slider.cpp
    svghandler.cpp
    volumepopupbutton.cpp
    actioncollection.cpp
    cache.cpp
    categoryreaderinterface.cpp
    collectionlist.cpp
    coverdialog.cpp
    covericonview.cpp
    coverinfo.cpp
    covermanager.cpp
    coverproxy.cpp
    dbuscollectionproxy.cpp
    deletedialog.cpp
    directorylist.cpp
    dynamicplaylist.cpp
    exampleoptions.cpp
    folderplaylist.cpp
    filehandle.cpp
    filerenamer.cpp
    filerenameroptions.cpp
    filerenamerconfigdlg.cpp
    webimagefetcher.cpp
    historyplaylist.cpp
    juk.cpp
    keydialog.cpp
    lyricswidget.cpp
    main.cpp
    mediafiles.cpp
    mpris2/mediaplayer2.cpp
    mpris2/mediaplayer2player.cpp
    mpris2/mpris2.cpp
    musicbrainzquery.cpp
    nowplaying.cpp
    playermanager.cpp
    playlist.cpp
    playlistbox.cpp
    playlistcollection.cpp
    playlistinterface.cpp
    playlistitem.cpp
    playlistsearch.cpp
    playlistsplitter.cpp
    scrobbler.cpp
    scrobbleconfigdlg.cpp
    searchplaylist.cpp
    searchwidget.cpp
    slideraction.cpp
    sortedstringlist.cpp
-   splashscreen.cpp
    statuslabel.cpp
    stringshare.cpp
    systemtray.cpp
    tag.cpp
    tageditor.cpp
    tagguesser.cpp
    tagguesserconfigdlg.cpp
    tagrenameroptions.cpp
    tagtransactionmanager.cpp
    tracksequenceiterator.cpp
    tracksequencemanager.cpp
    treeviewitemplaylist.cpp
    upcomingplaylist.cpp
    ktrm.cpp
    viewmode.cpp )
 
 ecm_qt_declare_logging_category(juk_SRCS HEADER juk_debug.h
                                 IDENTIFIER JUK_LOG CATEGORY_NAME org.kde.juk)
 
 qt5_add_dbus_adaptor( juk_SRCS org.kde.juk.collection.xml
     dbuscollectionproxy.h DBusCollectionProxy )
 qt5_add_dbus_adaptor( juk_SRCS org.kde.juk.player.xml playermanager.h PlayerManager)
 qt5_add_dbus_adaptor( juk_SRCS org.kde.juk.search.xml searchwidget.h SearchWidget)
 
 
 ki18n_wrap_ui(juk_SRCS
 	filerenamerbase.ui
 	filerenameroptionsbase.ui
 	directorylistbase.ui
 	trackpickerdialogbase.ui
 	tagguesserconfigdlgwidget.ui
 	exampleoptionsbase.ui
 	coverdialogbase.ui
 	deletedialogbase.ui
 	tageditor.ui
 )
 
 file(GLOB ICONS_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/*-apps-juk.png")
 ecm_add_app_icon(juk_SRCS ICONS ${ICONS_SRCS})
 add_executable(juk ${juk_SRCS})
 
 kde_target_enable_exceptions(juk PRIVATE)
 target_compile_definitions(juk PRIVATE QT_USE_QSTRINGBUILDER)
 
 if(NOT MSVC AND NOT ( WIN32 AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel" ) )
     set( LIBMATH m )
 endif()
 
 target_link_libraries(juk ${LIBMATH} Qt5::Gui Qt5::Svg Qt5::Widgets
     Qt5::Network KF5::ConfigCore KF5::CoreAddons KF5::Completion KF5::GlobalAccel
     KF5::I18n KF5::IconThemes KF5::TextWidgets KF5::XmlGui KF5::WindowSystem
     KF5::WidgetsAddons KF5::Wallet KF5::KDELibs4Support Phonon::phonon4qt5 ${TAGLIB_LIBRARIES})
 if(TUNEPIMP_FOUND)
 	target_link_libraries(juk ${TUNEPIMP_LIBRARIES})
 endif(TUNEPIMP_FOUND)
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 install(TARGETS juk  ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 
 ########### install files ###############
 
 install( PROGRAMS org.kde.juk.desktop  DESTINATION  ${XDG_APPS_INSTALL_DIR} )
 install( FILES juk.notifyrc jukui.rc jukui-rtl.rc  DESTINATION  ${KXMLGUI_INSTALL_DIR}/juk )
 install( FILES org.kde.juk.appdata.xml DESTINATION ${SHARE_INSTALL_PREFIX}/metainfo )
 install( FILES jukservicemenu.desktop  DESTINATION
 ${SERVICES_INSTALL_DIR}/ServiceMenus )
 install( FILES org.kde.juk.collection.xml org.kde.juk.player.xml org.kde.juk.search.xml DESTINATION ${DBUS_INTERFACES_INSTALL_DIR} )
 
 ecm_install_icons(ICONS
     128-apps-juk.png
     16-apps-juk.png
     32-apps-juk.png
     48-apps-juk.png
     64-apps-juk.png
     DESTINATION ${ICON_INSTALL_DIR}
     THEME hicolor
 )
diff --git a/collectionlist.cpp b/collectionlist.cpp
index c146a327..6a56dd8e 100644
--- a/collectionlist.cpp
+++ b/collectionlist.cpp
@@ -1,604 +1,597 @@
 /**
  * Copyright (C) 2002-2004 Scott Wheeler <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.
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  * PARTICULAR PURPOSE. See the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "collectionlist.h"
 
 #include <klocale.h>
 #include <kmessagebox.h>
 #include <kmenu.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <kactioncollection.h>
 #include <kstandarddirs.h>
 #include <ktoolbarpopupaction.h>
 #include <kdirwatch.h>
 
 #include <QList>
 #include <QDragMoveEvent>
 #include <QDropEvent>
 #include <QApplication>
 #include <QTimer>
 #include <QTime>
 #include <QClipboard>
 #include <QFileInfo>
 #include <QHeaderView>
 #include <QSaveFile>
 
 #include "playlistcollection.h"
-#include "splashscreen.h"
 #include "stringshare.h"
 #include "cache.h"
 #include "actioncollection.h"
 #include "tag.h"
 #include "viewmode.h"
 #include "juk_debug.h"
 
 using ActionCollection::action;
 
 ////////////////////////////////////////////////////////////////////////////////
 // static methods
 ////////////////////////////////////////////////////////////////////////////////
 
 CollectionList *CollectionList::m_list = 0;
 
 CollectionList *CollectionList::instance()
 {
     return m_list;
 }
 
 static QTime stopwatch;
 
 void CollectionList::startLoadingCachedItems()
 {
     if(!m_list)
         return;
 
     qCDebug(JUK_LOG) << "Starting to load cached items";
     stopwatch.start();
 
     if(!Cache::instance()->prepareToLoadCachedItems()) {
         qCCritical(JUK_LOG) << "Unable to setup to load cache... perhaps it doesn't exist?";
 
         completedLoadingCachedItems();
         return;
     }
 
     qCDebug(JUK_LOG) << "Kicked off first batch";
     QTimer::singleShot(0, this, SLOT(loadNextBatchCachedItems()));
 }
 
 void CollectionList::loadNextBatchCachedItems()
 {
     Cache *cache = Cache::instance();
     bool done = false;
 
     for(int i = 0; i < 20; ++i) {
         FileHandle cachedItem(cache->loadNextCachedItem());
 
         if(cachedItem.isNull()) {
             done = true;
             break;
         }
 
         // This may have already been created via a loaded playlist.
         if(!m_itemsDict.contains(cachedItem.absFilePath())) {
             CollectionListItem *newItem = new CollectionListItem(this, cachedItem);
             setupItem(newItem);
         }
     }
 
-    SplashScreen::update();
-
     if(!done) {
         QTimer::singleShot(0, this, SLOT(loadNextBatchCachedItems()));
     }
     else {
         completedLoadingCachedItems();
     }
 }
 
 void CollectionList::completedLoadingCachedItems()
 {
     // The CollectionList is created with sorting disabled for speed.  Re-enable
     // it here, and perform the sort.
     KConfigGroup config(KSharedConfig::openConfig(), "Playlists");
 
     Qt::SortOrder order = Qt::DescendingOrder;
     if(config.readEntry("CollectionListSortAscending", true))
         order = Qt::AscendingOrder;
 
     m_list->sortByColumn(config.readEntry("CollectionListSortColumn", 1), order);
 
-    SplashScreen::finishedLoading();
-
     qCDebug(JUK_LOG) << "Finished loading cached items, took" << stopwatch.elapsed() << "ms";
     qCDebug(JUK_LOG) << m_itemsDict.size() << "items are in the CollectionList";
 
     emit cachedItemsLoaded();
 }
 
 void CollectionList::initialize(PlaylistCollection *collection)
 {
     if(m_list)
         return;
 
     // We have to delay initialization here because dynamic_cast or comparing to
     // the collection instance won't work in the PlaylistBox::Item initialization
     // won't work until the CollectionList is fully constructed.
 
     m_list = new CollectionList(collection);
     m_list->setName(i18n("Collection List"));
 
     collection->setupPlaylist(m_list, "folder-sound");
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // public methods
 ////////////////////////////////////////////////////////////////////////////////
 
 CollectionListItem *CollectionList::createItem(const FileHandle &file, QTreeWidgetItem *, bool)
 {
     // It's probably possible to optimize the line below away, but, well, right
     // now it's more important to not load duplicate items.
 
     if(m_itemsDict.contains(file.absFilePath()))
         return 0;
 
     CollectionListItem *item = new CollectionListItem(this, file);
 
     if(!item->isValid()) {
         qCCritical(JUK_LOG) << "CollectionList::createItem() -- A valid tag was not created for \""
                  << file.absFilePath() << "\"";
         delete item;
         return 0;
     }
 
     setupItem(item);
 
     return item;
 }
 
 void CollectionList::clearItems(const PlaylistItemList &items)
 {
     foreach(PlaylistItem *item, items) {
         delete item;
     }
 
     dataChanged();
 }
 
 void CollectionList::setupTreeViewEntries(ViewMode *viewMode) const
 {
     TreeViewMode *treeViewMode = dynamic_cast<TreeViewMode *>(viewMode);
     if(!treeViewMode) {
         qCWarning(JUK_LOG) << "Can't setup entries on a non-tree-view mode!\n";
         return;
     }
 
     QList<int> columnList;
     columnList << PlaylistItem::ArtistColumn;
     columnList << PlaylistItem::GenreColumn;
     columnList << PlaylistItem::AlbumColumn;
 
     foreach(int column, columnList)
         treeViewMode->addItems(m_columnTags[column]->keys(), column);
 }
 
 void CollectionList::slotNewItems(const KFileItemList &items)
 {
     QStringList files;
 
     for(KFileItemList::ConstIterator it = items.constBegin(); it != items.constEnd(); ++it)
         files.append((*it).url().path());
 
     addFiles(files);
     update();
 }
 
 void CollectionList::slotRefreshItems(const QList<QPair<KFileItem, KFileItem> > &items)
 {
     for(int i = 0; i < items.count(); ++i) {
         const KFileItem fileItem = items[i].second;
         CollectionListItem *item = lookup(fileItem.url().path());
 
         if(item) {
             item->refreshFromDisk();
 
             // If the item is no longer on disk, remove it from the collection.
 
             if(item->file().fileInfo().exists())
                 item->repaint();
             else
                 delete item;
         }
     }
 
     update();
 }
 
 void CollectionList::slotDeleteItem(const KFileItem &item)
 {
     delete lookup(item.url().path());
 }
 
 void CollectionList::saveItemsToCache() const
 {
     qCDebug(JUK_LOG) << "Saving collection list to cache";
 
     QSaveFile f(Cache::fileHandleCacheFileName());
 
     if(!f.open(QIODevice::WriteOnly)) {
         qCCritical(JUK_LOG) << "Error saving cache:" << f.errorString();
         return;
     }
 
     QByteArray data;
     QDataStream s(&data, QIODevice::WriteOnly);
     s.setVersion(QDataStream::Qt_4_3);
 
     QHash<QString, CollectionListItem *>::const_iterator it;
     for(it = m_itemsDict.begin(); it != m_itemsDict.end(); ++it) {
         s << it.key();
         s << (*it)->file();
     }
 
     QDataStream fs(&f);
 
     qint32 checksum = qChecksum(data.data(), data.size());
 
     fs << qint32(Cache::playlistItemsCacheVersion)
        << checksum
        << data;
 
     if(!f.commit())
         qCCritical(JUK_LOG) << "Error saving cache:" << f.errorString();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // public slots
 ////////////////////////////////////////////////////////////////////////////////
 
 void CollectionList::paste()
 {
     decode(QApplication::clipboard()->mimeData());
 }
 
 void CollectionList::clear()
 {
     int result = KMessageBox::warningContinueCancel(this,
         i18n("Removing an item from the collection will also remove it from "
              "all of your playlists. Are you sure you want to continue?\n\n"
              "Note, however, that if the directory that these files are in is in "
              "your \"scan on startup\" list, they will be readded on startup."));
 
     if(result == KMessageBox::Continue) {
         Playlist::clear();
         emit signalCollectionChanged();
     }
 }
 
 void CollectionList::slotCheckCache()
 {
     PlaylistItemList invalidItems;
     qCDebug(JUK_LOG) << "Starting to check cached items for consistency";
     stopwatch.start();
 
     int i = 0;
     foreach(CollectionListItem *item, m_itemsDict) {
         if(!item->checkCurrent())
             invalidItems.append(item);
         if(++i == (m_itemsDict.size() / 2))
             qCDebug(JUK_LOG) << "Checkpoint";
     }
 
     clearItems(invalidItems);
 
     qCDebug(JUK_LOG) << "Finished consistency check, took" << stopwatch.elapsed() << "ms";
 }
 
 void CollectionList::slotRemoveItem(const QString &file)
 {
     delete m_itemsDict[file];
 }
 
 void CollectionList::slotRefreshItem(const QString &file)
 {
     if(m_itemsDict[file])
         m_itemsDict[file]->refresh();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // protected methods
 ////////////////////////////////////////////////////////////////////////////////
 
 CollectionList::CollectionList(PlaylistCollection *collection) :
     Playlist(collection, true),
     m_columnTags(15, 0)
 {
     QAction *spaction = ActionCollection::actions()->addAction("showPlaying");
     spaction->setText(i18n("Show Playing"));
     connect(spaction, SIGNAL(triggered(bool)), SLOT(slotShowPlaying()));
 
     connect(action<KToolBarPopupAction>("back")->menu(), SIGNAL(aboutToShow()),
             this, SLOT(slotPopulateBackMenu()));
     connect(action<KToolBarPopupAction>("back")->menu(), SIGNAL(triggered(QAction*)),
             this, SLOT(slotPlayFromBackMenu(QAction*)));
     setSortingEnabled(false); // Temporarily disable sorting to add items faster.
 
     m_columnTags[PlaylistItem::ArtistColumn] = new TagCountDict;
     m_columnTags[PlaylistItem::AlbumColumn] = new TagCountDict;
     m_columnTags[PlaylistItem::GenreColumn] = new TagCountDict;
 
     // Even set to true it wouldn't work with this class due to other checks
     setAllowDuplicates(false);
 }
 
 CollectionList::~CollectionList()
 {
     KConfigGroup config(KSharedConfig::openConfig(), "Playlists");
     config.writeEntry("CollectionListSortColumn", header()->sortIndicatorSection());
     config.writeEntry("CollectionListSortAscending", header()->sortIndicatorOrder() == Qt::AscendingOrder);
 
     // In some situations the dataChanged signal from clearItems will cause observers to
     // subsequently try to access a deleted item.  Since we're going away just remove all
     // observers.
 
     clearObservers();
 
     // The CollectionListItems will try to remove themselves from the
     // m_columnTags member, so we must make sure they're gone before we
     // are.
 
     clearItems(items());
 
     qDeleteAll(m_columnTags);
     m_columnTags.clear();
 }
 
 void CollectionList::dropEvent(QDropEvent *e)
 {
     if(e->source() == this)
         return; // Don't rearrange in the CollectionList.
     else
         Playlist::dropEvent(e);
 }
 
 void CollectionList::dragMoveEvent(QDragMoveEvent *e)
 {
     if(e->source() != this)
         Playlist::dragMoveEvent(e);
     else
         e->setAccepted(false);
 }
 
 QString CollectionList::addStringToDict(const QString &value, int column)
 {
     if(column > m_columnTags.count() || value.trimmed().isEmpty())
         return QString();
 
     if(m_columnTags[column]->contains(value))
         ++((*m_columnTags[column])[value]);
     else {
         m_columnTags[column]->insert(value, 1);
         emit signalNewTag(value, column);
     }
 
     return value;
 }
 
 QStringList CollectionList::uniqueSet(UniqueSetType t) const
 {
     int column;
 
     switch(t)
     {
     case Artists:
         column = PlaylistItem::ArtistColumn;
     break;
 
     case Albums:
         column = PlaylistItem::AlbumColumn;
     break;
 
     case Genres:
         column = PlaylistItem::GenreColumn;
     break;
 
     default:
         return QStringList();
     }
 
     return m_columnTags[column]->keys();
 }
 
 CollectionListItem *CollectionList::lookup(const QString &file) const
 {
     return m_itemsDict.value(file, 0);
 }
 
 void CollectionList::removeStringFromDict(const QString &value, int column)
 {
     if(column > m_columnTags.count() || value.trimmed().isEmpty())
         return;
 
     if(m_columnTags[column]->contains(value) &&
        --((*m_columnTags[column])[value])) // If the decrement goes to 0...
     {
         emit signalRemovedTag(value, column);
         m_columnTags[column]->remove(value);
     }
 }
 
 void CollectionList::addWatched(const QString &file)
 {
     m_dirWatch->addFile(file);
 }
 
 void CollectionList::removeWatched(const QString &file)
 {
     m_dirWatch->removeFile(file);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CollectionListItem public methods
 ////////////////////////////////////////////////////////////////////////////////
 
 void CollectionListItem::refresh()
 {
     int offset = CollectionList::instance()->columnOffset();
     int columns = lastColumn() + offset + 1;
 
     sharedData()->metadata.resize(columns);
     sharedData()->cachedWidths.resize(columns);
 
     for(int i = offset; i < columns; i++) {
         setText(i, text(i));
         int id = i - offset;
         if(id != TrackNumberColumn && id != LengthColumn) {
             // All columns other than track num and length need local-encoded data for sorting
 
             QString toLower = text(i).toLower();
 
             // For some columns, we may be able to share some strings
 
             if((id == ArtistColumn) || (id == AlbumColumn) ||
                (id == GenreColumn)  || (id == YearColumn)  ||
                (id == CommentColumn))
             {
                 toLower = StringShare::tryShare(toLower);
 
                 if(id != YearColumn && id != CommentColumn && sharedData()->metadata[id] != toLower) {
                     CollectionList::instance()->removeStringFromDict(sharedData()->metadata[id], id);
                     CollectionList::instance()->addStringToDict(text(i), id);
                 }
             }
 
             sharedData()->metadata[id] = toLower;
         }
 
         int newWidth = treeWidget()->fontMetrics().width(text(i));
         if(newWidth != sharedData()->cachedWidths[i])
             playlist()->slotWeightDirty(i);
 
         sharedData()->cachedWidths[i] = newWidth;
     }
 
     for(PlaylistItemList::Iterator it = m_children.begin(); it != m_children.end(); ++it) {
         (*it)->playlist()->update();
         (*it)->playlist()->dataChanged();
     }
     if(treeWidget()->isVisible())
         treeWidget()->viewport()->update();
 
     CollectionList::instance()->dataChanged();
     emit CollectionList::instance()->signalCollectionChanged();
 }
 
 PlaylistItem *CollectionListItem::itemForPlaylist(const Playlist *playlist)
 {
     if(playlist == CollectionList::instance())
         return this;
 
     PlaylistItemList::ConstIterator it;
     for(it = m_children.constBegin(); it != m_children.constEnd(); ++it)
         if((*it)->playlist() == playlist)
             return *it;
     return 0;
 }
 
 void CollectionListItem::updateCollectionDict(const QString &oldPath, const QString &newPath)
 {
     CollectionList *collection = CollectionList::instance();
 
     if(!collection)
         return;
 
     collection->removeFromDict(oldPath);
     collection->addToDict(newPath, this);
 }
 
 void CollectionListItem::repaint() const
 {
     // FIXME repaint
     /*QItemDelegate::repaint();
     for(PlaylistItemList::ConstIterator it = m_children.constBegin(); it != m_children.constEnd(); ++it)
         (*it)->repaint();*/
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CollectionListItem protected methods
 ////////////////////////////////////////////////////////////////////////////////
 
 CollectionListItem::CollectionListItem(CollectionList *parent, const FileHandle &file) :
     PlaylistItem(parent),
     m_shuttingDown(false)
 {
     parent->addToDict(file.absFilePath(), this);
 
     sharedData()->fileHandle = file;
 
     if(file.tag()) {
         refresh();
         parent->dataChanged();
     }
     else {
         qCCritical(JUK_LOG) << "CollectionListItem::CollectionListItem() -- Tag() could not be created.";
     }
-
-    SplashScreen::increment();
 }
 
 CollectionListItem::~CollectionListItem()
 {
     m_shuttingDown = true;
 
     foreach(PlaylistItem *item, m_children)
         delete item;
 
     CollectionList *l = CollectionList::instance();
     if(l) {
         l->removeFromDict(file().absFilePath());
         l->removeStringFromDict(file().tag()->album(), AlbumColumn);
         l->removeStringFromDict(file().tag()->artist(), ArtistColumn);
         l->removeStringFromDict(file().tag()->genre(), GenreColumn);
     }
 }
 
 void CollectionListItem::addChildItem(PlaylistItem *child)
 {
     m_children.append(child);
 }
 
 void CollectionListItem::removeChildItem(PlaylistItem *child)
 {
     if(!m_shuttingDown)
         m_children.removeAll(child);
 }
 
 bool CollectionListItem::checkCurrent()
 {
     if(!file().fileInfo().exists() || !file().fileInfo().isFile())
         return false;
 
     if(!file().current()) {
         file().refresh();
         refresh();
     }
 
     return true;
 }
 
 // vim: set et sw=4 tw=0 sta:
diff --git a/collectionlist.h b/collectionlist.h
index 69f91e3b..a1622e5a 100644
--- a/collectionlist.h
+++ b/collectionlist.h
@@ -1,216 +1,216 @@
 /**
  * Copyright (C) 2002-2004 Scott Wheeler <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.
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  * PARTICULAR PURPOSE. See the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef COLLECTIONLIST_H
-#define COLLECTIONLIST_H
+#ifndef JUK_COLLECTIONLIST_H
+#define JUK_COLLECTIONLIST_H
 
 #include <QHash>
 #include <QVector>
 
 #include "playlist.h"
 #include "playlistitem.h"
 
 class ViewMode;
 class KFileItem;
 class KFileItemList;
 class KDirWatch;
 
 /**
  * This type is for mapping QString track attributes like the album, artist
  * and track to an integer count representing the number of outstanding items
  * that hold the string.
  */
 
 typedef QHash<QString, int> TagCountDict;
 typedef QHashIterator<QString, int> TagCountDictIterator;
 
 /**
  * We then have an array of dicts, one for each column in the list view.
  * The array is sparse (not every vector will have a TagCountDict so we use
  * pointers.
  */
 
 typedef QVector<TagCountDict *> TagCountDicts;
 
 /**
  * This is the "collection", or all of the music files that have been opened
  * in any playlist and not explicitly removed from the collection.
  *
  * It is being implemented as a "semi-singleton" because I need universal access
  * to just one instance.  However, because the collection needs initialization
  * parameters (that will not always be available when an instance is needed).
  * Hence there will be the familiar singleton "instance()" method allong with an
  * "initialize()" method.
  */
 
 class CollectionListItem : public PlaylistItem
 {
     friend class Playlist;
     friend class CollectionList;
     friend class PlaylistItem;
 
 public:
     virtual void refresh();
     PlaylistItem *itemForPlaylist(const Playlist *playlist);
     void updateCollectionDict(const QString &oldPath, const QString &newPath);
     void repaint() const;
     PlaylistItemList children() const { return m_children; }
 
 protected:
     CollectionListItem(CollectionList *parent, const FileHandle &file);
     virtual ~CollectionListItem();
 
     void addChildItem(PlaylistItem *child);
     void removeChildItem(PlaylistItem *child);
 
     /**
      * Returns true if the item is now up to date (even if this required a refresh) or
      * false if the item is invalid.
      */
     bool checkCurrent();
 
     virtual CollectionListItem *collectionItem() { return this; }
 
 private:
     bool m_shuttingDown;
     PlaylistItemList m_children;
 };
 
 class CollectionList : public Playlist
 {
     friend class CollectionListItem;
 
     Q_OBJECT
 
 public:
     /**
      * A variety of unique value lists will be kept in the collection.  This
      * enum can be used as an index into those structures.
      */
     enum UniqueSetType { Artists = 0, Albums = 1, Genres = 2 };
 
     static CollectionList *instance();
     static void initialize(PlaylistCollection *collection);
 
     /**
      * Returns a unique set of values associated with the type specified.
      */
     QStringList uniqueSet(UniqueSetType t) const;
 
     CollectionListItem *lookup(const QString &file) const;
 
     virtual CollectionListItem *createItem(const FileHandle &file,
                                      QTreeWidgetItem * = 0,
                                      bool = false);
 
     void emitVisibleColumnsChanged() { emit signalVisibleColumnsChanged(); }
 
     virtual void clearItems(const PlaylistItemList &items);
 
     void setupTreeViewEntries(ViewMode *viewMode) const;
 
     virtual bool canReload() const { return true; }
 
     void saveItemsToCache() const;
 
 public slots:
     virtual void paste();
     virtual void clear();
     void slotCheckCache();
 
     void slotRemoveItem(const QString &file);
     void slotRefreshItem(const QString &file);
 
     void slotNewItems(const KFileItemList &items);
     void slotRefreshItems(const QList<QPair<KFileItem, KFileItem> > &items);
     void slotDeleteItem(const KFileItem &item);
 
 protected:
     CollectionList(PlaylistCollection *collection);
     virtual ~CollectionList();
 
     virtual void dropEvent(QDropEvent *e);
     virtual void dragMoveEvent(QDragMoveEvent *e);
 
     // These methods are used by CollectionListItem, which is a friend class.
 
     void addToDict(const QString &file, CollectionListItem *item) { m_itemsDict.insert(file, item); }
     void removeFromDict(const QString &file) { m_itemsDict.remove(file); }
 
     // These methods are also used by CollectionListItem, to manage the
     // strings used in generating the unique sets and tree view mode playlists.
 
     QString addStringToDict(const QString &value, int column);
     void removeStringFromDict(const QString &value, int column);
 
     void addWatched(const QString &file);
     void removeWatched(const QString &file);
 
     virtual bool hasItem(const QString &file) const { return m_itemsDict.contains(file); }
 
 signals:
     void signalCollectionChanged();
 
     /**
      * This is emitted when the set of columns that is visible is changed.
      *
      * \see Playlist::hideColumn()
      * \see Playlist::showColumn()
      * \see Playlsit::isColumnVisible()
      */
     void signalVisibleColumnsChanged();
     void signalNewTag(const QString &, unsigned);
     void signalRemovedTag(const QString &, unsigned);
 
     // Emitted once cached items are loaded, which allows for folder scanning
     // and invalid track detection to proceed.
     void cachedItemsLoaded();
 
 public slots:
     /**
      * Loads the CollectionListItems from the Cache.  Should be called after program
      * initialization.
      */
     void startLoadingCachedItems();
 
     /**
      * Loads a few items at a time. Intended to be single-shotted into the event
      * loop so that loading the music doesn't freeze the GUI.
      */
     void loadNextBatchCachedItems();
 
     /**
-     * Teardown from cache loading (e.g. splash screen, sorting, etc.). Should
+     * Teardown from cache loading (e.g. a sort operation). Should
      * always be called if startLoadingCachedItems is called.
      */
     void completedLoadingCachedItems();
 
 private:
     /**
      * Just the size of the above enum to keep from hard coding it in several
      * locations.
      */
     static const int m_uniqueSetCount = 3;
 
     static CollectionList *m_list;
     QHash<QString, CollectionListItem *> m_itemsDict;
     KDirWatch *m_dirWatch;
     TagCountDicts m_columnTags;
 };
 
 #endif
 
 // vim: set et sw=4 tw=0 sta:
diff --git a/doc/index.docbook b/doc/index.docbook
index 3ff07518..4b8c1370 100644
--- a/doc/index.docbook
+++ b/doc/index.docbook
@@ -1,1758 +1,1747 @@
 <?xml version="1.0" ?>
 <!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.5-Based Variant V1.1//EN" "dtd/kdedbx45.dtd" [
   <!ENTITY juk "<application>JuK</application>">
   <!ENTITY % addindex "IGNORE">
   <!ENTITY % English "INCLUDE">
 ]>
 
 <book id="juk" lang="&language;">
 
 <bookinfo>
 <title>The &juk; Handbook</title>
 
 <authorgroup>
 <author>&Lauri.Watts; &Lauri.Watts.mail;</author>
 <author>
 <firstname>Michael</firstname>
 <surname>Pyne</surname>
 <affiliation>
 <address><email>michael.pyne@kdemail.net</email></address>
 </affiliation>
 </author>
 
 <othercredit role="developer">
 <firstname>Scott</firstname>
 <surname>Wheeler</surname>
 <affiliation>
 <address>&Scott.Wheeler.mail;</address>
 </affiliation>
 </othercredit>
 
 <!-- TRANS:ROLES_OF_TRANSLATORS -->
 
 </authorgroup>
 
 <copyright>
 <year>2001</year>
 <year>2002</year>
 <year>2004</year>
 <holder>&Scott.Wheeler;</holder>
 </copyright>
 <legalnotice>&FDLNotice;</legalnotice>
 
 <date>2013-11-08</date>
 <releaseinfo>3.11 (&kde; 4.12)</releaseinfo>
 
 <abstract>
 <para>
 &juk; is a jukebox, tagger and music collection manager.
 </para>
 </abstract>
 
 <keywordset>
 <keyword>KDE</keyword>
 <keyword>kdemultimedia</keyword>
 <keyword>audio</keyword>
 <keyword>tagger</keyword>
 <keyword>player</keyword>
 <keyword>jukebox</keyword>
 <keyword>JuK</keyword>
 </keywordset>
 
 </bookinfo>
 
 <chapter id="introduction">
 <title>Introduction</title>
 
 <para>
 &juk; is, well, a jukebox.  As is typical with many jukebox
 applications, &juk; allows you to edit the <quote>tags</quote> of your
 audio files, and manage your collection and playlists.
 </para>
 </chapter>
 
 <chapter id="using-juk">
 <title>Using &juk;</title>
 
 <para>
 <screenshot>
 <screeninfo>Here's a screenshot of &juk;</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="juk-main.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
 	    <phrase>Screenshot of &juk; in action.</phrase>
 	  </textobject>
 	</mediaobject>
 </screenshot>
 </para>
 
 <para>&juk; maintains a list of all files that it knows about.  This
 is called the <guilabel>Collection List</guilabel>.  The collection
 list is specific to &juk; and is not shared with other
 applications.</para>
 
 <para>Independent of the Collection List, are playlists.  You can have
 as many playlists as you want. You can use &juk; created playlists
 with other media players (such as &amarok; or
 <application>xmms</application>) and you can manage playlists created
 in those applications from within &juk;.</para>
 
 <para>You can add files to the Collection List individually, using
 <menuchoice><guimenu>File</guimenu><guimenuitem>Open
 ...</guimenuitem></menuchoice> and selecting them from a standard
 &kde; file dialog.  You can add entire folders using
 <menuchoice><guimenu>File</guimenu><guimenuitem>Manage
 Folders...</guimenuitem></menuchoice>.  Folders added this way
 will be rescanned every time you start &juk;. You can even define folders
 inside these folders that will be excluded from scan.
 <!-- ask scott:
      Asked 2004-04-27 (mpyne), Choosing Reload from the Collection
      List context menu will result in a rescan.  Also, a KDirWatch
      watches the folders, but is apparently not recursive. -->
 You can force the folders to be rescanned by right-clicking on the <guilabel>Collection List</guilabel>
 icon, and selecting <guimenuitem>Reload</guimenuitem>.</para>
 
 <para>Adding a song to a playlist will automatically add its file to
 the Collection List, but adding a file to the Collection List won't
 automatically add the song to any playlists.</para>
 
 <para>You can quickly create a playlist from your entire Collection
 List, by &RMB; clicking on the <guilabel>Collection List</guilabel>
 icon, and choosing <guimenuitem>Duplicate</guimenuitem>.  The
 resulting playlist is a normal playlist, and editing it will not
 affect the <guilabel>Collection List</guilabel>.</para>
 
 <para>You can add playlist files created outside &juk; individually by
 selecting them with
 <menuchoice><guimenu>File</guimenu><guimenuitem>Open
 ...</guimenuitem></menuchoice>.  Any playlist files found in
 folders you add with
 <menuchoice><guimenu>File</guimenu><guimenuitem>Manage
 Folders...</guimenuitem></menuchoice> will also be added
 automatically.</para>
 
 <para>You can create a new empty playlist, a search playlist or a 
 playlist from a folder by choosing
 <menuchoice><guimenu>File</guimenu><guisubmenu>New</guisubmenu></menuchoice>
 or the <guiicon>New</guiicon> icon on the toolbar.  You will be
 prompted for a name, and then an icon for that playlist will appear in
 the playlist pane.  You can now drag and drop files from the
 Collection List, or from other playlists, to your playlist.  Use the <guiicon>Save</guiicon>
 icon or
 <menuchoice><guimenu>File</guimenu><guimenuitem>Save</guimenuitem></menuchoice> to
 save the playlist at any time.</para>
 
 <sect1 id="collection-list-gui">
 <title>The Song List</title>
 
 <para>When you are viewing the Collection List, the main pane contains
 all the files that &juk; knows about.  When you are viewing a
 playlist, only the songs that are in that playlist are shown.  In
 either case, the appearance and behavior of the list is the
 same.</para>
 
 <para>Each song takes one row in the display. There is a column for
 each metadata field that &juk; tracks.  These columns correspond to
 the fields available to edit in the tag editor.</para>
 
 <para>You can reorder the list at any time by &LMB; clicking on the
 column header.  This will first sort the files in ascending order
 based on the contents of that column.  If you &LMB; click again on the
 same header, the files will be re-sorted in descending order.</para>
 
 <para>The columns are initially sized wide enough to show the longest
 entry available. You can resize the columns by placing your mouse
 cursor on the divider between two columns.  When the cursor changes
 from a pointer, &LMB; click and drag in the direction you want to
 resize the columns.</para>
 
 <para>You can reorder the columns by &LMB; clicking on a header and
 dragging the header to the left or right.  You cannot drag past the
 edge of the window when doing this however, so you may need to scroll
 a little to the left or right, and repeat dragging the header, until
 you have placed it in your preferred position.</para>
 
 <para>You can hide or unhide columns by &RMB; clicking on a column header,
 and clicking on the name of the column to change.</para>
 
 <para>&LMB; double clicking on a file will play it with the built-in
 player.  If another song was already playing, it will stop, and the
 new song will play.</para>
 
 <para>&RMB; clicking on a file offers you several options:</para>
 
 <variablelist>
 <varlistentry>
 <term><guimenuitem>Add to Play Queue</guimenuitem></term>
 <listitem>
 <para>This will start playing the file as soon as the current
 song is over.  If no song is playing, the file will be played when
 you next hit the <guiicon>Play</guiicon> button.  If you have already
 chosen the <guimenuitem>Add to Play Queue</guimenuitem> option on a 
 different file, then this file will override that selection.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guimenuitem>Cut</guimenuitem></term>
 <term><guimenuitem>Copy</guimenuitem></term>
 <term><guimenuitem>Paste</guimenuitem></term>
 <listitem>
 <para>...</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guimenuitem>Remove from Playlist</guimenuitem></term>
 <listitem>
 <para>If you are viewing the Collection List, choosing
 this action will remove the file from the list,
 and will also remove all corresponding entries for this song from all
 playlists.  You should note that if this file is in a folder that
 &juk; scans on startup, it will be readded to the Collection List the
 next time you start up &juk; but it won't be automatically added to
 any playlists.</para>
 <para>If you are viewing a playlist, <guimenuitem>Remove from Playlist</guimenuitem>
 will simply remove the song from the playlist.</para>
 
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guimenuitem>Edit <replaceable>Column Title</replaceable></guimenuitem></term>
 <listitem>
 <para>Will allow you to edit the currently highlighted song, in the
 column you clicked in.  For example, if you do not have the tag editor
 visible, and you are busy creating a playlist, but you notice a
 mis-spelling in an artist name, you can edit it directly with this
 menu item.</para>
 <para>Changes made in this manner are always saved immediately as soon
 as you click elsewhere and are finished editing.</para>
 <para>This menu item will be disabled if &juk; detects that the track you
 have selected is read-only.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guimenuitem>Refresh</guimenuitem></term>
 <listitem>
 <para>This will reload the tag information of the selected files, in
 case the files have been changed while &juk; was running.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guimenuitem>Delete</guimenuitem></term>
 <listitem>
 <para>This will remove the file from the Collection List, remove all
 entries for the song in all playlists, and delete the file from your
 disk.  You cannot undo this, although you will be asked to confirm
 your choice.  Use this with caution.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guisubmenu>Guess Tag Information</guisubmenu></term>
 <listitem>
 <para>This will make &juk; try to guess information such as the
 Artist and Title of a song.  &juk; employs different methods of guessing:
   <variablelist>
 
   <varlistentry><term><guimenuitem>From File Name</guimenuitem></term>
   <listitem><para>&juk; will try to guess the tags of the song based on its filename.
   For example, a song name such as <filename>Roxette - You've Got the Look.mp3</filename>
   would guess Roxette for the artist and You've Got the Look as the title.  You
   can adjust the way &juk; guesses for tags by selecting <menuchoice><guimenu>Settings
   </guimenu><guimenuitem>Tag Guesser...</guimenuitem></menuchoice>, which will open the
   <link linkend="juk-tag-guesser-configuration">Tag Guesser dialog</link>. &juk; will not
   replace tags that it did not guess from the file name.</para>
   </listitem>
   </varlistentry>
 
   <varlistentry><term><guimenuitem>From Internet</guimenuitem></term>
   <listitem><para>&juk; will try to guess the tags of the song by using the
   MusicBrainz program.  You must have MusicBrainz installed for this command to work.
   </para>
   </listitem>
   </varlistentry>
 
   </variablelist>
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guimenuitem>Rename File</guimenuitem></term>
 <listitem>
 <para>This will rename the selected files to conform to a given format.  You must
 choose the way you want the files renamed first by selecting <menuchoice>
 <guimenu>Settings</guimenu><guimenuitem>File Renamer...</guimenuitem></menuchoice>.
 The resulting name of each file is based on its metadata tags.  For example,
 the Ogg Vorbis song <quote>The Theme (Metroid)</quote> by Stemage could result in
 <filename>/usr/share/music/Stemage/The Theme (Metroid).ogg</filename>.
 </para>
 </listitem>
 </varlistentry>
 <!--missing Cover Manager
 View Cover
 Get Cover From File
 Get Cover From Internet
 Delete Cover
 Show Cover Manager
 -->
 <varlistentry>
 <term><guimenuitem>Create Playlist From Selected Items</guimenuitem></term>
 <listitem>
 <para>This allows you to quickly create a playlist from songs in your Collection List.
 This function will prompt you for a name for the new playlist, and will then insert all of
 the songs that are selected into the new playlist.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guimenuitem>Add Selected Items to Audio or Data CD</guimenuitem></term>
 <listitem>
 <para>This allows you to quickly create a K3b &CD;-burning project from your selected songs.  &juk; will ask you if you would like an Audio &CD; project or a Data &CD; project, unless K3b already has a project open.</para>
 
 <para>If K3b is not already running, &juk; will start it up for you.  After that, &juk; will add your selected files to the current K3b project.  You can then save the project in K3b for burning later, or burn the &CD; right away.
 </para>
 
 </listitem>
 </varlistentry>
 
 </variablelist>
 
 </sect1>
 
 <sect1 id="juk-playlists">
 <title>&juk; Playlists</title>
 <para>A playlist is simply a collection of songs grouped by some category.  For example, you
 may have a playlist of songs that you listen to while coding, while trying to sleep, or even
 when you need a laugh.  &juk; supports several different types of playlists.
 </para>
 
 <variablelist>
 
 <varlistentry>
 <term id="juk-normal-playlists">Normal playlists</term>
 <listitem><para><inlinemediaobject><imageobject><imagedata format="PNG" fileref="normal-playlist.png"/></imageobject></inlinemediaobject>
 This is the most common kind of playlist.  It is a playlist composed of files, just
 like the Collection List.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term id="juk-history-playlists">The history playlist</term>
 <listitem><para><inlinemediaobject><imageobject><imagedata format="PNG" fileref="history-playlist.png"/></imageobject></inlinemediaobject>
 If you enable this playlist (by enabling <menuchoice><guimenu>View</guimenu><guimenuitem>Show History</guimenuitem></menuchoice>,
 this playlist will record every song that &juk; plays.  The playlist will have an extra column, <guilabel>Time</guilabel>, which
 records the exact time and date the song played.  The playlist doesn't start tracking the history until it is enabled, however.
 </para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term id="juk-search-playlists">Search playlists</term>
 <listitem><para><inlinemediaobject><imageobject><imagedata format="PNG" fileref="search-playlist.png"/></imageobject></inlinemediaobject>
 This is a playlist which is based off of a search.  You can create a playlist like this by clicking <menuchoice>
 <guimenu>File</guimenu><guisubmenu>New</guisubmenu><guimenuitem>Search Playlist</guimenuitem></menuchoice>, or by clicking on the
 <link linkend="juk-advanced-search-dialog">Search Playlist</link>
  button on the toolbar.</para>
 <para>After creating this playlist, it will keep track of which songs in the Collection List match your criteria, and automatically update itself accordingly whenever the
 Collection List changes.</para></listitem>
 </varlistentry>
 
 </variablelist>
 
 <para>Playlists are organized in the <guilabel>Playlist pane</guilabel>, which is the vertical bar at the left.  In this pane is an icon
 for every playlist you have.  There are different view mode for this pane, which can be selected from the
 <menuchoice><guimenu>View</guimenu><guisubmenu>View Modes</guisubmenu></menuchoice> menu.
 
 <variablelist>
 
 <varlistentry>
 <term id="juk-viewmode-default">Default View mode</term>
 <listitem>
 <para>
 This is the default view mode.  In this mode, all the playlists are shown as large icons, one above the other in the view mode.
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term id="juk-viewmode-compact">Compact View mode</term>
 <listitem>
 <para>
 This mode is similar to the Normal Viewmode, with the exception that the playlists are represented with horizontal bars with small icons instead
 of with square boxes.
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term id="juk-viewmode-tree">Tree View mode</term>
 <listitem>
 <para>This mode is the most powerful.  This mode is just like the Compact viewmode, except that the Collection List is now the root of a tree of virtual
 playlists.  The Collection List has three children nodes, Artist, Album, and Genre.  Each of these node has children representing all of the entries
 from that specific category.  For example, if your Collection List contains music from 4 different artists, you would have 4 entries under the artist
 node.</para>
 <para>One nifty feature of the tree view mode is something called drag-and-drop retagging.  Simply select some files in the track list, and drag them
 onto one of the artist, album, or genre nodes under Collection List.  The songs will automatically be retagged to match the item you dropped the
 tracks on.  For example, if you drag a group of tracks onto a Genre called "Rock", all of the tracks will be retagged will a Genre tag of Rock.
 </para>
 </listitem>
 </varlistentry>
 
 </variablelist>
 
 </para>
 
 </sect1>
 
 <sect1 id="juk-tagger">
 <title>The &juk; Tag Editor</title>
 
 <para>For many file formats, it is practical to use the filename to
 describe the contents of the file: <quote><filename>Report for the
 board - June 2003.doc</filename></quote> for example, may be all the
 information you need in order to find that file again.  Trying to
 capture all the useful information about a particular song however,
 could lead to filenames like this: <quote><filename>Type O Negative -
 The Glorious Liberation Of The Peoples Technocratic Republic Of
 Vinnland By The Combined Forces Of The United Territories Of
 Europa.mp3</filename></quote> or <quote><filename>Various
 Artists_15_The Smithsonian Collection of Classic Jazz Volume II_Jimmie
 Lunceford &amp; His Orchestra - Organ Grinder's
 Swing.mp3</filename></quote>.  These are neither very practical to
 use, nor do they contain all of the useful information that you might
 have collected about the song.  Adding the album, and track number,
 for example, to the first would make it even longer and more
 unmanageable, while still not telling you at a glance the year it was
 released, or what style of music it is, if you're not familiar with
 the artist.</para>
 
 <para>The solution then, is to store this kind of metadata inside the
 files themselves. Mp3 and ogg files can also contain small snippets of
 text which you can use to describe the content of the file.  There are
 several formats, but &juk; hides the details of the differences
 between them, and provides a standard way to edit a standard subset of
 well known tags for all your audio files.</para>
 
 <para>&juk;'s full featured tag editor allows you to edit the tags in
 both mp3 and ogg files.  You can edit single files or multiple files,
 and you can select a mix of mp3 and ogg files to edit.  The only
 requirement is that you have write access to the files themselves; you
 cannot edit the tags of a file that is mounted from a &CD-ROM; for
 example.</para>
 
 <sect2 id="tagging-a-single-file">
 <title>Editing the Tags in a Single File</title>
 
 <para>To edit the tag in a single file, select it in either the
 collection list or any entries it has in any playlist.  If the tag
 editor is not visible, enable it by choosing
 <menuchoice><guimenu>View</guimenu><guimenuitem>Show Tag
 Editor</guimenuitem></menuchoice>.  The tag editor displays in the
 bottom of the list view.</para>
 
 <para>Simply type into any of the editable fields to change the
 information.  When you are done, &LMB; click back in the list, and you
 will be prompted to save your changes.</para>
 
 <para>You may find that the tag editor remains disabled when you've
 clicked on a file.  This happens when &juk; has detected that the track
 is read-only.</para>
 
 <variablelist>
 <title>Tag Editor Fields</title>
 <varlistentry>
 <term><guilabel>Artist Name:</guilabel></term>
 <listitem>
 <para>The name of the Artist(s) who released the song.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>Track name:</guilabel></term>
 <listitem>
 <para>The name of the song.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>Album name:</guilabel></term>
 <listitem>
 <para>The name of the album the song was released on.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>Genre:</guilabel></term>
 <listitem>
 <para>The <quote>Style</quote> of the music.  &juk; provides a list
 corresponding roughly to the informal id3 standard, but you are free
 to type your own entries in this list.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>File name:</guilabel></term>
 <listitem>
 <para>The file name of the actual file on disk.  You can edit this
 directly, and when you save, the file will be renamed.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>Track:</guilabel></term>
 <listitem>
 <para>The position of the track on the original recording.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>Year:</guilabel></term>
 <listitem>
 <para>The year the song was released.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>Length:</guilabel></term>
 <listitem>
 <para>This is not editable, it is simply shown for information.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>Bitrate:</guilabel></term>
 <listitem>
 <para>This is not editable, it is simply shown for information.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guilabel>Comment:</guilabel></term>
 <listitem>
 <para>You can add your own free text comment here, with additional
 notes &etc;</para>
 </listitem>
 </varlistentry>
 </variablelist>
 
 <para>You can explicitly and immediately save your changes at any time
 using the
 <menuchoice><guimenu>Tagger</guimenu><guimenuitem>Save</guimenuitem></menuchoice>
 menu entry or by pressing
 <keycombo action="simul">&Ctrl;<keycap>T</keycap></keycombo>.</para>
 
 </sect2>
 
 <sect2 id="tagging-multiple-files">
 <title>Editing the Tags in Multiple Files</title>
 
 <para>You can select multiple files in the list view, and edit one or
 more fields in the tags for all files at once.</para>
 
 <para>Use &Shift; and the &LMB; to select a contiguous
 list of files, and &Ctrl; and &LMB; to select individual
 non-contiguous files.</para>
 
 <para>If the tag editor is not visible, you can enable it by choosing
 <menuchoice><guimenu>View</guimenu><guimenuitem>Show Tag
 Editor</guimenuitem></menuchoice>.  The tag editor displays in the
 bottom of the list view.</para>
 
 <para>The tag editor behaves slightly differently when you have
 selected multiple files.</para>
 
 <para>Each field in the tag editor will now show an
 <guilabel>Enable</guilabel> check box next to it.  Any field that has
 exactly the same contents for all the files you selected, displays
 that content, and is enabled for editing, with the
 <guilabel>Enable</guilabel> check box checked.</para>
 
 <!-- put screeny here -->
 
 <para>Any field that does not have matching contents in all selected
 files is not initially editable, and does not display any contents at
 all.</para>
 
 <para>To change the content of any field, check the
 <guilabel>Enable</guilabel> check box if it is not already checked, and
 edit the field as you normally would.</para>
 
 <para>When you are done, &LMB; click back in the list view and you
 will be prompted to save your changes.  The prompt dialog will show
 you a list of the affected files, so you have a chance to check that
 you are indeed altering the files you intended to.</para>
 
 <para>You can explicitly and immediately save your changes at any time
 using the
 <menuchoice><guimenu>Tagger</guimenu><guimenuitem>Save</guimenuitem></menuchoice>
 menu entry or by pressing
 <keycombo action="simul">&Ctrl;<keycap>T</keycap></keycombo>.</para>
 
 </sect2>
 
 </sect1>
 
 <sect1 id="juk-rename-dialog">
 <title>The Rename File dialog</title>
 <para>
 <screenshot>
 <screeninfo>The Rename File dialog</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="juk-file-renamer.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
 	    <phrase>Screenshot of the Rename File dialog.</phrase>
 	  </textobject>
 	</mediaobject>
 </screenshot>
 </para>
 
 <para>
   The File Renamer Configuration dialog box is used to configure the
   Rename File action, which renames a song's based on the information contained
   within its metadata tags.
 </para>
 <para>
   The whole Rename File feature is used to get consistent file names for your
   music collection (including moving the files if necessary). For example you
   may have some songs which appear on disk as <filename>01 - Title.mp3</filename>
   if you got them from <ulink url="http://amazon.com">Amazon</ulink>, while songs
   from <ulink url="http://ocremix.org/">OCRemix</ulink> might be <filename>Ailsean-
   Mega_Man_3_Mega_Fire_(OC_Remix).mp3</filename> or something along those lines.
 </para>
 <para>
   Using the file renamer allows &juk; to rename those songs to something <quote>sane</quote>
   on-disk, such as <filename>Ailsean - Mega Fire.mp3</filename> and <filename>The Strokes - Reptilia.mp3</filename>.
   You can even include paths throughout to automatically sort the music (&eg;
   by year or album), like <filename>$HOME/Music/2003/The Strokes - Reptilia.mp3</filename>.
 </para>
 <para>
   Doing this is as simple as activating the <quote>Rename File</quote> action, either from
   the <guimenu>Tagger</guimenu> menu, or right-clicking on the files. The default is the
   <keycombo>&Ctrl;<keycap>R</keycap></keycombo> shortcut. But before this is done you should
   setup how the files are to be renamed.
 </para>
 <para>
   That is done from the above mentioned dialog that can be opened with 
   <menuchoice><guimenu>Settings</guimenu><guimenuitem>File Renamer...</guimenuitem></menuchoice> menu item.
   You can define a destination path, by using a base music folder and
   then adding pieces to there. These path pieces would be based on the music
   metadata such as song title, artist, &etc;, and are added using the <guilabel>Add Category</guilabel>
   selector.
 </para>
 <para>
   Each "path piece" has a check box between it allowing a folder separator to be added.
 </para>
 <para>
   The options for each piece, which
   simply control what happens if the appropriate metadata is empty, and allow a
   prefix/suffix when the entry is substituted in, can help you to make the renaming
   procedure more effective.
 </para>
 </sect1>
 
 <sect1 id="juk-tag-guesser-configuration">
 <title>The Tag Guesser Configuration dialog</title>
 <para>
 <screenshot>
 <screeninfo>The Tag Guesser Configuration dialog</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="juk-tag-guesser.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
 	    <phrase>Screenshot of the Tag Guesser Configuration dialog.</phrase>
 	  </textobject>
 	</mediaobject>
 </screenshot>
 </para>
 
 <para>The Tag Guesser Configuration dialog is used to configure the
 <guilabel>Guess from File Name</guilabel> action.</para>
 
 <para>In the dialog you will see a list on the left of different filename scheme patterns.
 &juk; includes an extensive set of defaults patterns to match most common filenaming styles.
 If you'd like to add a new scheme, click on the <guibutton>Add</guibutton> button, and type
 in your scheme and click on <guibutton>OK</guibutton>.</para>  
 
 <para>Here you can see the currently configured file name schemes which the 
 tag editor uses to extract tag information from a 
 file name. Each string may contain one of the following placeholders:</para>
 
 <para><itemizedlist>
 <listitem><para>%t: Title</para></listitem>
 <listitem><para>%A: Album</para></listitem>
 <listitem><para>%a: Artist</para></listitem>
 <listitem><para>%T: Track</para></listitem>
 <listitem><para>%c: Comment</para></listitem>
 </itemizedlist>
 </para>
 
 <para>For example, the file name scheme <quote>[%T] %a - %t</quote> would match <quote>[01] Deep 
 Purple - Smoke on the water</quote> but not <quote>(Deep Purple) Smoke on the water</quote>. 
 For that second name, you would use the scheme <quote>(%a) %t</quote>.</para>
 
 <para>&juk; will try the schemes you have listed one at a time, starting at the top of the list.
 The first scheme which results in a match will be the scheme used to guess the song's tags.
 Some songs may match more than one scheme.  You can make sure that the correct scheme matches
 first by selecting the scheme in the list box and then using the arrow buttons to move it to the
 top of the list.
 </para>
 
 <para>You can also edit or remove a scheme from the list.  Just select the scheme in the list,
 and use the <guibutton>Modify</guibutton> button to change the scheme, or the
 <guibutton>Remove</guibutton> button to remove the scheme from the list.
 </para>
 </sect1>
 
 <sect1 id="juk-advanced-search-dialog">
 <title>The Advanced Search dialog</title>
 <para>
 <screenshot>
 <screeninfo>The Advanced Search dialog</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="juk-adv-search.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
 	    <phrase>Screenshot of the Advanced Search Dialog.</phrase>
 	  </textobject>
 	</mediaobject>
 </screenshot>
 </para>
 
 <para>The Advanced Search dialog is used to create <link linkend="juk-search-playlists">Search
 Playlists</link>.  It allows you to make a fine-grained search among the different tags of
 your song collection.</para>
 
 <para>At the top of the dialog, you can type in the name of your search playlist.  Then, you
 can define your search criteria in the <guilabel>Search Criteria</guilabel> group.
 </para>
 
 <para>The top of the <guilabel>Search Criteria</guilabel> group has two radio buttons,
 <guilabel>Match any of the following</guilabel> and <guilabel>Match all of the
 following</guilabel>.  If you select <guilabel>Match any of the following</guilabel>, then
 a match by any of the conditions you define will include the song in the playlist.  Otherwise,
 every condition you define must match in order to include the song in the playlist.
 </para>
 
 <para>Below the radio buttons are the condition definitions.  You can add more conditions
 by using the <guibutton>More</guibutton> button, and remove conditions by using the
 <guibutton>Fewer</guibutton> button.  Any conditions you leave blank are ignored, so you do
 not have to use <guibutton>Fewer</guibutton> to eliminate empty conditions.
 </para>
 
 <para>Every condition definition has three parts:  The tag chooser list on the left, the
 matching style list on the right, and the search text in the middle.  The tag chooser
 lets &juk; know what tag you want to search for the text in.  If you choose the special
 tag "&lt;All Visible&gt;", then any tag that you can see in the Collection List listing
 is fair game to match the search text.
 </para>
 
 <para>The match style list lets &juk; know which search method to use.
 The search methods you can use are as follows:
 <variablelist>
 <varlistentry>
 <term>Normal Matching</term>
 <listitem><para>This is the default matching style.  It searches for the given
 text anywhere in the chosen tag, ignoring case differences.  For example a
 search for mode in the Artist tag would match Depeche Mode.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term>Case Sensitive</term>
 <listitem><para>This search is just like Normal Matching, except that
 the search must match the exact case of the text.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term>Pattern Matching</term>
 <listitem><para>This is the most powerful search method.  The search
 text you type in will define a regular expression used to search within
 the tag.  Regular expressions are beyond the scope of this documentation, but
 the application &kregexpeditor; can help you form a regular expression.
 &juk; uses the &Qt; regular expression style.</para></listitem>
 </varlistentry>
 
 </variablelist>
 
 </para>
 
 <para>Simply choose the conditions you want to include in your search, and
 click <guibutton>OK</guibutton> to create your search playlist!
 </para>
 </sect1>
 <!-- is this still relevant?
 
 write new for kde4
 
 <sect1 id="juk-cover-manager">
 
 <title>The &juk; Cover Manager</title>
 
 <para>&juk; 2.3 (part of &kde; 3.5) includes improved cover management code which introduces some new possibilities for users compared with &juk; 2.2 (which was shipped with &kde; 3.4).  It also can change the workflow slightly for you if you are used to the way covers were handled in &juk; 2.2.  So first, let's review how things used to be.</para>
 
 <sect2 id="covers-in-juk-2.2">
 <title>How Covers Worked in &juk; 2.2</title>
 
 <para>In &juk; 2.2, the cover for a track was strictly tied to its <guilabel>Artist</guilabel> and <guilabel>Album</guilabel> information. Although this proved useful enough, and had a few advantages, it wasn't a great way to organize the covers. If you wanted to use a cover for a different track, you either had to rename the tags in the track, or you had to duplicate the cover, wasting hard disk space. And if your track had no <guilabel>Artist</guilabel> or <guilabel>Album</guilabel> information, &juk; would prevent you from setting a cover since it had no information to go by. It worked, but it could be better.</para>
 
 </sect2>
 
 <sect2 id="covers-in-juk-2.3">
 
 <title>How Covers work in &juk; 2.3</title>
 
 <para>In &juk; 2.3, the code was redesigned to add a core component responsible for dealing with cover art.  Instead of looking on disk for a picture file with a specific name like &juk; 2.2, the Cover Manager in &juk; 2.3 associates every cover with an identification tag, and then uses the tag with your music.  It's still not perfect, but it works, and it can save you time while allowing you to do more.</para>
 
 <sect3 id="examples-adding-covers">
 
 <title>Examples of adding covers</title>
 
 <para>So just as an example, let's say you wanted to set a cover for tracks you just ripped off of your &CD;. We'll use <quote>Alabama - Greatest Hits III</quote> for the sake of discussion. In &juk; 2.2, you could simply select any one of those tracks, and import a cover from the Internet by right-clicking on that track, and using the <menuchoice><guimenu>Tagger</guimenu> <guisubmenu>Cover Manager</guisubmenu> <guimenuitem>Get Cover From Internet</guimenuitem></menuchoice> command. As a side effect of the way &juk; worked, the cover would then be immediately applied to <emphasis>all</emphasis> of the <quote>Alabama - Greatest Hits III</quote> tracks, <emphasis>whether you wanted that or not</emphasis>.</para>
 
 <para>In &juk; 2.3, the procedure is exactly the same, with one exception: You should select all of the tracks you want to apply the cover to first. So you would select all the <quote>Alabama - Greatest Hits III</quote> tracks before using the <menuchoice><guimenuitem>Get Cover From Internet</guimenuitem></menuchoice> command. Or if you only wanted to set cover art to half of the tracks for some reason, you'd only select half the tracks before running the <menuchoice><guimenuitem>Get Cover From Internet</guimenuitem></menuchoice> command. Don't worry about duplicating covers, either: &juk; is smart enough to re-use the same image, so you won't get 14 duplicate <literal role="extension">.png</literal> images cluttering your hard drive.</para>
 </sect3>
 
 <sect3 id="reusing-old-covers">
 
 <title>Reusing Old Covers</title>
 
 <para>But what happens if you forgot to select all the tracks you wanted to tag? You could select them and repeat the process, but that would leave a duplicate cover on your hard drive because &juk; cannot quickly tell that the cover you've found is the same as one you already have. But that's alright, because you can tell &juk; to use the cover from another track.</para>
 
 <para>There are two ways of doing this:</para>
 
 <para>1. Open the <guilabel>Cover Manager</guilabel> dialog using the <guimenu>Tagger</guimenu> menu (<menuchoice><guimenu>Tagger Cover</guimenu> <guisubmenu>Manager</guisubmenu> <guimenuitem>Show Cover Manager</guimenuitem></menuchoice>). The Cover Manager will display a list of all the covers &juk; knows about on the right, and after they have loaded you can quickly pare the list down using the search line at the top, or by using the list of Artists on the left. Once you see the cover you want to use, you can drag-and-drop the cover onto a track to apply it. It should happen nearly instantaneously since &juk; is reusing the same cover (and you'll see the cover while you're dragging it as well). Unfortunately, it can take awhile to load the covers in the first place, and the Cover Manager isn't really useful for much else besides.</para>
 
 <para>2. I prefer to use this method because it's rather easy. All you do is double-click on the track that has the cover you want, in order to start it playing. This will cause its cover to show up in the <interface>Now Playing bar</interface>, and you can drag-and-drop the cover to the track you want to change exactly as you would for the Cover Manager.</para>
 
 </sect3>
 
 <sect3 id="dragging-covers">
 
 <title>Dragging covers to more than one track at once</title>
 
 <para>Also note that you can use drag-and-drop to quickly apply covers to more than one track. Just select the tracks you want to apply a cover to, and drag the cover onto any one of the selected tracks.</para>
 </sect3>
 
 <sect3 id="old-covers">
 
 <title>What happens to my old covers?</title>
 
 <para>You may be wondering what &juk; will do if you already have covers from &juk; 2.2.  What happens is that &juk; will automatically convert the old covers and merge them into the cover management system.</para>
 
 <para>Because this is a time consuming process, it does not happen all at once.  Instead, the old cover is only converted when the cover needs to be shown on screen.  As the conversion process is happening, &juk; will recognize what tracks would have shown the cover being converted, and will automatically apply the new cover to those tracks.  The end result is that there should be no visible changes: &juk; will keep the same cover on your tracks that they've always had, except that now you can immediately take advantage of the new cover management features.</para>
 
 </sect3>
 <sect3 id="removing-covers">
 
 <title>Removing Covers</title>
 
 <para>Another side effect is that you can now remove a cover from a track without simultaneously removing it from all other tracks with the same <guilabel>Artist</guilabel> and <guilabel>Album</guilabel>.</para>
 
 <para>In &juk; 2.3, the Remove Cover command now only removes the covers from the selected tracks.
 </para>
 
 </sect3>
 <sect3 id="suggested-use">
 
 <title>Suggested Uses:</title>
 
 <para>1. You can now apply the same cover to tracks with Albums that have <quote>Disc 1</quote>, <quote>Disc 2</quote>, etc, which you couldn't do in &juk; 2.2 without duplicating the cover.</para>
 
 <para>
 2. Applying a generic cover to tracks if you simply must have a cover on every track, or if you have music that wasn't released as an album but fits a genre well.  You could make yourself a cover for that type of music and apply it to the songs in question.</para>
 
 </sect3>
 </sect2>
 </sect1>
 -->
 </chapter>
 
 <chapter id="toolbar-reference">
 <title>The &juk; Toolbar</title>
 
 <sect1 id="main-toolbar">
 <title>The Main Toolbar</title>
 
 <screenshot>
 <screeninfo>The &juk; toolbar.</screeninfo>
 <mediaobject>
 <imageobject>
 <imagedata format="PNG" fileref="toolbar.png" />
 </imageobject>
 <textobject>
 <phrase>The &juk; toolbar.</phrase>
 </textobject>
 <caption><para>The &juk; toolbar.</para></caption>
 </mediaobject>
 </screenshot>
 
 <para>From left to right in the screenshot above, the icons on the
 default toolbar are:</para>
 
 <variablelist>
 <varlistentry>
 <term><guiicon>New</guiicon></term>
 <listitem><para>Create a new playlist.  If you hold down the button, a
 menu will pop up allowing you to select the different kinds of playlists
 to create.
 </para>
   <variablelist>
   <varlistentry><term><guimenuitem>Empty Playlist...</guimenuitem></term>
   <listitem><para>This prompts you for a playlist name, and then inserts it into the
     Playlist view.  The playlist starts out completely empty.</para></listitem>
   </varlistentry>
 
   <varlistentry><term><guimenuitem>Playlist From Folder...</guimenuitem></term>
   <listitem><para>This prompts you for a folder to open, and then creates a playlist
     containing the music within the folder and any sub-folders.  The name of the created
     playlist is the same as the name of the selected folder.</para></listitem>
   </varlistentry>
 
   <varlistentry><term><guimenuitem>Search Playlist...</guimenuitem></term>
   <listitem><para>This brings up the Advanced Search Dialog, allowing you to create a
   <quote>virtual playlist</quote>.  Any songs in your Collection List that match the search
   criteria that you specify in the Advanced Search Dialog will be added to the new playlist.
   As your Collection List changes, the new playlist will as well.  For example, if you create a playlist
   of all of your Depeche Mode songs, and then add another Depeche Mode song to your Collection List,
   it will show up in the Depeche Mode playlist with no special action required on your part.
   </para></listitem>
   </varlistentry>
 
   </variablelist>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guiicon>Open</guiicon></term>
 <listitem><para>Add a file to the collection list (if it's active) or
 to the currently selected playlist.  Adding a file to a playlist will
 add it to the collection list automatically, but not vice
 versa.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guiicon>Save</guiicon></term>
 <listitem><para>Save the currently selected playlist.  To save a tag
 you have edited, either select another item, or press <keycombo
 action="simul">&Ctrl;<keycap>T</keycap></keycombo>
 instead.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guiicon>Cut</guiicon></term>
 <listitem><para>If a playlist or song is selected, cut (remove) it from the
 list.  If the tag editor is active, this works like cut in any editor,
 removing the selected text, but keeping a copy on the
 clipboard.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guiicon>Copy</guiicon></term>
 <listitem><para>If the tag editor is active, this works like copy in
 any editor, placing a copy of the selected text on the
 clipboard.</para>
 <para>If you use copy on a song in the collection list, the url is
 placed on the clipboard, so you can paste it.  For example, you could
 paste the url into a text editor, &konqueror;, or another
 playlist.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guiicon>Paste</guiicon></term>
 <listitem><para>If you previously either cut or copied a url from the
 collection list, you can paste the url back into a new playlist.  You
 could also paste a url you have copied from &konqueror; or any other
 application. If you are operating in the tag editor, paste will paste
 any text currently on the clipboard into the selected
 field.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guiicon>Show Search Bar</guiicon></term>
 <listitem><para>Show or hide <link linkend="search-bar">the search
 bar</link>.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term><guiicon>Show Tag Editor</guiicon></term>
 <listitem><para>Show or hide <link linkend="tagging-a-single-file">the
 tag editor</link>.</para></listitem>
 </varlistentry>
 
 <varlistentry id="play-toolbar">
 <term>Play controls</term>
 <listitem>
 <para>These work like any standard media player you may have come
 across.  The controls are <guiicon>Play</guiicon>,
 <guiicon>Pause</guiicon>, <guiicon>Stop</guiicon>, <guiicon>Previous
 </guiicon> and <guiicon>Next</guiicon>.</para>
 <para>There is also a tracking bar, showing how far along (relatively)
 in the current song you are.  You can drag this slider with the mouse
 in order to skip forwards or backwards within a track.</para>
 <para>Finally there is a volume slider.  As you may expect, this
 raises and lowers the volume.  <quote>Loud</quote> is on the right,
 and <quote>Quiet</quote> is on the left.</para></listitem>
 </varlistentry>
 </variablelist>
 
 </sect1>
 
 <sect1 id="search-bar">
 <title>The Search bar</title>
 
 <para>The search bar allows you to quickly search for a song in the
 collection list or a playlist.</para>
 
 <para>Simply typing text into the search bar will reduce the visible
 list of songs to those which contain that text in any visible
 column.  Pressing &Enter; will start playing the top match in the playlist view.</para>
 
 <para>Searching begins instantly when text is entered into the search
 field.  Searching is incremental, that is, as you type each character
 into the text field, the search is narrowed further.  This is useful
 to find a song where you only remember part of a name, for
 instance.</para>
 
 <!-- Not here in KDE 4.11
 <para>If you would like to make a more fine-grained search, you can click
 the Advanced Search button to the right of the search bar, which will allow
 you to create a virtual playlist.  If you would like to cancel the search,
 you can simply click on the Clear button to the left of the search bar.</para>
 -->
 
 </sect1>
 
 </chapter>
 
 <chapter id="menu-and-command-reference">
 <title>Menu and Command Reference</title>
 
 <sect1 id="menus">
 <title>Menus</title>
 
 <sect2 id="menu-file">
 <title>File Menu</title>
 
 <variablelist>
 <varlistentry>
 <term><menuchoice>
 <shortcut><keycombo action="simul">&Ctrl;<keycap>N</keycap></keycombo>
 </shortcut>
 <guimenu>File</guimenu><guisubmenu>New</guisubmenu><guimenuitem>Empty Playlist...</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Create a new playlist</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <shortcut><keycombo action="simul">&Ctrl;<keycap>F</keycap></keycombo>
 </shortcut>
 <guimenu>File</guimenu><guisubmenu>New</guisubmenu><guimenuitem>Search Playlist...</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Creates a new <link linkend="juk-search-playlists">search playlist</link>.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <shortcut><keycombo action="simul">&Ctrl;<keycap>D</keycap></keycombo>
 </shortcut>
 <guimenu>File</guimenu><guisubmenu>New</guisubmenu><guimenuitem>Playlist From
 Folder...</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Creates a new playlist, containing all music files
 in a folder and any sub-folders.  Any music within playlists files that
 &juk; recognizes will also be added.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <shortcut>
 <keycombo action="simul">&Ctrl;<keycap>O</keycap></keycombo>
 </shortcut>
 <guimenu>File</guimenu>
 <guimenuitem>Open...</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Select a file (or files) to add to the collection list.  If you select
 a playlist file, every file in the playlist will be added.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>File</guimenu><guimenuitem>Manage Folders...</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This menu item opens the same window that is shown on a first &juk; start
 </para>
 <para>Select a folder (or folders) to add to the
 collection list.  These folders will also be rescanned whenever
 &juk; is started or
 <menuchoice><guimenu>File</guimenu><guimenuitem>Reload</guimenuitem>
 </menuchoice> is chosen.</para>
 <para>You can also select folders that
 should not be automatically searched (which would override
 the list of folders to scan on startup). This way you can avoid having
 to completely change up your music layout on-disk just to keep &juk; from
 automatically grabbing songs you do not want or need managed from within
 &juk;.
 </para>
 <para>
 <screenshot>
 <screeninfo>The Manage Folders dialog</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="juk-manage-folders.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
 	    <phrase>Screenshot of the Manage Folders Dialog.</phrase>
 	  </textobject>
 	</mediaobject>
 </screenshot>
 </para>
 <note>
 <para>
 If you want to remove files that are already in the collection
 list, you can enable the <guilabel>File Name (full path)</guilabel> column in a playlist
 and then use the search bar to find the offending path name, select and remove
 the files that are shown.
 </para>
 </note>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>File</guimenu>
 <guimenuitem>Rename...</guimenuitem></menuchoice>
 </term>
 <listitem><para>Rename a playlist.</para>
 </listitem>
 </varlistentry>
 
 <!-- Edit Search... -->
 <varlistentry>
 <term><menuchoice>
 <guimenu>File</guimenu><guimenuitem>Duplicate...</guimenuitem></menuchoice>
 </term>
 <listitem><para>Create a duplicate of the selected playlist, and
 prompt for a new name.
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>File</guimenu><guimenuitem>Reload</guimenuitem></menuchoice>
 </term>
 <listitem><para>Reloads the tag information on every file in the selected
 playlist.
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice><guimenu>File</guimenu><guimenuitem>Remove</guimenuitem></menuchoice></term>
 <listitem><para>Remove the selected playlist.</para></listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <shortcut><keycombo action="simul">&Ctrl;<keycap>S</keycap></keycombo>
 </shortcut>
 <guimenu>File</guimenu><guimenuitem>Save</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Save the selected playlist.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>File</guimenu><guimenuitem>Save As...</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Save the selected playlist, with a different name.</para>
 </listitem>
 </varlistentry>
 
 </variablelist>
 </sect2>
 
 <sect2 id="menu-edit">
 <title>Edit Menu</title>
 
 <variablelist>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Edit</guimenu><guimenuitem>Clear</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Removes the selected songs from the playlist.</para>
 </listitem>
 </varlistentry>
 <!-- Undo Cut Copy Paste Clear Select All -->
 </variablelist>
 </sect2>
 
 <sect2 id="menu-view">
 <title>View Menu</title>
 
 <variablelist>
 <varlistentry>
 <term><menuchoice>
 <guimenu>View</guimenu><guimenuitem>Show Search Bar</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This is a toggle action that sets whether or not the
 <link linkend="search-bar">Search Bar</link> is shown.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>View</guimenu><guimenuitem>Show Tag Editor</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This is a toggle action that sets whether or not the
 <interface>Tag Editor</interface> is shown.</para>
 </listitem>
 </varlistentry>
 <!--Show Lyrics-->
 <varlistentry>
 <term><menuchoice>
 <guimenu>View</guimenu><guimenuitem>Show History</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This is a toggle action that sets whether or not the
 <link linkend="juk-history-playlists">History Playlist</link> is shown.</para>
 </listitem>
 </varlistentry>
 
 <!-- missing
 Show Play Queue
 Show Columns
 Resize Playlist Columns Manually
 -->
 <varlistentry>
 <term><menuchoice>
 <guimenu>View</guimenu><guisubmenu>View Modes</guisubmenu><guimenuitem>Default</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Switches to <link linkend="juk-viewmode-default">Default View mode</link>.
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>View</guimenu><guisubmenu>View Modes</guisubmenu><guimenuitem>Compact</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Switches to <link linkend="juk-viewmode-compact">Compact View mode</link>.
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>View</guimenu><guisubmenu>View Modes</guisubmenu><guimenuitem>Tree</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>Switches to <link linkend="juk-viewmode-tree">Tree View mode</link>.
 </para>
 </listitem>
 </varlistentry>
 
 </variablelist>
 </sect2>
 
 <sect2 id="menu-player">
 <title>Player Menu</title>
 
 <variablelist>
 <varlistentry>
 <term><menuchoice>
 <guimenu>Player</guimenu><guimenuitem>Random Play</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This is a toggle option which controls the Random Play setting.
 If Random Play is enabled, then &juk; will randomly select a random song from the
 current playlist when the currently playing song is over.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Player</guimenu><guimenuitem>Loop Playlist</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This is a toggle option which controls the Loop Playlist setting.
 If Loop Playlist is enabled, then &juk; will start playing from the beginning when
 it has finished playing every song in the current playlist.</para>
 </listitem>
 </varlistentry>
 <!--
 Crossfade Between Tracks
 -->
 <varlistentry>
 <term><menuchoice>
 <guimenu>Player</guimenu><guimenuitem>Play</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command starts playing the currently selected song, or resumes
 playback of the song if it was paused.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Player</guimenu><guimenuitem>Pause</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command pauses the currently playing song.  Use the
 Play command to restart playback.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Player</guimenu><guimenuitem>Stop</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command stops the playback of the currently playing song.
 You cannot resume playback from its current position after that.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Player</guimenu><guimenuitem>Next</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command skips to the next song to play in the
 playlist.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Player</guimenu><guimenuitem>Previous</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command plays the song that was playing before
 the currently playing song.</para>
 </listitem>
 </varlistentry>
 <!--
 Play Next Album
 -->
 </variablelist>
 </sect2>
 
 <sect2 id="menu-tagger">
 <title>Tagger Menu</title>
 
 <variablelist>
 
 <varlistentry>
 <term><menuchoice>
 <shortcut><keycombo action="simul">&Ctrl;<keycap>T</keycap></keycombo></shortcut>
 <guimenu>Tagger</guimenu><guimenuitem>Save</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command saves any changes to the tags that you are
 editing.  Normally, changes are not saved until you deselect the file you
 are editing.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Tagger</guimenu><guimenuitem>Delete</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command deletes the currently selected files from
 the Collection List and any playlists containing it, and then deletes
 the selected file from the disk.
 <!-- God this is a dumb place to put this particular command --></para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Tagger</guimenu><guimenuitem>Refresh</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command allows you to refresh playlist tags after
 changing them.
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <shortcut><keycombo action="simul">&Ctrl;<keycap>G</keycap></keycombo></shortcut>
 <guimenu>Tagger</guimenu><guisubmenu>Guess Tag
 Information</guisubmenu><guimenuitem>From Filename</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command tries to guess the tags of the selected files
 by scanning the filename.  You can configure the patterns used for guessing
 by selecting <menuchoice><guimenu>Settings</guimenu>
 <guimenuitem>Tag Guesser...</guimenuitem></menuchoice>, which opens the
 <link linkend="juk-tag-guesser-configuration">Tag Guesser Configuration dialog</link>.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <shortcut><keycombo action="simul">&Ctrl;<keycap>I</keycap></keycombo></shortcut>
 <guimenu>Tagger</guimenu><guisubmenu>Guess Tag
 Information</guisubmenu><guimenuitem>From Internet</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command tries to guess the tags of the selected files
 by using the <application>TunePimp</application> library provided with
 <ulink url="http://www.musicbrainz.org/">MusicBrainz</ulink>.</para>
 </listitem>
 </varlistentry>
 <!--missing
 Cover Manager
   -->
 <varlistentry>
 <term><menuchoice>
 <shortcut><keycombo action="simul">&Ctrl;<keycap>R</keycap></keycombo></shortcut>
 <guimenu>Tagger</guimenu><guimenuitem>Rename File</guimenuitem>
 </menuchoice>
 </term>
 <listitem>
   <para>
     This command allows you to rename a file or a group of files for the selected songs in the playlist.
     Before the real rename happens &juk; will show a preview dialog where you can confirm or cancel the action.
   </para>
   <para>
     The files will be renamed according to the parameters defined using <link linkend="juk-rename-dialog">Rename File dialog</link>.
   </para> 
 </listitem>
 </varlistentry>
 </variablelist>
 
 </sect2>
 
 <sect2 id="menu-settings">
 <title>Settings Menu</title>
 
 <variablelist>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Settings</guimenu><guisubmenu>Toolbars Shown</guisubmenu>
 <guimenuitem>Main / Play Toolbar</guimenuitem> 
 </menuchoice>
 </term>
 <listitem><para>These commands show or hide the <link linkend="main-toolbar">Main
 Toolbar</link> and the <link linkend="play-toolbar">Play Toolbar</link>.</para>
 </listitem>
 </varlistentry>
 
-<varlistentry>
-<term><menuchoice>
-<guimenu>Settings</guimenu>
-<guimenuitem>Show Splash Screen on Startup</guimenuitem>
-</menuchoice>
-</term>
-<listitem><para>This is a toggle option.  If enabled, &juk; will display
-an informational screen upon startup as it loads your music collection.</para>
-</listitem>
-</varlistentry>
-
 <varlistentry>
 <term><menuchoice>
 <guimenu>Settings</guimenu>
 <guimenuitem>Dock in System Tray</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This is a toggle option.  If enabled, &juk; will display an
 icon in your system tray.  You can use the system
 tray icon to tell if &juk; is playing, and control playback.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Settings</guimenu>
 <guimenuitem>Stay in System Tray on Close</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This is a toggle option.  If enabled, &juk; will remain
   running if you close the main window.  The <guimenuitem>Dock in System Tray</guimenuitem> option must
 also be enabled.  To quit &juk;, use the <menuchoice><guimenu>File</guimenu>
 <guimenuitem>Quit</guimenuitem></menuchoice> command from the main window, or
 the <guimenuitem>Quit</guimenuitem> command from the system tray's context
 menu.</para>
 <para>
 If &juk; is started up when it is set to dock in the system tray on startup
 a simple notification will be shown (as otherwise the user may wonder why &juk;
 window did not open up). It is possible to remove this additional
 notification by going to <menuchoice><guimenu>Common Appearance and Behavior</guimenu>
 <guimenuitem>Application and System Notifications</guimenuitem></menuchoice> in
 &systemsettings; to manage <guilabel>JuK music player</guilabel> application notifications.
 Just uncheck <guilabel>Show a message in a popup</guilabel> item for <guimenuitem>JuK running
 in dock mode</guimenuitem>. More information on &kde; notification settings can be found
 <ulink url="help:/kcontrol/kcmnotify">here</ulink>.
 </para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Settings</guimenu>
 <guimenuitem>Popup Track Announcement</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This is a toggle option.  If enabled, &juk; will display
 an indicator whenever a song starts playing, with information on the artist and
 title, and with buttons allowing you to quickly switch to a different song.  The
 Dock in System Tray option must also be enabled.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Settings</guimenu>
 <guimenuitem>Tag Guesser...</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command brings up the <link linkend="juk-tag-guesser-configuration">Tag Guesser Configuration
 dialog box</link>, where you can alter the patterns used to guess tag information
 from filenames.</para>
 </listitem>
 </varlistentry>
 
 <varlistentry>
 <term><menuchoice>
 <guimenu>Settings</guimenu>
 <guimenuitem>File Renamer...</guimenuitem>
 </menuchoice>
 </term>
 <listitem><para>This command brings up the <link linkend="juk-rename-dialog">File Renamer Configuration
 dialog box</link>, where you can alter the way &juk; renames files for you.</para>
 </listitem>
 </varlistentry>
 <!--missing
 Configure scrobbling
   -->
 </variablelist>
 
 <para>
 Additionally &juk; has the common &kde; <guimenu>Settings</guimenu> and <guimenu>Help</guimenu>
 menu items, for more information read the sections about the
 <ulink url="help:/fundamentals/ui.html#menus-settings">Settings Menu</ulink> and
 <ulink url="help:/fundamentals/ui.html#menus-help">Help Menu</ulink> of the &kde; Fundamentals.
 </para>
 
 </sect2>
 
 </sect1>
 
 <sect1 id="keybindings">
 <title>Keybinding Reference</title>
 
 <!--
 ctrl-a select all
 ctrl-c copy
 ctrl-r rename file
 ctrl-i guess tag entries from internet
 ctrl-f guess tag entries based on filename
 ctrl-f new search playlist
 ctrl-n new empty playlist
 ctrl-d new playlist from folder
 ctrl-o open file (add to the collection or a playlist)
 ctrl-q quit
 ctrl-s save
 ctrl-t save edited tag information
 ctrl-v paste
 ctrl-x cut
 f1 Show manual
 shift-f1 what's this help
 
 -->
 <informaltable>
 <tgroup cols="2">
 <thead>
 <row>
 <entry>Key Combination</entry>
 <entry>Action</entry>
 </row>
 </thead>
 <tbody>
 <row>
 <entry><keycombo
 action="simul">&Ctrl;<keycap>A</keycap></keycombo></entry>
 <entry>Select all</entry>
 </row>
 <row>
 <entry><keycombo action="simul">&Ctrl;<keycap>C</keycap></keycombo></entry>
 <entry>Copy</entry>
 </row>
 <row>
 <entry><keycombo
 action="simul">&Ctrl;<keycap>R</keycap></keycombo></entry>
 <entry>Rename file</entry>
 </row>
 <row>
 <entry><keycombo
 action="simul">&Ctrl;<keycap>I</keycap></keycombo></entry>
 <entry>Guess tags from the Internet.</entry>
 </row>
 <row>
 <entry><keycombo
 action="simul">&Ctrl;<keycap>G</keycap></keycombo></entry>
 <entry>Guess tags from the filename.</entry>
 </row>
 <row>
 <entry><keycombo
 action="simul">&Ctrl;<keycap>F</keycap></keycombo></entry>
 <entry>New <link linkend="juk-search-playlists">search playlist</link>.</entry>
 </row>
 <row>
 <entry><keycombo
 action="simul">&Ctrl;<keycap>N</keycap></keycombo></entry>
 <entry>New empty Playlist</entry>
 </row>
 <row>
 <entry><keycombo
 action="simul">&Ctrl;<keycap>D</keycap></keycombo></entry>
 <entry>New playlist from folder.</entry>
 </row>
 <row>
 <entry><keycombo
 action="simul">&Ctrl;<keycap>T</keycap></keycombo></entry>
 <entry>Save changes to edited tags.</entry>
 </row>
 </tbody>
 </tgroup>
 </informaltable>
 
 </sect1>
 </chapter>
 
 <chapter id="credits-and-license">
 <title>Credits and License</title>
 
 <para>&juk; Copyright &copy; 2002-2013 &Scott.Wheeler;, Michael Pyne, and others.
 </para>
 
  <para>&juk; is developed and maintained by &Scott.Wheeler;
 &Scott.Wheeler.mail; and Michael Pyne <email>michael.pyne@kdemail.net</email>.</para>
 
 <para>Many thanks to the following people who have contributed to &juk;:</para>
 
 <itemizedlist>
 <listitem><para>&Daniel.Molkentin; &Daniel.Molkentin.mail; for system tray docking, <quote>inline</quote> tag
 editing, bug fixes, evangelism, moral support.</para>
 </listitem>
 <listitem><para>Tim Jansen <email>tim@tjansen.de</email> for
 the <application>GStreamer</application> port</para>
 </listitem>
 
 <listitem><para>Stefan Asserh&auml;ll <email>stefan.asserhall@telia.com</email>
 for global shortcut support.</para>
 </listitem>
 
 <listitem><para>Stephen Douglas <email>stephen_douglas@yahoo.com</email>
 for track announcement popups.</para>
 </listitem>
 
 <listitem><para>&Frerich.Raabe; &Frerich.Raabe.mail;
 for automagical track data guessing, and bugfixes.</para>
 </listitem>
 
 <listitem><para>Zack Rusin <email>zack@kde.org</email>
 for more automagical things, including MusicBrainz support.</para>
 </listitem>
 
 <listitem><para>Adam Treat <email>manyoso@yahoo.com</email>
 for co-conspiring in MusicBrainz wizardry.</para>
 </listitem>
 
 <listitem><para>Matthias Kretz <email>kretz@kde.org</email>
 for being the friendly neighborhood &arts; guru.</para>
 </listitem>
 
 <listitem><para>Maks Orlovich <email>maksim@kde.org</email>
 for making &juk; friendlier to people with terabytes of music.</para>
 </listitem>
 
 <listitem><para>Antonio Larrosa Jimenez <email>larrosa@kde.org</email>
 for the &DCOP; interface.</para>
 </listitem>
 
 <listitem><para>Allan Sandfield Jensen <email>kde@carewolf.com</email>
 for the <acronym>FLAC</acronym> and <acronym>MPC</acronym> support.</para>
 </listitem>
 
 <listitem><para>Nathan Toone <email>nathan@toonetown.com</email>
 for the Album cover manager.</para>
 </listitem>
 
 <listitem><para>Pascal Klein <email>4pascal@tpg.com.au</email>
 for the splash screen.</para>
 </listitem>
 
 <listitem><para>Laurent Montel <email>montel@kde.org</email>
 for the porting to &kde; 4 when no one else around.</para>
 </listitem>
 
 <listitem><para>Georg Grabler <email>georg@grabler.net</email>
 for the &kde; Platform porting efforts.</para>
 </listitem>
 
 <listitem><para>Martin Sandsmark <email>martin.sandsmark@kde.org</email>
 for the Last.fm scrobbling support, lyrics, prepping for &kde; Frameworks.</para>
 </listitem>
 
 <listitem><para>Eike Hein <email>hein@kde.org</email>
 for the MPRIS2 interface implementation.</para>
 </listitem>
 
 </itemizedlist>
 
 <para>Documentation Copyright &copy; 2003, &Lauri.Watts;, and copyright
 &copy; 2004-2013 Michael Pyne.</para>
 
 <!-- TRANS:CREDIT_FOR_TRANSLATORS -->
 
 &underFDL;
 &underGPL;
 
 </chapter>
 
 &documentation.index;
 
 </book>
 <!--
 Local Variables:
 mode: sgml
 sgml-minimize-attributes:nil
 sgml-general-insert-case:lower
 sgml-indent-step:0
 sgml-indent-data:nil
 End:
 -->
diff --git a/juk.cpp b/juk.cpp
index 1dd6db65..d34bf968 100644
--- a/juk.cpp
+++ b/juk.cpp
@@ -1,629 +1,614 @@
 /**
  * Copyright (C) 2002-2004 Scott Wheeler <wheeler@kde.org>
  * Copyright (C) 2008, 2009 Michael Pyne <mpyne@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.
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  * PARTICULAR PURPOSE. See the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "juk.h"
 
 #include <kstatusbar.h>
 #include <kmessagebox.h>
 #include <kstandarddirs.h>
 #include <kactioncollection.h>
 #include <kstandardaction.h>
 #include <ktoggleaction.h>
 #include <kactionmenu.h>
 #include <QIcon>
 #include <QAction>
 #include <kconfiggroup.h>
 #include <kglobal.h>
 #include <kglobalaccel.h>
 #include <ktoolbarpopupaction.h>
 #include <knotification.h>
 #include <kdeversion.h>
 
 #include <QCoreApplication>
 #include <QKeyEvent>
 #include <QDir>
 #include <QTime>
 #include <QTimer>
 #include <QDesktopWidget>
 
 #include "slideraction.h"
 #include "statuslabel.h"
-#include "splashscreen.h"
 #include "systemtray.h"
 #include "keydialog.h"
 #include "tagguesserconfigdlg.h"
 #include "filerenamerconfigdlg.h"
 #include "scrobbler.h"
 #include "scrobbleconfigdlg.h"
 #include "actioncollection.h"
 #include "cache.h"
 #include "playlistsplitter.h"
 #include "collectionlist.h"
 #include "covermanager.h"
 #include "tagtransactionmanager.h"
 #include "juk_debug.h"
 
 using namespace ActionCollection;
 
 JuK* JuK::m_instance;
 
 template<class T>
 void deleteAndClear(T *&ptr)
 {
     delete ptr;
     ptr = 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
 JuK::JuK(const QStringList &filesToOpen, QWidget *parent) :
     KXmlGuiWindow(parent, Qt::WindowFlags(Qt::WA_DeleteOnClose)),
     m_splitter(0),
     m_statusLabel(0),
     m_systemTray(0),
     m_player(new PlayerManager),
     m_scrobbler(0),
-    m_shuttingDown(false),
-    m_filesToOpen(filesToOpen)
+    m_filesToOpen(filesToOpen),
+    m_shuttingDown(false)
 {
     // Expect segfaults if you change this order.
 
     m_instance = this;
 
     readSettings();
 
     Cache::ensureAppDataStorageExists();
 
-    if(m_showSplash && !m_startDocked && Cache::cacheFileExists()) {
-        if(SplashScreen* splash = SplashScreen::instance()) {
-            splash->show();
-            qApp->processEvents();
-        }
-    }
-
     setupActions();
     setupLayout();
 
     bool firstRun = !KSharedConfig::openConfig()->hasGroup("MainWindow");
 
     if(firstRun) {
         KConfigGroup mainWindowConfig(KSharedConfig::openConfig(), "MainWindow");
         KConfigGroup playToolBarConfig(&mainWindowConfig, "Toolbar playToolBar");
         playToolBarConfig.writeEntry("ToolButtonStyle", "IconOnly");
     }
 
     QSize defaultSize(800, 480);
 
     if(QApplication::isRightToLeft())
         setupGUI(defaultSize, ToolBar | Save | Create, "jukui-rtl.rc");
     else
         setupGUI(defaultSize, ToolBar | Save | Create);
 
     // Center the GUI if this is our first run ever.
 
     if(firstRun) {
         QRect r = rect();
         r.moveCenter(QApplication::desktop()->screenGeometry().center());
         move(r.topLeft());
     }
 
     connect(m_splitter, SIGNAL(guiReady()), SLOT(slotSetupSystemTray()));
     readConfig();
     setupGlobalAccels();
     activateScrobblerIfEnabled();
 
     connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), SLOT(slotAboutToQuit()));
 
     // slotCheckCache loads the cached entries first to populate the collection list
 
     QTimer::singleShot(0, this, SLOT(slotClearOldCovers()));
     QTimer::singleShot(0, CollectionList::instance(), SLOT(startLoadingCachedItems()));
     QTimer::singleShot(0, this, SLOT(slotProcessArgs()));
 }
 
 JuK::~JuK()
 {
 }
 
 JuK* JuK::JuKInstance()
 {
     return m_instance;
 }
 
 PlayerManager *JuK::playerManager() const
 {
     return m_player;
 }
 
 void JuK::coverDownloaded(const QPixmap &cover)
 {
     QString event(cover.isNull() ? "coverFailed" : "coverDownloaded");
     KNotification *notification = new KNotification(event, this);
     notification->setPixmap(cover);
     notification->setFlags(KNotification::CloseOnTimeout);
 
     if(cover.isNull())
         notification->setText(i18n("Your album art failed to download."));
     else
         notification->setText(i18n("Your album art has finished downloading."));
 
     notification->sendEvent();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
 void JuK::setupLayout()
 {
     new TagTransactionManager(this);
 
     qCDebug(JUK_LOG) << "Creating GUI";
     QTime stopwatch;
     stopwatch.start();
 
     m_splitter = new PlaylistSplitter(m_player, this);
     setCentralWidget(m_splitter);
 
     m_statusLabel = new StatusLabel(m_splitter->playlist(), statusBar());
     connect(CollectionList::instance(), SIGNAL(signalCollectionChanged()),
             m_statusLabel, SLOT(updateData()));
     statusBar()->addWidget(m_statusLabel, 1);
     m_player->setStatusLabel(m_statusLabel);
 
     m_splitter->setFocus();
 
     qCDebug(JUK_LOG) << "GUI created in" << stopwatch.elapsed() << "ms";
 }
 
 void JuK::setupActions()
 {
     KActionCollection *collection = ActionCollection::actions();
 
     // Setup KDE standard actions that JuK uses.
 
     KStandardAction::quit(this, SLOT(slotQuit()), collection);
     KStandardAction::undo(this, SLOT(slotUndo()), collection);
     KStandardAction::cut(collection);
     KStandardAction::copy(collection);
     KStandardAction::paste(collection);
     QAction *clear = KStandardAction::clear(collection);
     KStandardAction::selectAll(collection);
     KStandardAction::keyBindings(this, SLOT(slotEditKeys()), collection);
 
     // Setup the menu which handles the random play options.
     KActionMenu *actionMenu = collection->add<KActionMenu>("actionMenu");
     actionMenu->setText(i18n("&Random Play"));
     actionMenu->setIcon(QIcon::fromTheme( QLatin1String( "media-playlist-shuffle" )));
     actionMenu->setDelayed(false);
 
     QActionGroup* randomPlayGroup = new QActionGroup(this);
 
     QAction *act = collection->add<KToggleAction>("disableRandomPlay");
     act->setText(i18n("&Disable Random Play"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "go-down" )));
     act->setActionGroup(randomPlayGroup);
     actionMenu->addAction(act);
 
     m_randomPlayAction = collection->add<KToggleAction>("randomPlay");
     m_randomPlayAction->setText(i18n("Use &Random Play"));
     m_randomPlayAction->setIcon(QIcon::fromTheme( QLatin1String( "media-playlist-shuffle" )));
     m_randomPlayAction->setActionGroup(randomPlayGroup);
     actionMenu->addAction(m_randomPlayAction);
 
     act = collection->add<KToggleAction>("albumRandomPlay");
     act->setText(i18n("Use &Album Random Play"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "media-playlist-shuffle" )));
     act->setActionGroup(randomPlayGroup);
     connect(act, SIGNAL(triggered(bool)), SLOT(slotCheckAlbumNextAction(bool)));
     actionMenu->addAction(act);
 
     act = collection->addAction("removeFromPlaylist", clear, SLOT(clear()));
     act->setText(i18n("Remove From Playlist"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "list-remove" )));
 
     act = collection->add<KToggleAction>("crossfadeTracks");
     act->setText(i18n("Crossfade Between Tracks"));
     connect(act, SIGNAL(triggered(bool)), m_player, SLOT(setCrossfadeEnabled(bool)));
 
     act = collection->addAction("play", m_player, SLOT(play()));
     act->setText(i18n("&Play"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "media-playback-start" )));
 
     act = collection->addAction("pause", m_player, SLOT(pause()));
     act->setText(i18n("P&ause"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "media-playback-pause" )));
 
     act = collection->addAction("stop", m_player, SLOT(stop()));
     act->setText(i18n("&Stop"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "media-playback-stop" )));
 
     act = new KToolBarPopupAction(QIcon::fromTheme( QLatin1String( "media-skip-backward") ), i18nc("previous track", "Previous" ), collection);
     collection->addAction("back", act);
     connect(act, SIGNAL(triggered(bool)), m_player, SLOT(back()));
 
     act = collection->addAction("forward", m_player, SLOT(forward()));
     act->setText(i18nc("next track", "&Next"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "media-skip-forward" )));
 
     act = collection->addAction("loopPlaylist");
     act->setText(i18n("&Loop Playlist"));
     act->setCheckable(true);
 
     act = collection->add<KToggleAction>("resizeColumnsManually");
     act->setText(i18n("&Resize Playlist Columns Manually"));
 
     // the following are not visible by default
 
     act = collection->addAction("mute", m_player, SLOT(mute()));
     act->setText(i18nc("silence playback", "Mute"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "audio-volume-muted" )));
 
     act = collection->addAction("volumeUp", m_player, SLOT(volumeUp()));
     act->setText(i18n("Volume Up"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "audio-volume-high" )));
 
     act = collection->addAction("volumeDown", m_player, SLOT(volumeDown()));
     act->setText(i18n("Volume Down"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "audio-volume-low" )));
 
     act = collection->addAction("playPause", m_player, SLOT(playPause()));
     act->setText(i18n("Play / Pause"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "media-playback-start" )));
 
     act = collection->addAction("seekForward", m_player, SLOT(seekForward()));
     act->setText(i18n("Seek Forward"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "media-seek-forward" )));
 
     act = collection->addAction("seekBack", m_player, SLOT(seekBack()));
     act->setText(i18n("Seek Back"));
     act->setIcon(QIcon::fromTheme( QLatin1String( "media-seek-backward" )));
 
     act = collection->addAction("showHide", this, SLOT(slotShowHide()));
     act->setText(i18n("Show / Hide"));
 
     //////////////////////////////////////////////////
     // settings menu
     //////////////////////////////////////////////////
 
-    m_toggleSplashAction = collection->add<KToggleAction>("showSplashScreen");
-    m_toggleSplashAction->setText(i18n("Show Splash Screen on Startup"));
-
     m_toggleSystemTrayAction = collection->add<KToggleAction>("toggleSystemTray");
     m_toggleSystemTrayAction->setText(i18n("&Dock in System Tray"));
     connect(m_toggleSystemTrayAction, SIGNAL(triggered(bool)), SLOT(slotToggleSystemTray(bool)));
 
     m_toggleDockOnCloseAction = collection->add<KToggleAction>("dockOnClose");
     m_toggleDockOnCloseAction->setText(i18n("&Stay in System Tray on Close"));
 
     m_togglePopupsAction = collection->add<KToggleAction>("togglePopups");
     m_togglePopupsAction->setText(i18n("Popup &Track Announcement"));
 
     act = collection->add<KToggleAction>("saveUpcomingTracks");
     act->setText(i18n("Save &Play Queue on Exit"));
 
     act = collection->addAction("tagGuesserConfig", this, SLOT(slotConfigureTagGuesser()));
     act->setText(i18n("&Tag Guesser..."));
 
     act = collection->addAction("fileRenamerConfig", this, SLOT(slotConfigureFileRenamer()));
     act->setText(i18n("&File Renamer..."));
 
     act = collection->addAction("scrobblerConfig", this, SLOT(slotConfigureScrobbling()));
     act->setText(i18n("&Configure scrobbling..."));
 
     //////////////////////////////////////////////////
     // just in the toolbar
     //////////////////////////////////////////////////
 
     collection->addAction("trackPositionAction",
                           new TrackPositionAction(i18n("Track Position"), this));
     collection->addAction("volumeAction",
                           new VolumeAction(i18n("Volume"), this));
 
     ActionCollection::actions()->addAssociatedWidget(this);
     foreach (QAction* action, ActionCollection::actions()->actions())
         action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 }
 
 void JuK::slotSetupSystemTray()
 {
     if(m_toggleSystemTrayAction && m_toggleSystemTrayAction->isChecked()) {
         qCDebug(JUK_LOG) << "Setting up systray";
         QTime stopwatch; stopwatch.start();
         m_systemTray = new SystemTray(m_player, this);
         m_systemTray->setObjectName( QLatin1String("systemTray" ));
 
         m_toggleDockOnCloseAction->setEnabled(true);
         m_togglePopupsAction->setEnabled(true);
         qCDebug(JUK_LOG) << "Finished setting up systray, took" << stopwatch.elapsed() << "ms";
     }
     else {
         m_systemTray = 0;
         m_toggleDockOnCloseAction->setEnabled(false);
         m_togglePopupsAction->setEnabled(false);
     }
 }
 
 void JuK::setupGlobalAccels()
 {
     KeyDialog::setupActionShortcut("play");
     KeyDialog::setupActionShortcut("playPause");
     KeyDialog::setupActionShortcut("stop");
     KeyDialog::setupActionShortcut("back");
     KeyDialog::setupActionShortcut("forward");
     KeyDialog::setupActionShortcut("seekBack");
     KeyDialog::setupActionShortcut("seekForward");
     KeyDialog::setupActionShortcut("volumeUp");
     KeyDialog::setupActionShortcut("volumeDown");
     KeyDialog::setupActionShortcut("mute");
     KeyDialog::setupActionShortcut("showHide");
     KeyDialog::setupActionShortcut("forwardAlbum");
 }
 
 void JuK::slotProcessArgs()
 {
     CollectionList::instance()->addFiles(m_filesToOpen);
 }
 
 void JuK::slotClearOldCovers()
 {
     // Find all saved covers from the previous run of JuK and clear them out, in case
     // we find our tracks in a different order this run, which would cause old saved
     // covers to be wrong.
     // See mpris2/mediaplayer2player.cpp
     QStringList oldFiles = KGlobal::dirs()->findAllResources("tmp", "juk-cover-*.png");
 
     foreach(const QString &file, oldFiles) {
         qCWarning(JUK_LOG) << "Removing old cover" << file;
         if(!QFile::remove(file)) {
             qCCritical(JUK_LOG) << "Failed to remove old cover" << file;
         }
     }
 }
 
 void JuK::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() >= Qt::Key_Back && e->key() <= Qt::Key_MediaLast)
         e->accept();
     KXmlGuiWindow::keyPressEvent(e);
 }
 
 /**
  * These are settings that need to be know before setting up the GUI.
  */
 
 void JuK::readSettings()
 {
     KConfigGroup config(KSharedConfig::openConfig(), "Settings");
-    m_showSplash = config.readEntry("ShowSplashScreen", true);
     m_startDocked = config.readEntry("StartDocked", false);
 }
 
 void JuK::readConfig()
 {
     // player settings
 
     KConfigGroup playerConfig(KSharedConfig::openConfig(), "Player");
 
     if(m_player)
     {
         const int maxVolume = 100;
         const int volume = playerConfig.readEntry("Volume", maxVolume);
         m_player->setVolume(volume * 0.01);
 
         bool enableCrossfade = playerConfig.readEntry("CrossfadeTracks", true);
         m_player->setCrossfadeEnabled(enableCrossfade);
         //ActionCollection::action<QAction>("crossfadeTracks")->setChecked(enableCrossfade);
     }
 
     // Default to no random play
 
     ActionCollection::action<KToggleAction>("disableRandomPlay")->setChecked(true);
 
     QString randomPlayMode = playerConfig.readEntry("RandomPlay", "Disabled");
     if(randomPlayMode == "true" || randomPlayMode == "Normal")
         m_randomPlayAction->setChecked(true);
     else if(randomPlayMode == "AlbumRandomPlay")
         ActionCollection::action<QAction>("albumRandomPlay")->setChecked(true);
 
     bool loopPlaylist = playerConfig.readEntry("LoopPlaylist", false);
     //ActionCollection::action<QAction>("loopPlaylist")->setChecked(loopPlaylist);
 
     // general settings
 
     KConfigGroup settingsConfig(KSharedConfig::openConfig(), "Settings");
 
     bool dockInSystemTray = settingsConfig.readEntry("DockInSystemTray", true);
     m_toggleSystemTrayAction->setChecked(dockInSystemTray);
 
     bool dockOnClose = settingsConfig.readEntry("DockOnClose", true);
     m_toggleDockOnCloseAction->setChecked(dockOnClose);
 
     bool showPopups = settingsConfig.readEntry("TrackPopup", false);
     m_togglePopupsAction->setChecked(showPopups);
-
-    m_toggleSplashAction->setChecked(m_showSplash);
 }
 
 void JuK::saveConfig()
 {
     // player settings
 
     KConfigGroup playerConfig(KSharedConfig::openConfig(), "Player");
 
     if (m_player)
     {
         playerConfig.writeEntry("Volume", static_cast<int>(100.0 * m_player->volume()));
     }
 
     playerConfig.writeEntry("RandomPlay", m_randomPlayAction->isChecked());
 
     QAction *a = ActionCollection::action<QAction>("loopPlaylist");
     playerConfig.writeEntry("LoopPlaylist", a->isChecked());
 
     a = ActionCollection::action<QAction>("crossfadeTracks");
     playerConfig.writeEntry("CrossfadeTracks", a->isChecked());
 
     a = ActionCollection::action<QAction>("albumRandomPlay");
     if(a->isChecked())
         playerConfig.writeEntry("RandomPlay", "AlbumRandomPlay");
     else if(m_randomPlayAction->isChecked())
         playerConfig.writeEntry("RandomPlay", "Normal");
     else
         playerConfig.writeEntry("RandomPlay", "Disabled");
 
     // general settings
 
     KConfigGroup settingsConfig(KSharedConfig::openConfig(), "Settings");
-    settingsConfig.writeEntry("ShowSplashScreen", m_toggleSplashAction->isChecked());
     settingsConfig.writeEntry("StartDocked", m_startDocked);
     settingsConfig.writeEntry("DockInSystemTray", m_toggleSystemTrayAction->isChecked());
     settingsConfig.writeEntry("DockOnClose", m_toggleDockOnCloseAction->isChecked());
     settingsConfig.writeEntry("TrackPopup", m_togglePopupsAction->isChecked());
 
     KSharedConfig::openConfig()->sync();
 }
 
 bool JuK::queryClose()
 {
     if(!m_shuttingDown &&
        !qApp->isSavingSession() &&
        m_systemTray &&
        m_toggleDockOnCloseAction->isChecked())
     {
         KMessageBox::information(this,
             i18n("<qt>Closing the main window will keep JuK running in the system tray. "
                  "Use Quit from the File menu to quit the application.</qt>"),
             i18n("Docking in System Tray"), "hideOnCloseInfo");
         hide();
         return false;
     }
     else
     {
         // Some phonon backends will crash on shutdown unless we've stopped
         // playback.
         if(m_player->playing())
             m_player->stop();
 
         // Save configuration data.
         m_startDocked = !isVisible();
         saveConfig();
         return true;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private slot definitions
 ////////////////////////////////////////////////////////////////////////////////
 
 void JuK::slotShowHide()
 {
     setHidden(!isHidden());
 }
 
 void JuK::slotAboutToQuit()
 {
     m_shuttingDown = true;
 
     deleteAndClear(m_systemTray);
     deleteAndClear(m_splitter);
     deleteAndClear(m_player);
     deleteAndClear(m_statusLabel);
 
     // Playlists depend on CoverManager, so CoverManager should shutdown as
     // late as possible
     CoverManager::shutdown();
 }
 
 void JuK::slotQuit()
 {
     m_shuttingDown = true;
 
     qApp->quit();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // settings menu
 ////////////////////////////////////////////////////////////////////////////////
 
 void JuK::slotToggleSystemTray(bool enabled)
 {
     if(enabled && !m_systemTray)
         slotSetupSystemTray();
     else if(!enabled && m_systemTray) {
         delete m_systemTray;
         m_systemTray = 0;
         m_toggleDockOnCloseAction->setEnabled(false);
         m_togglePopupsAction->setEnabled(false);
     }
 }
 
 void JuK::slotEditKeys()
 {
     KeyDialog::configure(ActionCollection::actions(), this);
 }
 
 void JuK::slotConfigureTagGuesser()
 {
     TagGuesserConfigDlg(this).exec();
 }
 
 void JuK::slotConfigureFileRenamer()
 {
     FileRenamerConfigDlg(this).exec();
 }
 
 void JuK::slotConfigureScrobbling()
 {
     ScrobbleConfigDlg(this).exec();
     activateScrobblerIfEnabled();
 }
 
 void JuK::activateScrobblerIfEnabled()
 {
     bool isScrobbling = Scrobbler::isScrobblingEnabled();
 
     if (!m_scrobbler && isScrobbling) {
         m_scrobbler = new Scrobbler(this);
         connect (m_player,    SIGNAL(signalItemChanged(FileHandle)),
                  m_scrobbler, SLOT(nowPlaying(FileHandle)));
     }
     else if (m_scrobbler && !isScrobbling) {
         delete m_scrobbler;
         m_scrobbler = 0;
     }
 }
 
 void JuK::slotUndo()
 {
     TagTransactionManager::instance()->undo();
 }
 
 void JuK::slotCheckAlbumNextAction(bool albumRandomEnabled)
 {
     // If album random play is enabled, then enable the Play Next Album action
     // unless we're not playing right now.
 
     if(albumRandomEnabled && !m_player->playing())
         albumRandomEnabled = false;
 
     action("forwardAlbum")->setEnabled(albumRandomEnabled);
 }
 
 // vim: set et sw=4 tw=0 sta:
diff --git a/juk.h b/juk.h
index 210749b2..a13e36ac 100644
--- a/juk.h
+++ b/juk.h
@@ -1,109 +1,107 @@
 /**
  * Copyright (C) 2002-2004 Scott Wheeler <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.
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  * PARTICULAR PURPOSE. See the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef JUK_H
 #define JUK_H
 
 #include <kxmlguiwindow.h>
 
 #include "playermanager.h"
 #include <QKeyEvent>
 
 
 class KToggleAction;
 class KGlobalAccel;
 
 class SliderAction;
 class StatusLabel;
 class SystemTray;
 class PlayerManager;
 class PlaylistSplitter;
 class Scrobbler;
 
 class JuK : public KXmlGuiWindow
 {
     Q_OBJECT
 
 public:
     JuK(const QStringList &filesToOpen, QWidget* parent = 0);
     virtual ~JuK();
 
     static JuK* JuKInstance();
 
     PlayerManager *playerManager() const;
 
     // Use a null cover for failure
     void coverDownloaded(const QPixmap &cover);
 
 private:
     void setupLayout();
     void setupActions();
     void setupGlobalAccels();
 
     void keyPressEvent(QKeyEvent *);
 
     void activateScrobblerIfEnabled();
 
     /**
      * readSettings() is separate from readConfig() in that it contains settings
      * that need to be read before the GUI is setup.
      */
     void readSettings();
     void readConfig();
     void saveConfig();
 
     virtual bool queryClose();
 
 private slots:
     void slotSetupSystemTray();
     void slotShowHide();
     void slotAboutToQuit();
     void slotQuit();
     void slotToggleSystemTray(bool enabled);
     void slotEditKeys();
     void slotConfigureTagGuesser();
     void slotConfigureFileRenamer();
     void slotConfigureScrobbling();
     void slotUndo();
     void slotCheckAlbumNextAction(bool albumRandomEnabled);
     void slotProcessArgs();
     void slotClearOldCovers();
 
 private:
     PlaylistSplitter *m_splitter;
     StatusLabel *m_statusLabel;
     SystemTray *m_systemTray;
 
     KToggleAction *m_randomPlayAction;
     KToggleAction *m_toggleSystemTrayAction;
     KToggleAction *m_toggleDockOnCloseAction;
     KToggleAction *m_togglePopupsAction;
-    KToggleAction *m_toggleSplashAction;
 
     PlayerManager *m_player;
     Scrobbler     *m_scrobbler;
 
     QStringList m_filesToOpen;
     bool m_startDocked;
-    bool m_showSplash;
     bool m_shuttingDown;
 
     static JuK* m_instance;
 };
 
 #endif
 
 // vim: set et sw=4 tw=0 sta:
diff --git a/jukui-rtl.rc b/jukui-rtl.rc
index 77c3b896..38d74477 100644
--- a/jukui-rtl.rc
+++ b/jukui-rtl.rc
@@ -1,113 +1,112 @@
 <!DOCTYPE kpartgui>
-<kpartgui name="juk" version="12">
+<kpartgui name="juk" version="13">
 <MenuBar>
 	<Menu name="file" noMerge="1"><text>&amp;File</text>
 		<Action name="file_new"/>
 		<Action name="file_open"/>
 		<Action name="openDirectory"/>
 
 		<Separator/>
 
 		<Action name="renamePlaylist"/>
 		<Action name="editSearch"/>
 		<Action name="duplicatePlaylist"/>
 		<Action name="reloadPlaylist"/>
 		<Action name="deleteItemPlaylist"/>
 
 		<Separator/>
 
 		<Action name="file_save"/>
 		<Action name="file_save_as"/>
 
 		<Separator/>
 
 		<Action name="file_quit"/>
 	</Menu>
 	<Menu name="view" noMerge="1"><text>&amp;View</text>
 		<Action name="showSearch"/>
 		<Action name="showEditor"/>
 		<Action name="showLyrics"/>
 		<Action name="showHistory"/>
 		<Action name="showUpcoming"/>
 		<Action name="showColumns"/>
 		<Action name="resizeColumnsManually"/>
 
 		<Separator/>
 
 		<Action name="viewModeMenu"/>
 	</Menu>
 	<Menu name="player"><text>&amp;Player</text>
 		<Action name="actionMenu"/>
 
 		<Action name="loopPlaylist"/>
 		<Action name="crossfadeTracks"/>
 
 		<Separator/>
 
 		<Action name="play"/>
 		<Action name="pause"/>
 		<Action name="stop"/>
 		<Action name="forward"/>
 		<Action name="back"/>
 
 		<Separator/>
 
 		<Action name="forwardAlbum"/>
 	</Menu>
 	<Menu name="playlist"><text>&amp;Tagger</text>
 		<Action name="saveItem"/>
 		<Action name="removeItem"/>
 		<Action name="refresh"/>
 
 		<Separator/>
 
 		<Action name="guessTag"/>
 		<Action name="coverManager"/>
 		<Action name="renameFile"/>
 	</Menu>
 	<Menu name="settings"><text>&amp;Settings</text>
-		<Action name="showSplashScreen" append="show_merge"/>
 		<Action name="toggleSystemTray" append="show_merge"/>
 		<Action name="dockOnClose" append="show_merge"/>
 		<Action name="togglePopups" append="show_merge"/>
 		<!-- <Action name="saveUpcomingTracks" append="show_merge"/> -->
 		<Action name="tagGuesserConfig" append="save_merge"/>
 		<Action name="fileRenamerConfig" append="save_merge"/>
 		<Action name="scrobblerConfig" append="save_merge"/>
 		<Action name="outputSelect" append="save_merge"/>
 	</Menu>
 </MenuBar>
 
 <ToolBar name="mainToolBar" hidden="true" noMerge="1"><text>Main Toolbar</text>
 	<Action name="file_new"/>
 	<Action name="file_open"/>
 	<Action name="file_save"/>
 
 	<Separator lineSeparator="true"/>
 
 	<Action name="edit_cut"/>
 	<Action name="edit_copy"/>
 	<Action name="edit_paste"/>
 
 	<Separator lineSeparator="true"/>
 
 	<Action name="showSearch"/>
 	<Action name="showEditor"/>
 	<Action name="showNowPlaying"/>
 </ToolBar>
 
 <ToolBar name="playToolBar" noMerge="1"><text>Play Toolbar</text>
 
         <Action name="volumeAction"/>
 	<Action name="trackPositionAction"/>
 	<Action name="forward"/>
 	<Action name="back"/>
 	<Separator lineSeparator="false"/>	
 
 
 	<Action name="stop"/>
 	<Action name="pause"/>
 	<Action name="play"/>
 
 </ToolBar>
 </kpartgui>
diff --git a/jukui.rc b/jukui.rc
index 4a14d454..4277d28e 100644
--- a/jukui.rc
+++ b/jukui.rc
@@ -1,113 +1,112 @@
 <!-- PLEASE UPDATE jukui-rtl.rc WHEN UPDATING THIS FILE -->
 
 <!DOCTYPE kpartgui>
-<kpartgui name="juk" version="12">
+<kpartgui name="juk" version="13">
 <MenuBar>
 	<Menu name="file" noMerge="1"><text>&amp;File</text>
 		<Action name="file_new"/>
 		<Action name="file_open"/>
 		<Action name="openDirectory"/>
 
 		<Separator/>
 
 		<Action name="renamePlaylist"/>
 		<Action name="editSearch"/>
 		<Action name="duplicatePlaylist"/>
 		<Action name="reloadPlaylist"/>
 		<Action name="deleteItemPlaylist"/>
 
 		<Separator/>
 
 		<Action name="file_save"/>
 		<Action name="file_save_as"/>
 
 		<Separator/>
 
 		<Action name="file_quit"/>
 	</Menu>
 	<Menu name="view" noMerge="1"><text>&amp;View</text>
 		<Action name="showSearch"/>
 		<Action name="showEditor"/>
 		<Action name="showLyrics"/>
 		<Action name="showHistory"/>
 		<Action name="showUpcoming"/>
 		<Action name="showColumns"/>
 		<Action name="resizeColumnsManually"/>
 
 		<Separator/>
 
 		<Action name="viewModeMenu"/>
 	</Menu>
 	<Menu name="player"><text>&amp;Player</text>
 		<Action name="actionMenu"/>
 
 		<Action name="loopPlaylist"/>
 		<Action name="crossfadeTracks"/>
 
 		<Separator/>
 
 		<Action name="play"/>
 		<Action name="pause"/>
 		<Action name="stop"/>
 		<Action name="forward"/>
 		<Action name="back"/>
 
 		<Separator/>
 
 		<Action name="forwardAlbum"/>
 	</Menu>
 	<Menu name="playlist"><text>&amp;Tagger</text>
 		<Action name="saveItem"/>
 		<Action name="removeItem"/>
 		<Action name="refresh"/>
 
 		<Separator/>
 
 		<Action name="guessTag"/>
 		<Action name="coverManager"/>
 		<Action name="renameFile"/>
 	</Menu>
 	<Menu name="settings"><text>&amp;Settings</text>
-		<Action name="showSplashScreen" append="show_merge"/>
 		<Action name="toggleSystemTray" append="show_merge"/>
 		<Action name="dockOnClose" append="show_merge"/>
 		<Action name="togglePopups" append="show_merge"/>
 		<!-- <Action name="saveUpcomingTracks" append="show_merge"/> -->
 		<Action name="tagGuesserConfig" append="save_merge"/>
 		<Action name="fileRenamerConfig" append="save_merge"/>
 		<Action name="scrobblerConfig" append="save_merge"/>
 		<Action name="outputSelect" append="save_merge"/>
 	</Menu>
 </MenuBar>
 
 <ToolBar name="mainToolBar" hidden="true" noMerge="1"><text>Main Toolbar</text>
 	<Action name="file_new"/>
 	<Action name="file_open"/>
 	<Action name="file_save"/>
 
 	<Separator lineSeparator="true"/>
 
 	<Action name="edit_cut"/>
 	<Action name="edit_copy"/>
 	<Action name="edit_paste"/>
 
 	<Separator lineSeparator="true"/>
 
 	<Action name="showSearch"/>
 	<Action name="showEditor"/>
 	<Action name="showNowPlaying"/>
 </ToolBar>
 
 <ToolBar name="playToolBar" noMerge="1"><text>Play Toolbar</text>
 	<Action name="play"/>
 	<Action name="pause"/>
 	<Action name="stop"/>
 
 	<Separator lineSeparator="false"/>	
 
 	<Action name="back"/>
 	<Action name="forward"/>
 	<Action name="trackPositionAction"/>
 	<Action name="volumeAction"/>
 </ToolBar>
 </kpartgui>
diff --git a/pics/CMakeLists.txt b/pics/CMakeLists.txt
index 66a35879..11ff67c2 100644
--- a/pics/CMakeLists.txt
+++ b/pics/CMakeLists.txt
@@ -1,3 +1,3 @@
 
-install( FILES theme.svg playing.png splash.png DESTINATION  ${DATA_INSTALL_DIR}/juk/pics )
+install( FILES theme.svg playing.png DESTINATION  ${DATA_INSTALL_DIR}/juk/pics )
 
diff --git a/pics/splash.png b/pics/splash.png
deleted file mode 100644
index 3cbaca7e..00000000
Binary files a/pics/splash.png and /dev/null differ
diff --git a/splashscreen.cpp b/splashscreen.cpp
deleted file mode 100644
index ca7b1bba..00000000
--- a/splashscreen.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/**
- * Copyright (C) 2002-2004 Scott Wheeler <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.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
- * PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "splashscreen.h"
-#include "juk_debug.h"
-
-#include <kiconloader.h>
-#include <klocale.h>
-#include <kstandarddirs.h>
-
-#include <QPixmap>
-#include <QLabel>
-#include <QPalette>
-
-SplashScreen *SplashScreen::splash = 0;
-bool SplashScreen::done = false;
-int SplashScreen::count = 0;
-
-static QString loadedText(int i)
-{
-    return i18nc("%1 is a count of loaded music tracks", "Loading: %1", i);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// pubic members
-////////////////////////////////////////////////////////////////////////////////
-
-SplashScreen *SplashScreen::instance()
-{
-    if(!splash && !done)
-        splash = new SplashScreen();
-    return splash;
-}
-
-void SplashScreen::finishedLoading()
-{
-    done = true;
-    delete splash;
-    splash = 0;
-}
-
-void SplashScreen::increment()
-{
-    if(splash) {
-        count++;
-        if(( count & 63 ) == 0)
-            splash->processEvents();
-    }
-}
-
-void SplashScreen::update()
-{
-    if(splash)
-        splash->processEvents();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// protected members
-////////////////////////////////////////////////////////////////////////////////
-
-SplashScreen::SplashScreen() : QLabel(0, Qt::SplashScreen)
-{
-    setObjectName( QLatin1String("splashScreen" ));
-
-    QPixmap background = UserIcon("splash");
-    resize(background.size());
-    QPalette palette;
-    palette.setBrush(backgroundRole(), QBrush(background));
-
-    setMargin(7);
-    setAlignment(Qt::AlignLeft | Qt::AlignBottom);
-
-    palette.setColor(foregroundRole(), QColor(107, 158, 194));
-    setPalette(palette);
-
-    QFont f = font();
-    f.setPixelSize(10);
-    setFont(f);
-
-    setText(loadedText(0));
-}
-
-SplashScreen::~SplashScreen()
-{
-
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private methods
-////////////////////////////////////////////////////////////////////////////////
-
-void SplashScreen::processEvents()
-{
-    setText(loadedText(count));
-}
-
-// vim: set et sw=4 tw=0 sta:
diff --git a/splashscreen.h b/splashscreen.h
deleted file mode 100644
index 5ef87e74..00000000
--- a/splashscreen.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Copyright (C) 2002-2004 Scott Wheeler <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.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
- * PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef SPLASHSCREEN_H
-#define SPLASHSCREEN_H
-
-#include <QLabel>
-
-/**
- * Well, all of this session restoration sure is fun, but it's starting to take
- * a while, especially say, if you're building KDE and indexing your file system
- * in the background.  ;-)  So, despite my general hate of splashscreens I
- * thought on appropriate here.
- *
- * As in other places, this is a singleton.  That makes it relatively easy to
- * handle the updates from whichever class seems appropriate through static
- * methods.
- */
-
-class SplashScreen : public QLabel
-{
-public:
-    static SplashScreen *instance();
-    static void finishedLoading();
-    static void increment();
-    static void update();
-
-protected:
-    SplashScreen();
-    virtual ~SplashScreen();
-
-private:
-    void processEvents();
-
-    static SplashScreen *splash;
-    static bool done;
-    static int count;
-};
-
-#endif
-
-// vim: set et sw=4 tw=0 sta: