• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

digikam

albumiconview.cpp

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * http://www.digikam.org
 *
 * Date        : 2002-16-10
 * Description : album icon view
 *
 * Copyright (C) 2002-2005 by Renchi Raju <renchi@pooh.tam.uiuc.edu>
 * Copyright (C) 2002-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
 * Copyright (C) 2006-2008 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 *
 * 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, 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.
 *
 * ============================================================ */

// C Ansi includes.

extern "C"
{
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
}

// C++ includes.

#include <cstdio>

// Qt includes.

#include <Q3IntDict>
#include <Q3Dict>
#include <QImage>
#include <QString>
#include <QStringList>
#include <QEvent>
#include <QPainter>
#include <QPoint>
#include <QPolygon>
#include <QDateTime>
#include <QFileInfo>
#include <QFile>
#include <QCursor>
#include <QDataStream>
#include <QTimer>
#include <QClipboard>
#include <QPixmap>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QResizeEvent>

// KDE includes.

#include <kdebug.h>
#include <kurl.h>
#include <kapplication.h>
#include <klocale.h>
#include <kglobal.h>
#include <kmessagebox.h>
#include <kiconloader.h>
#include <kpropsdlg.h>
#include <ktrader.h>
#include <kservice.h>
#include <krun.h>
#include <kaction.h>
#include <kmenu.h>
#include <kstandarddirs.h>
#include <kiconeffect.h>
#include <kdeversion.h>
#include <kcalendarsystem.h>
#include <kinputdialog.h>
#include <kio/jobuidelegate.h>
#include <kmimetypetrader.h>
#include <kstandardaction.h>

// LibKipi includes.

#include <libkipi/pluginloader.h>
#include <libkipi/plugin.h>

// LibKDcraw includes.

#include <libkdcraw/version.h>
#include <libkdcraw/kdcraw.h>

#if KDCRAW_VERSION < 0x000400
#include <libkdcraw/dcrawbinary.h>
#endif

// Local includes.

#include "constants.h"
#include "album.h"
#include "albumdb.h"
#include "albummanager.h"
#include "dio.h"
#include "albumlister.h"
#include "albumfiletip.h"
#include "albumsettings.h"
#include "databasetransaction.h"
#include "databaseaccess.h"
#include "imagewindow.h"
#include "thumbnailsize.h"
#include "themeengine.h"
#include "dpopupmenu.h"
#include "tagspopupmenu.h"
#include "ratingpopupmenu.h"
#include "scancontroller.h"
#include "thumbnailloadthread.h"
#include "cameraui.h"
#include "ddragobjects.h"
#include "dmetadata.h"
#include "albumdb.h"
#include "imageattributeswatch.h"
#include "deletedialog.h"
#include "albumiconitem.h"
#include "albumicongroupitem.h"
#include "loadingcacheinterface.h"
#include "lighttablewindow.h"
#include "statusprogressbar.h"
#include "metadatahub.h"
#include "albumiconview.h"
#include "albumiconview.moc"

namespace Digikam
{

class AlbumIconViewPrivate
{
public:

    void init()
    {
        imageLister   = 0;
        currentAlbum  = 0;
        albumSettings = 0;
        toolTip       = 0;

        // Pre-computed star polygon for a 15x15 pixmap.
        starPolygon << QPoint(0,  6);
        starPolygon << QPoint(5,  5);
        starPolygon << QPoint(7,  0);
        starPolygon << QPoint(9,  5);
        starPolygon << QPoint(14, 6);
        starPolygon << QPoint(10, 9);
        starPolygon << QPoint(11, 14);
        starPolygon << QPoint(7,  11);
        starPolygon << QPoint(3,  14);
        starPolygon << QPoint(4,  9);

        starPolygonSize = QSize(15, 15);

        ratingPixmaps = QVector<QPixmap>(10);
    }

    QString                          albumTitle;
    QString                          albumDate;
    QString                          albumComments;

    QRect                            itemRect;
    QRect                            itemRatingRect;
    QRect                            itemDateRect;
    QRect                            itemModDateRect;
    QRect                            itemPixmapRect;
    QRect                            itemNameRect;
    QRect                            itemCommentsRect;
    QRect                            itemResolutionRect;
    QRect                            itemSizeRect;
    QRect                            itemTagRect;
    QRect                            bannerRect;

    QPixmap                          itemRegPixmap;
    QPixmap                          itemSelPixmap;
    QPixmap                          bannerPixmap;
    QVector<QPixmap>                 ratingPixmaps;

    QFont                            fnReg;
    QFont                            fnCom;
    QFont                            fnXtra;

    QPolygon                         starPolygon;
    QSize                            starPolygonSize;

    Q3Dict<AlbumIconItem>            itemDict;
    QHash<ImageInfo, AlbumIconItem*> itemInfoMap;

    KUrl                             itemUrlToFind;

    AlbumLister                     *imageLister;
    Album                           *currentAlbum;
    const AlbumSettings             *albumSettings;
    Q3IntDict<AlbumIconGroupItem>    albumDict;

    ThumbnailSize                    thumbSize;

    AlbumFileTip                    *toolTip;
};

AlbumIconView::AlbumIconView(QWidget* parent)
             : IconView(parent)
{
    d = new AlbumIconViewPrivate;
    d->init();
    d->imageLister = AlbumLister::instance();
    d->toolTip     = new AlbumFileTip(this);

    setAcceptDrops(true);
    viewport()->setAcceptDrops(true);

    // -- ImageLister connections -------------------------------------

    connect(d->imageLister, SIGNAL(signalNewFilteredItems(const ImageInfoList&)),
            this, SLOT(slotImageListerNewItems(const ImageInfoList&)));

    connect(d->imageLister, SIGNAL(signalDeleteFilteredItem(const ImageInfo &)),
            this, SLOT(slotImageListerDeleteItem(const ImageInfo &)) );

    connect(d->imageLister, SIGNAL(signalClear()),
            this, SLOT(slotImageListerClear()));

    // -- Icon connections --------------------------------------------

    connect(this, SIGNAL(signalDoubleClicked(IconItem*)),
            this, SLOT(slotDoubleClicked(IconItem*)));

    connect(this, SIGNAL(signalReturnPressed(IconItem*)),
            this, SLOT(slotDoubleClicked(IconItem*)));

    connect(this, SIGNAL(signalRightButtonClicked(IconItem*, const QPoint &)),
            this, SLOT(slotRightButtonClicked(IconItem*, const QPoint &)));

    connect(this, SIGNAL(signalRightButtonClicked(const QPoint &)),
            this, SLOT(slotRightButtonClicked(const QPoint &)));

    connect(this, SIGNAL(signalSelectionChanged()),
            this, SLOT(slotSelectionChanged()));

    connect(this, SIGNAL(signalShowToolTip(IconItem*)),
            this, SLOT(slotShowToolTip(IconItem*)));

    // -- ThemeEngine connections ---------------------------------------

    connect(ThemeEngine::instance(), SIGNAL(signalThemeChanged()),
            this, SLOT(slotThemeChanged()));

    // -- Pixmap manager connections ------------------------------------

    connect(ThumbnailLoadThread::defaultIconViewThread(), SIGNAL(signalThumbnailLoaded(const LoadingDescription &, const QPixmap&)),
            this, SLOT(slotThumbnailLoaded(const LoadingDescription &, const QPixmap&)));

    // -- ImageAttributesWatch connections ------------------------------

    ImageAttributesWatch *watch = ImageAttributesWatch::instance();

    connect(watch, SIGNAL(signalImageTagsChanged(qlonglong)),
            this, SLOT(slotImageAttributesChanged(qlonglong)));

    connect(watch, SIGNAL(signalImagesChanged(int)),
            this, SLOT(slotAlbumImagesChanged(int)));

    connect(watch, SIGNAL(signalImageRatingChanged(qlonglong)),
            this, SLOT(slotImageAttributesChanged(qlonglong)));

    connect(watch, SIGNAL(signalImageDateChanged(qlonglong)),
            this, SLOT(slotImageAttributesChanged(qlonglong)));

    connect(watch, SIGNAL(signalImageCaptionChanged(qlonglong)),
            this, SLOT(slotImageAttributesChanged(qlonglong)));
}

AlbumIconView::~AlbumIconView()
{
    delete d->toolTip;
    delete d;
}

void AlbumIconView::applySettings(const AlbumSettings* settings)
{
    if (!settings)
        return;

    d->albumSettings = settings;

    d->thumbSize = (ThumbnailSize::Size)d->albumSettings->getDefaultIconSize();

    setEnableToolTips(d->albumSettings->getShowToolTips());

    updateRectsAndPixmaps();

    d->imageLister->stop();
    clear();

    ThumbnailLoadThread::defaultIconViewThread()->setThumbnailSize(d->thumbSize.size());

    if (d->currentAlbum)
    {
        d->imageLister->openAlbum(d->currentAlbum);
    }
}

void AlbumIconView::setThumbnailSize(const ThumbnailSize& thumbSize)
{
    if ( d->thumbSize != thumbSize)
    {
        d->imageLister->stop();
        clear();

        d->thumbSize = thumbSize;
        ThumbnailLoadThread::defaultIconViewThread()->setThumbnailSize(d->thumbSize.size());

        updateRectsAndPixmaps();

        d->imageLister->openAlbum(d->currentAlbum);
    }
}

void AlbumIconView::setAlbum(Album* album)
{
    if (!album)
    {
        d->currentAlbum = 0;
        d->imageLister->stop();
        clear();

        return;
    }

    if (d->currentAlbum == album)
        return;

    d->imageLister->stop();
    clear();

    d->currentAlbum = album;
    d->imageLister->openAlbum(d->currentAlbum);

    updateRectsAndPixmaps();
}

void AlbumIconView::setAlbumItemToFind(const KUrl& url)
{
    d->itemUrlToFind = url;
}

void AlbumIconView::refreshIcon(AlbumIconItem* item)
{
    if (!item)
        return;

    emit signalSelectionChanged();
}

void AlbumIconView::clear(bool update)
{
    emit signalCleared();

    d->itemDict.clear();
    d->albumDict.clear();
    d->itemInfoMap.clear();

    IconView::clear(update);

    emit signalSelectionChanged();
}

void AlbumIconView::slotImageListerNewItems(const ImageInfoList& itemList)
{
    if (!d->currentAlbum || d->currentAlbum->isRoot())
        return;

    for (ImageInfoList::const_iterator it = itemList.begin(); it != itemList.end(); ++it)
    {
        KUrl url( it->fileUrl() );
        url.cleanPath();

        if (d->itemInfoMap.contains(*it))
        {
            // TODO: Make sure replacing slotImageListerDeleteItem with continue here is not wrong
            //slotImageListerDeleteItem((*itMap)->imageInfo());
            continue;
        }

        AlbumIconGroupItem* group = d->albumDict.find(it->albumId());
        if (!group)
        {
            group = new AlbumIconGroupItem(this, it->albumId());
            d->albumDict.insert(it->albumId(), group);
        }

        PAlbum *album = AlbumManager::instance()->findPAlbum(it->albumId());
        if (!album)
        {
            kWarning(50003) << "No album for item: " << it->name()
                            << ", albumID: " << it->albumId() << endl;
            continue;
        }

        AlbumIconItem* iconItem = new AlbumIconItem(group, (*it));

        d->itemDict.insert(url.url(), iconItem);
        d->itemInfoMap.insert((*it), iconItem);
    }

    // Make the icon, specified by d->itemUrlToFind, the current one
    // in the album icon view and make it visible.
    // This is for example used after a "Go To",
    // e.g. from tags (or date) view to folder view.
    // Note that AlbumIconView::slotImageListerNewItems may
    // be called several times after another, because images get
    // listed in packages of 200.
    // Therefore the item might not always be available in the very
    // first call when there are sufficiently many images.
    // Also, because of this, we cannot reset the item which is to be found,
    // i.e. something like d->itemUrlToFind = 0, after the item was found,
    // as then the visibility of this item is lost in a subsequent call.
    if (!d->itemUrlToFind.isEmpty())
    {
        AlbumIconItem* icon = findItem(d->itemUrlToFind.url());
        if (icon)
        {
            clearSelection();
            updateContents();
            setCurrentItem(icon);
            ensureItemVisible(icon);

            // make the item really visible
            // (the previous ensureItemVisible does not work)
            setStoredVisibleItem(icon);
            triggerRearrangement();
        }
    }

    emit signalItemsAdded();
}

void AlbumIconView::slotImageListerDeleteItem(const ImageInfo &item)
{
    QHash<ImageInfo, AlbumIconItem*>::iterator itMap = d->itemInfoMap.find(item);
    if (itMap == d->itemInfoMap.end())
        return;

    AlbumIconItem* iconItem = (*itMap);

    /*
    // ?? Necessary? For what situation?
    KUrl url(item->kurl());
    url.cleanPath();

    AlbumIconItem *oldItem = d->itemDict[url.url()];

    if( oldItem &&
       (oldItem->imageInfo()->id() != iconItem->imageInfo()->id()))
    {
        return;
    }
    */

    //d->pixMan->deleteThumbnail(item->kurl());

    emit signalItemDeleted(iconItem);

    delete iconItem;

    d->itemInfoMap.remove(item);
    d->itemDict.remove(item.fileUrl().url());

    IconGroupItem* group = firstGroup();
    IconGroupItem* tmp;

    while (group)
    {
        tmp = group->nextGroup();

        if (group->count() == 0)
        {
            d->albumDict.remove(((AlbumIconGroupItem*)group)->albumID());
            delete group;
        }

        group = tmp;
    }
}

void AlbumIconView::slotImageListerClear()
{
    clear();
}

void AlbumIconView::slotDoubleClicked(IconItem *item)
{
    if (!item) return;

    if (d->albumSettings->getItemRightClickAction() == AlbumSettings::ShowPreview)
    {
        // icon effect takes too much time
        //KIconEffect::visualActivate(viewport(), contentsRectToViewport(item->rect()));
        signalPreviewItem(static_cast<AlbumIconItem *>(item));
    }
    else
    {
        // FIXME: this method has diseapear from kdelibs4
        //KIconEffect::visualActivate(viewport(), contentsRectToViewport(item->rect()));
        slotDisplayItem(static_cast<AlbumIconItem *>(item));
    }
}

void AlbumIconView::slotRightButtonClicked(const QPoint& pos)
{
    if (!d->currentAlbum)
        return;

    if (d->currentAlbum->isRoot() ||
         (   d->currentAlbum->type() != Album::PHYSICAL
          && d->currentAlbum->type() != Album::TAG))
    {
        return;
    }

    QMenu popmenu(this);
    KAction *paste        = KStandardAction::paste(this, SLOT(slotPaste()), 0);
    const QMimeData *data = kapp->clipboard()->mimeData(QClipboard::Clipboard);

    if(!data || !KUrl::List::canDecode(data))
        paste->setEnabled(false);

    popmenu.addAction(paste);
    popmenu.exec(pos);
    delete paste;
}

void AlbumIconView::slotRightButtonClicked(IconItem *item, const QPoint& pos)
{
    if (!item)
        return;

    AlbumIconItem* iconItem = static_cast<AlbumIconItem *>(item);

    //-- Open With Actions ------------------------------------

    KMimeType::Ptr mimePtr = KMimeType::findByUrl(iconItem->imageInfo().fileUrl(), 0, true, true);

    QMap<QAction*, KService::Ptr> serviceMap;

    const KService::List offers = KMimeTypeTrader::self()->query(mimePtr->name());
    KService::List::ConstIterator iter;
    KService::Ptr ptr;

    KMenu openWithMenu;

    for( iter = offers.begin(); iter != offers.end(); ++iter )
    {
        ptr = *iter;
        QAction *serviceAction = openWithMenu.addAction(SmallIcon(ptr->icon()), ptr->name());
        serviceMap[serviceAction] = ptr;
    }

    if (openWithMenu.isEmpty())
        openWithMenu.menuAction()->setEnabled(false);

    // --------------------------------------------------------

    // Obtain a list of all selected images.
    // This is needed both for the goto tags submenu here and also
    // for the "move to trash" and further actions below.
    QList<qlonglong> selectedImageIDs;

    for (IconItem *it = firstItem(); it; it=it->nextItem())
    {
        if (it->isSelected())
        {
            AlbumIconItem *selItem = static_cast<AlbumIconItem *>(it);
            selectedImageIDs.append(selItem->imageInfo().id());
        }
    }

    // --------------------------------------------------------
    // Provide Goto folder and/or date pop-up menu
    QMenu gotoMenu;

    QAction *gotoAlbum = gotoMenu.addAction(SmallIcon("folder-image"),        i18n("Album"));
    QAction *gotoDate  = gotoMenu.addAction(SmallIcon("view-calendar-month"), i18n("Date"));

    TagsPopupMenu* gotoTagsPopup = new TagsPopupMenu(selectedImageIDs, TagsPopupMenu::DISPLAY);
    QAction *gotoTag             = gotoMenu.addMenu(gotoTagsPopup);
    gotoTag->setIcon(SmallIcon("tag"));
    gotoTag->setText(i18n("Tag"));

    // Disable the goto Tag popup menu, if there are no tags at all.
    if (!DatabaseAccess().db()->hasTags(selectedImageIDs))
        gotoTag->setEnabled(false);

    connect(gotoTagsPopup, SIGNAL(signalTagActivated(int)),
            this, SLOT(slotGotoTag(int)));

    if (d->currentAlbum->type() == Album::PHYSICAL )
    {
        // If the currently selected album is the same as album to
        // which the image belongs, then disable the "Go To" Album.
        // (Note that in recursive album view these can be different).
        if (iconItem->imageInfo().albumId() == d->currentAlbum->id())
            gotoAlbum->setEnabled(false);
    }
    else if (d->currentAlbum->type() == Album::DATE )
    {
        gotoDate->setEnabled(false);
    }

    // --------------------------------------------------------

    DPopupMenu popmenu(this);
    QAction *viewAction       = popmenu.addAction(SmallIcon("viewimage"),     i18n("View..."));
    QAction *editAction       = popmenu.addAction(SmallIcon("editimage"),     i18n("Edit..."));
    QAction *lighttableAction = popmenu.addAction(SmallIcon("lighttableadd"), i18n("Add to Light Table"));
    QAction *gotoAction       = popmenu.addMenu(&gotoMenu);
    gotoAction->setIcon(SmallIcon("go-jump"));
    gotoAction->setText(i18n("Go To"));

    // If there is more than one image selected, disable the goto menu entry.
    if (selectedImageIDs.count() > 1)
    {
        gotoAction->setEnabled(false);
    }

    popmenu.addMenu(&openWithMenu);
    openWithMenu.menuAction()->setText(i18n("Open With"));

    // Merge in the KIPI plugins actions ----------------------------

    KIPI::PluginLoader* kipiPluginLoader      = KIPI::PluginLoader::instance();
    KIPI::PluginLoader::PluginList pluginList = kipiPluginLoader->pluginList();

    for (KIPI::PluginLoader::PluginList::const_iterator it = pluginList.begin();
         it != pluginList.end(); ++it)
    {
        KIPI::Plugin* plugin = (*it)->plugin();

        if (plugin && (*it)->name() == "JPEGLossless")
        {
            kDebug(50003) << "Found JPEGLossless plugin" << endl;

            QList<KAction*> actionList = plugin->actions();

            for (QList<KAction*>::const_iterator iter = actionList.begin();
                iter != actionList.end(); ++iter)
            {
                KAction* action = *iter;

                if (action->objectName().toLatin1() == QString::fromLatin1("jpeglossless_rotate"))
                {
                    popmenu.addAction(action);
                }
            }
        }
    }

    // --------------------------------------------------------

    QAction *renameAction = popmenu.addAction(SmallIcon("edit-rename"), i18n("Rename..."));
    popmenu.addSeparator();

    // --------------------------------------------------------

    QAction *thumbnailAction = 0;
    if (d->currentAlbum)
    {
        if (d->currentAlbum->type() == Album::PHYSICAL )
        {
            thumbnailAction = popmenu.addAction(i18n("Set as Album Thumbnail"));
            popmenu.addSeparator();
        }
        else if (d->currentAlbum->type() == Album::TAG )
        {
            thumbnailAction = popmenu.addAction(i18n("Set as Tag Thumbnail"));
            popmenu.addSeparator();
        }
    }

    // --------------------------------------------------------

    KAction *copy         = KStandardAction::copy(this, SLOT(slotCopy()), 0);
    KAction *paste        = KStandardAction::paste(this, SLOT(slotPaste()), 0);
    const QMimeData *data = kapp->clipboard()->mimeData(QClipboard::Clipboard);

    if(!data || !KUrl::List::canDecode(data))
        paste->setEnabled(false);

    popmenu.addAction(copy);
    popmenu.addAction(paste);
    popmenu.addSeparator();

    // --------------------------------------------------------

    QAction *trashAction = popmenu.addAction(SmallIcon("user-trash"),
                           i18np("Move to Trash", "Move %1 Files to Trash", selectedImageIDs.count()));

    popmenu.addSeparator();

    // Bulk assignment/removal of tags --------------------------

    TagsPopupMenu* assignTagsPopup = new TagsPopupMenu(selectedImageIDs, TagsPopupMenu::ASSIGN);
    TagsPopupMenu* removeTagsPopup = new TagsPopupMenu(selectedImageIDs, TagsPopupMenu::REMOVE);

    connect(assignTagsPopup, SIGNAL(signalTagActivated(int)),
            this, SLOT(slotAssignTag(int)));

    connect(removeTagsPopup, SIGNAL(signalTagActivated(int)),
            this, SLOT(slotRemoveTag(int)));

    popmenu.addMenu(assignTagsPopup);
    assignTagsPopup->menuAction()->setText(i18n("Assign Tag"));

    popmenu.addMenu(removeTagsPopup);
    removeTagsPopup->menuAction()->setText(i18n("Remove Tag"));

    // Performance: Only check for tags if there are <250 images selected
    // Also disable the remove Tag popup menu, if there are no tags at all.
    if (selectedImageIDs.count() > 250 ||
        !DatabaseAccess().db()->hasTags(selectedImageIDs))
        removeTagsPopup->menuAction()->setEnabled(false);

    popmenu.addSeparator();

    // Assign Star Rating -------------------------------------------

    RatingPopupMenu ratingMenu;

    connect(&ratingMenu, SIGNAL(signalRatingChanged(int)),
            this, SLOT(slotAssignRating(int)));

    popmenu.addMenu(&ratingMenu);
    ratingMenu.menuAction()->setText(i18n("Assign Rating"));

    // --------------------------------------------------------

    QAction *choice = popmenu.exec(pos);

    if (choice)
    {
        if (choice == editAction)
        {
            slotDisplayItem(iconItem);
        }
        else if (choice == renameAction)
        {
            slotRename(iconItem);
        }
        else if (choice == trashAction)
        {
            slotDeleteSelectedItems();
        }
        else if (choice == thumbnailAction)
        {
            slotSetAlbumThumbnail(iconItem);
        }
        else if (choice == viewAction)
        {
            signalPreviewItem(iconItem);
        }
        else if (choice == lighttableAction)
        {
            //  add images to existing images in the light table
            insertSelectionToLightTable(true);
        }
        else if (choice == gotoAlbum)
        {
            // send a signal to the parent widget (digikamview.cpp)
            emit signalGotoAlbumAndItem(iconItem);
        }
        else if (choice == gotoDate)
        {
            // send a signal to the parent widget (digikamview.cpp)
            emit signalGotoDateAndItem(iconItem);
        }
        else
        {
            if (serviceMap.contains(choice))
            {
                KService::Ptr imageServicePtr = serviceMap[choice];
                KUrl::List urlList;
                for (IconItem *it = firstItem(); it; it=it->nextItem())
                {
                    if (it->isSelected())
                    {
                        AlbumIconItem *selItem = static_cast<AlbumIconItem *>(it);
                        urlList.append(selItem->imageInfo().fileUrl());
                    }
                }
                if (urlList.count())
                    KRun::run(*imageServicePtr, urlList, this);
            }
        }
    }

    //---------------------------------------------------------------

    popmenu.deleteLater();
}

void AlbumIconView::slotCopy()
{
    if (!d->currentAlbum)
        return;

    KUrl::List urls;
    KUrl::List kioURLs;
    QList<int> albumIDs;
    QList<int> imageIDs;

    for (IconItem *it = firstItem(); it; it=it->nextItem())
    {
        if (it->isSelected())
        {
            AlbumIconItem *albumItem = static_cast<AlbumIconItem *>(it);
            ImageInfo info = albumItem->imageInfo();
            urls.append(info.fileUrl());
            kioURLs.append(info.databaseUrl());
            imageIDs.append(info.id());
        }
    }
    albumIDs.append(d->currentAlbum->id());

    if (urls.isEmpty())
        return;

    kapp->clipboard()->setMimeData(new DItemDrag(urls, kioURLs, albumIDs, imageIDs));
}

void AlbumIconView::slotPaste()
{
    const QMimeData *data = kapp->clipboard()->mimeData(QClipboard::Clipboard);
    if(!data)
        return;

    Album *album = 0;

    // Check if we working on grouped items view.
    if (groupCount() > 1)
    {
        AlbumIconGroupItem *grp = dynamic_cast<AlbumIconGroupItem*>(findGroup(QCursor::pos()));
        if (grp)
        {
            if(d->currentAlbum->type() == Album::PHYSICAL)
                album = dynamic_cast<Album*>(AlbumManager::instance()->findPAlbum(grp->albumID()));
            else if(d->currentAlbum->type() == Album::TAG)
                album = dynamic_cast<Album*>(AlbumManager::instance()->findTAlbum(grp->albumID()));
        }
    }
    if (!album)
        album = d->currentAlbum;

    if (d->currentAlbum->type() == Album::PHYSICAL)
    {
        if (DItemDrag::canDecode(data))
        {
            // Drag & drop inside of digiKam

            PAlbum* palbum = (PAlbum*)album;

            // B.K.O #119205: do not handle root album.
            if (palbum->isRoot())
                return;

            KUrl::List urls;
            KUrl::List kioURLs;
            QList<int> albumIDs;
            QList<int> imageIDs;

            if (!DItemDrag::decode(data, urls, kioURLs, albumIDs, imageIDs))
                return;

            if (urls.isEmpty() || kioURLs.isEmpty() || albumIDs.isEmpty() || imageIDs.isEmpty())
                return;

            // Check if items dropped come from outside current album.
            KUrl::List extUrls;
            QList<qlonglong> extImageIDs;
            for (QList<int>::iterator it = imageIDs.begin(); it != imageIDs.end(); ++it)
            {
                ImageInfo info(*it);
                if (info.albumId() != album->id())
                {
                    extUrls << info.databaseUrl();
                    extImageIDs << *it;
                }
            }

            if(extUrls.isEmpty())
                return;

            KIO::Job* job = DIO::copy(kioURLs, extImageIDs, palbum);
            connect(job, SIGNAL(result(KJob*)),
                    this, SLOT(slotDIOResult(KJob*)));
        }
        else if (KUrl::List::canDecode(data))
        {
            PAlbum* palbum = (PAlbum*)album;

            // B.K.O #119205: do not handle root album.
            if (palbum->isRoot())
                return;

            KUrl::List srcURLs;
            srcURLs.fromMimeData(data);

            KIO::Job* job = DIO::copy(srcURLs, palbum);
            connect(job, SIGNAL(result(KJob*)),
                    this, SLOT(slotDIOResult(KJob*)));
        }
    }
    else if(d->currentAlbum->type() == Album::TAG && DItemDrag::canDecode(data))
    {
        TAlbum* talbum = (TAlbum*)album;

        // B.K.O #119205: do not handle root album.
        if (talbum->isRoot())
            return;

        KUrl::List urls;
        KUrl::List kioURLs;
        QList<int> albumIDs;
        QList<int> imageIDs;

        if (!DItemDrag::decode(data, urls, kioURLs, albumIDs, imageIDs))
            return;

        if (urls.isEmpty() || kioURLs.isEmpty() || albumIDs.isEmpty() || imageIDs.isEmpty())
            return;

        ImageInfoList list;
        for (QList<int>::const_iterator it = imageIDs.begin();
             it != imageIDs.end(); ++it)
        {
            ImageInfo info(*it);
            list.append(info);
        }

        changeTagOnImageInfos(list, QList<int>() << talbum->id(), true, true);
    }
}

void AlbumIconView::slotSetAlbumThumbnail(AlbumIconItem *iconItem)
{
    if(!d->currentAlbum)
        return;

    if(d->currentAlbum->type() == Album::PHYSICAL)
    {
        PAlbum *album = static_cast<PAlbum*>(d->currentAlbum);

        QString err;
        AlbumManager::instance()->updatePAlbumIcon( album,
                                                    iconItem->imageInfo().id(),
                                                    err );
    }
    else if (d->currentAlbum->type() == Album::TAG)
    {
        TAlbum *album = static_cast<TAlbum*>(d->currentAlbum);

        QString err;
        AlbumManager::instance()->updateTAlbumIcon( album,
                                                    QString(),
                                                    iconItem->imageInfo().id(),
                                                    err );
    }
}

void AlbumIconView::slotRename(AlbumIconItem* item)
{
    if (!item)
        return;

    // Create a copy of the item. After entering the event loop
    // in the dialog, we cannot be sure about the item's status.
    ImageInfo renameInfo = item->imageInfo();

    QFileInfo fi(renameInfo.name());
    QString ext  = QString(".") + fi.suffix();
    QString name = fi.fileName();
    name.truncate(fi.fileName().length() - ext.length());

    bool ok;

    QString newName = KInputDialog::getText(i18n("Rename Item (%1)",fi.fileName()),
                                            i18n("Enter new name (without extension):"),
                                            name, &ok, this);
    if (!ok)
        return;

    KIO::CopyJob* job = DIO::rename(renameInfo, newName + ext);

    connect(job, SIGNAL(result(KJob*)),
            this, SLOT(slotDIOResult(KJob*)));

    connect(job, SIGNAL(copyingDone(KIO::Job *, const KUrl &, const KUrl &, bool, bool)),
            this, SLOT(slotRenamed(KIO::Job*, const KUrl &, const KUrl&)));

    //TODO: The explanation is outdated. Check if we can safely remove.
    // The AlbumManager KDirWatch will trigger a DIO::scan.
    // When this is completed, DIO will call AlbumLister::instance()->refresh().
    // Usually the AlbumLister will ignore changes to already listed items.
    // So the renamed item need explicitly be invalidated.
    d->imageLister->invalidateItem(renameInfo);
}

void AlbumIconView::slotRenamed(KIO::Job*, const KUrl &, const KUrl&newURL)
{
    // reconstruct file path from digikamalbums:// URL
    KUrl fileURL;
    fileURL.setPath(newURL.user());
    fileURL.addPath(newURL.path());

    // refresh thumbnail
    ThumbnailLoadThread::deleteThumbnail(fileURL.path());
    // clean LoadingCache as well - be pragmatic, do it here.
    LoadingCacheInterface::cleanFromCache(fileURL.path());
}

void AlbumIconView::slotDeleteSelectedItems(bool deletePermanently)
{
    KUrl::List  urlList;
    KUrl::List  kioUrlList;

    for (IconItem *it = firstItem(); it; it=it->nextItem())
    {
        if (it->isSelected())
        {
            AlbumIconItem *iconItem = static_cast<AlbumIconItem *>(it);
            ImageInfo info = iconItem->imageInfo();
            urlList.append(info.fileUrl());
            kioUrlList.append(info.databaseUrl());
        }
    }

    if (urlList.count() <= 0)
        return;

    DeleteDialog dialog(this);

    if (!dialog.confirmDeleteList(urlList,
                                  DeleteDialogMode::Files,
                                  deletePermanently ?
                                  DeleteDialogMode::NoChoiceDeletePermanently :
                                  DeleteDialogMode::NoChoiceTrash))
        return;

    bool useTrash = !dialog.shouldDelete();

    // trash does not like non-local URLs, put is not implemented
    KIO::Job* job = DIO::del(useTrash ? urlList : kioUrlList, useTrash);

    connect(job, SIGNAL(result(KJob*)),
            this, SLOT(slotDIOResult(KJob*)));
}

void AlbumIconView::slotDeleteSelectedItemsDirectly(bool useTrash)
{
    // This method deletes the selected items directly, without confirmation.
    // It is not used in the default setup.

    KUrl::List kioUrlList;
    KUrl::List urlList;

    for (IconItem *it = firstItem(); it; it=it->nextItem())
    {
        if (it->isSelected())
        {
            AlbumIconItem *iconItem = static_cast<AlbumIconItem *>(it);
            ImageInfo info = iconItem->imageInfo();
            kioUrlList.append(info.databaseUrl());
            urlList.append(info.fileUrl());
        }
    }

    if (kioUrlList.count() <= 0)
        return;

    // trash does not like non-local URLs, put is not implemented
    KIO::Job* job = DIO::del(useTrash ? urlList : kioUrlList , useTrash);

    connect(job, SIGNAL(result(KJob*)),
            this, SLOT(slotDIOResult(KJob*)));
}

void AlbumIconView::slotFilesModified()
{
    d->imageLister->refresh();
}

void AlbumIconView::slotFilesModified(const KUrl& url)
{
    refreshItems(url);
}

void AlbumIconView::slotImageWindowURLChanged(const KUrl &url)
{
    IconItem* item = findItem(url.url());
    if (item)
        setCurrentItem(item);
}

void AlbumIconView::slotDisplayItem(AlbumIconItem *item)
{
    if (!item) return;

    AlbumSettings *settings = AlbumSettings::instance();

    if (!settings) return;

    QString currentFileExtension = item->imageInfo().name().section( '.', -1 );
    QString imagefilter = settings->getImageFileFilter().toLower() +
                          settings->getImageFileFilter().toUpper();

#if KDCRAW_VERSION < 0x000400
    if (KDcrawIface::DcrawBinary::instance()->versionIsRight())
    {
        // add raw files only if dcraw is available
        imagefilter += settings->getRawFileFilter().toLower() +
                       settings->getRawFileFilter().toUpper();
    }
#else
    // add raw files only if dcraw is available
    imagefilter += settings->getRawFileFilter().toLower() +
                   settings->getRawFileFilter().toUpper();
#endif

    // If the current item is not an image file.
    if ( !imagefilter.contains(currentFileExtension) )
    {
        KMimeType::Ptr mimePtr = KMimeType::findByUrl(item->imageInfo().fileUrl(), 0, true, true);
        const KService::List offers = KServiceTypeTrader::self()->query(mimePtr->name(), "Type == 'Application'");

        if (offers.isEmpty())
            return;

        KService::Ptr ptr = offers.first();
        // Run the dedicated app to show the item.
        KRun::run(*ptr, item->imageInfo().fileUrl(), this);
        return;
    }

    // Run digiKam ImageEditor with all image from current Album.

    ImageInfoList list;
    ImageInfo     current;

    for (IconItem *it = firstItem() ; it ; it = it->nextItem())
    {
        AlbumIconItem *iconItem = static_cast<