Rename 'digikam' folder to 'src'

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit ee0d99607c14cb63d3ebdb3a970b508949fa8219)

1 files changed, 1227 insertions, 0 deletions

diff --git a/src/utilities/cameragui/cameracontroller.cpp b/src/utilities/cameragui/cameracontroller.cpp
new file mode 100644
index 00000000..34afa8ab
--- /dev/null
+++ b/src/utilities/cameragui/cameracontroller.cpp
@@ -0,0 +1,1227 @@
+/* ============================================================
+ *
+ * This file is a part of digiKam project
+ * http://www.digikam.org
+ *
+ * Date        : 2004-09-17
+ * Description : digital camera controller
+ *
+ * Copyright (C) 2004-2005 by Renchi Raju <renchi@pooh.tam.uiuc.edu>
+ * Copyright (C) 2006-2009 by Gilles Caulier <caulier dot gilles at gmail dot com> 
+ *
+ * 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.
+ *
+ * ============================================================ */
+
+extern "C"
+{
+#include <unistd.h>
+}
+
+// C++ includes.
+
+#include <typeinfo>
+#include <cstdio>
+
+// TQt includes.
+
+#include <tqthread.h>
+#include <tqmutex.h>
+#include <tqwaitcondition.h>
+#include <tqevent.h>
+#include <tqapplication.h>
+#include <tqdeepcopy.h>
+#include <tqvariant.h>
+#include <tqimage.h>
+#include <tqdatastream.h>
+#include <tqfile.h>
+#include <tqtimer.h>
+#include <tqregexp.h>
+
+// KDE includes.
+
+#include <tdelocale.h>
+#include <kurl.h>
+#include <tdemessagebox.h>
+#include <tdeio/renamedlg.h>
+#include <kstandarddirs.h>
+
+// Local includes.
+
+#include "ddebug.h"
+#include "thumbnailsize.h"
+#include "imagewindow.h"
+#include "gpcamera.h"
+#include "umscamera.h"
+#include "dmetadata.h"
+#include "jpegutils.h"
+#include "mtqueue.h"
+#include "cameracontroller.h"
+#include "cameracontroller.moc"
+
+namespace Digikam
+{
+
+class CameraThread;
+
+class CameraCommand
+{
+public:
+
+    enum Action
+    {
+        gp_none = 0,
+        gp_connect,
+        gp_cancel,
+        gp_cameraInformations,
+        gp_listfolders,
+        gp_listfiles,
+        gp_download,
+        gp_upload,
+        gp_delete,
+        gp_lock,
+        gp_thumbnail,
+        gp_exif,
+        gp_open
+    };
+
+    Action                 action;
+    TQStringVariantMap map;
+};
+
+class CameraEvent : public TQCustomEvent
+{
+public:
+
+    enum State
+    {
+        gp_connected = 0,
+        gp_busy,
+        gp_listedfolders,
+        gp_listedfiles,
+        gp_downloadstarted,
+        gp_downloaded,
+        gp_downloadFailed,
+        gp_opened,
+        gp_uploaded,
+        gp_uploadFailed,
+        gp_deleted,
+        gp_deleteFailed,
+        gp_locked,
+        gp_lockFailed,
+        gp_thumbnailed,
+        gp_exif,
+        gp_cameraInformations,
+        gp_infomsg,
+        gp_errormsg
+    };
+
+    CameraEvent(State state) :
+        TQCustomEvent(TQEvent::User+state)
+        {}
+
+    bool                   result;
+    TQString                msg;
+    TQStringVariantMap map;
+};
+
+class CameraControllerPriv
+{
+public:
+
+    CameraControllerPriv()
+    {
+        close         = false;
+        overwriteAll  = false;
+        skipAll       = false;
+        canceled      = false;
+        downloadTotal = 0;
+        parent        = 0; 
+        timer         = 0; 
+        camera        = 0;
+        thread        = 0; 
+    }
+
+    bool                    close;
+    bool                    overwriteAll;
+    bool                    skipAll;
+    bool                    canceled;
+
+    int                     downloadTotal;
+
+    TQWidget                *parent;
+
+    TQTimer                 *timer;
+
+    CameraThread           *thread;
+
+    DKCamera               *camera;
+
+    MTQueue<CameraCommand>  cmdQueue;
+};
+
+class CameraThread : public TQThread
+{
+public:
+
+    CameraThread(CameraController* controller);
+    ~CameraThread();
+
+    void sendBusy(bool busy);
+    void sendError(const TQString& msg);
+    void sendInfo(const TQString& msg);
+
+protected:
+
+    void run();
+
+private:
+
+    CameraControllerPriv *d;
+
+    TQObject              *parent;
+};
+
+CameraThread::CameraThread(CameraController* controller)
+            : d(controller->d), parent(controller)
+{
+}
+
+CameraThread::~CameraThread()
+{
+}
+
+void CameraThread::run()
+{
+    if (d->close)
+        return;
+
+    sendBusy(true);
+
+    CameraCommand* cmd = d->cmdQueue.dequeue();
+    if (cmd)
+    {
+        switch (cmd->action)
+        {
+            case(CameraCommand::gp_connect):
+            {
+                sendInfo(i18n("Connecting to camera..."));
+
+                bool result = d->camera->doConnect();
+    
+                CameraEvent* event = new CameraEvent(CameraEvent::gp_connected);
+                event->result = result;
+                TQApplication::postEvent(parent, event);
+    
+                if (result)
+                    sendInfo(i18n("Connection established"));
+                else
+                    sendInfo(i18n("Connection failed"));
+    
+                break;
+            }
+            case(CameraCommand::gp_cameraInformations):
+            {
+                sendInfo(i18n("Getting camera information..."));
+            
+                TQString summary, manual, about;
+
+                d->camera->cameraSummary(summary);
+                d->camera->cameraManual(manual);
+                d->camera->cameraAbout(about);
+            
+                CameraEvent* event = new CameraEvent(CameraEvent::gp_cameraInformations);
+                event->map.insert("summary", TQVariant(summary));
+                event->map.insert("manual", TQVariant(manual));
+                event->map.insert("about", TQVariant(about));
+                TQApplication::postEvent(parent, event);
+                break;
+            }            
+            case(CameraCommand::gp_listfolders):
+            {
+                sendInfo(i18n("Listing folders..."));
+    
+                TQStringList folderList;
+                folderList.append(d->camera->path());
+                d->camera->getAllFolders(d->camera->path(), folderList);
+    
+                /* TODO: ugly hack since qt <= 3.1.2 does not define
+                TQStringList with TQDeepCopy as a friend. */
+                TQValueList<TQString> flist(folderList);
+                
+                CameraEvent* event = new CameraEvent(CameraEvent::gp_listedfolders);
+                event->map.insert("folders", TQVariant(flist));
+                TQApplication::postEvent(parent, event);
+            
+                sendInfo(i18n("The folders have been listed."));
+    
+                break;
+            }
+            case(CameraCommand::gp_listfiles):
+            {
+                TQString folder = cmd->map["folder"].asString();
+                
+                sendInfo(i18n("The files in %1 have been listed.").arg(folder));
+    
+                GPItemInfoList itemsList;
+                // setting getImageDimensions to false is a huge speedup for UMSCamera
+                if (!d->camera->getItemsInfoList(folder, itemsList, false))
+                {
+                    sendError(i18n("Failed to list files in %1").arg(folder));
+                }
+    
+                if (!itemsList.isEmpty())
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_listedfiles);
+                    event->map.insert("folder", TQVariant(folder));
+                    
+                    TQByteArray  ba;
+                    TQDataStream ds(ba, IO_WriteOnly);
+                    ds << itemsList;
+                    
+                    event->map.insert("files", TQVariant(ba));
+                    TQApplication::postEvent(parent, event);
+                }
+    
+                sendInfo(i18n("Listing files in %1 is complete").arg(folder));
+                
+                break;
+            }
+            case(CameraCommand::gp_thumbnail):
+            {
+                TQString folder = cmd->map["folder"].asString();
+                TQString file   = cmd->map["file"].asString();
+    
+                sendInfo(i18n("Getting thumbnails..."));
+    
+                TQImage thumbnail;
+                d->camera->getThumbnail(folder, file, thumbnail);
+    
+                if (!thumbnail.isNull())
+                {
+                    thumbnail = thumbnail.smoothScale(ThumbnailSize::Huge, ThumbnailSize::Huge, TQImage::ScaleMin);
+            
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_thumbnailed);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    event->map.insert("thumbnail", TQVariant(thumbnail));
+                    TQApplication::postEvent(parent, event);
+                }
+    
+                break;
+            }
+            case(CameraCommand::gp_exif):
+            {
+                TQString folder = cmd->map["folder"].asString();
+                TQString file   = cmd->map["file"].asString();
+
+                sendInfo(i18n("Getting EXIF information for %1/%2...").arg(folder).arg(file));
+
+                char* edata = 0;
+                int   esize = 0;
+                d->camera->getExif(folder, file, &edata, esize);
+
+                if (edata || esize)
+                {
+                    TQByteArray  ba;
+                    TQDataStream ds(ba, IO_WriteOnly);
+                    ds.writeRawBytes(edata, esize);
+                    delete [] edata;
+
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_exif);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    event->map.insert("exifSize", TQVariant(esize));
+                    event->map.insert("exifData", TQVariant(ba));
+                    TQApplication::postEvent(parent, event);
+                }
+                break;
+            }
+            case(CameraCommand::gp_download):
+            {
+                TQString   folder            = cmd->map["folder"].asString();
+                TQString   file              = cmd->map["file"].asString();
+                TQString   dest              = cmd->map["dest"].asString();
+                bool      autoRotate        = cmd->map["autoRotate"].asBool();
+                bool      fixDateTime       = cmd->map["fixDateTime"].asBool();
+                TQDateTime newDateTime       = cmd->map["newDateTime"].asDateTime();
+                bool      setPhotographerId = cmd->map["setPhotographerId"].asBool();
+                TQString   author            = cmd->map["author"].asString();
+                TQString   authorTitle       = cmd->map["authorTitle"].asString();
+                bool      setCredits        = cmd->map["setCredits"].asBool();
+                TQString   credit            = cmd->map["credit"].asString();
+                TQString   source            = cmd->map["source"].asString();
+                TQString   copyright         = cmd->map["copyright"].asString();
+                bool      convertJpeg       = cmd->map["convertJpeg"].asBool();
+                TQString   losslessFormat    = cmd->map["losslessFormat"].asString();
+                sendInfo(i18n("Downloading file %1...").arg(file));
+
+                // download to a temp file
+
+                CameraEvent* event = new CameraEvent(CameraEvent::gp_downloadstarted);
+                event->map.insert("folder", TQVariant(folder));
+                event->map.insert("file", TQVariant(file));
+                event->map.insert("dest", TQVariant(dest));
+                TQApplication::postEvent(parent, event);
+
+                KURL tempURL(dest);
+                tempURL      = tempURL.upURL();
+                tempURL.addPath( TQString(".digikam-camera-tmp1-%1").arg(getpid()).append(file));
+                DDebug() << "Downloading: " << file << " using (" << tempURL.path() << ")" << endl;
+                TQString temp = tempURL.path();
+
+                bool result  = d->camera->downloadItem(folder, file, tempURL.path());
+
+                if (result && isJpegImage(tempURL.path()))
+                {
+                    if (autoRotate)
+                    {
+                        DDebug() << "Exif autorotate: " << file << " using (" << tempURL.path() << ")" << endl;
+                        sendInfo(i18n("EXIF rotating file %1...").arg(file));
+                        exifRotate(tempURL.path(), file);
+                    }
+
+                    if (fixDateTime || setPhotographerId || setCredits)
+                    {
+                        DDebug() << "Set Metadata from: " << file << " using (" << tempURL.path() << ")" << endl;
+                        sendInfo(i18n("Setting Metadata tags to file %1...").arg(file));
+                        DMetadata metadata(tempURL.path());
+
+                        if (fixDateTime)
+                            metadata.setImageDateTime(newDateTime, true);
+
+                        if (setPhotographerId)
+                            metadata.setImagePhotographerId(author, authorTitle);
+
+                        if (setCredits)
+                            metadata.setImageCredits(credit, source, copyright);
+
+                        metadata.applyChanges();
+                    }
+
+                    // Convert Jpeg file to lossless format if necessary, 
+                    // and move converted image to destination.
+
+                    if (convertJpeg)
+                    {
+                        DDebug() << "Convert to LossLess: " << file << " using (" << tempURL.path() << ")" << endl;
+                        sendInfo(i18n("Converting %1 to lossless file format...").arg(file));
+
+                        KURL tempURL2(dest);
+                        tempURL2 = tempURL2.upURL();
+                        tempURL2.addPath( TQString(".digikam-camera-tmp2-%1").arg(getpid()).append(file));
+                        temp     = tempURL2.path();
+
+                        if (!jpegConvert(tempURL.path(), tempURL2.path(), file, losslessFormat))
+                        {
+                            // convert failed. delete the temp file
+                            unlink(TQFile::encodeName(tempURL.path()));
+                            unlink(TQFile::encodeName(tempURL2.path()));
+                            result = false;
+                        }
+                        else
+                        {
+                            // Else remove only the first temp file.
+                            unlink(TQFile::encodeName(tempURL.path()));
+                        }
+                    }
+                }
+
+                if (result)
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_downloaded);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    event->map.insert("dest", TQVariant(dest));
+                    event->map.insert("temp", TQVariant(temp));
+                    TQApplication::postEvent(parent, event);
+                }
+                else
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_downloadFailed);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    event->map.insert("dest", TQVariant(dest));
+                    TQApplication::postEvent(parent, event);
+                }
+                break;
+            }
+            case(CameraCommand::gp_open):
+            {
+                TQString folder = cmd->map["folder"].asString();
+                TQString file   = cmd->map["file"].asString();
+                TQString dest   = cmd->map["dest"].asString();
+    
+                sendInfo(i18n("Retrieving file %1 from camera...").arg(file));
+    
+                bool result = d->camera->downloadItem(folder, file, dest);
+    
+                if (result)
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_opened);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    event->map.insert("dest", TQVariant(dest));
+                    TQApplication::postEvent(parent, event);
+                }
+                else
+                {
+                    sendError(i18n("Failed to retrieve file %1 from camera").arg(file));
+                }                
+                break;
+            }
+            case(CameraCommand::gp_upload):
+            {                
+                TQString folder = cmd->map["destFolder"].asString();
+    
+                // We will using the same source file name to create the dest file 
+                // name in camera.
+                TQString file   = cmd->map["destFile"].asString();
+                
+                // The source file path to download in camera.
+                TQString src    = cmd->map["srcFilePath"].asString();
+    
+                sendInfo(i18n("Uploading file %1 to camera...").arg(file));
+    
+                GPItemInfo itemsInfo;
+
+                bool result = d->camera->uploadItem(folder, file, src, itemsInfo);
+    
+                if (result)
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_uploaded);
+                    TQByteArray  ba;
+                    TQDataStream ds(ba, IO_WriteOnly);
+                    ds << itemsInfo;                    
+                    event->map.insert("info", TQVariant(ba));
+
+                    TQApplication::postEvent(parent, event);
+                }
+                else
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_uploadFailed);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    event->map.insert("src", TQVariant(src));
+                    TQApplication::postEvent(parent, event);
+                }                
+                break;
+            }
+            case(CameraCommand::gp_delete):
+            {
+                TQString folder = cmd->map["folder"].asString();
+                TQString file   = cmd->map["file"].asString();
+    
+                sendInfo(i18n("Deleting file %1...").arg(file));
+    
+                bool result = d->camera->deleteItem(folder, file);
+    
+                if (result)
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_deleted);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    TQApplication::postEvent(parent, event);
+                }
+                else
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_deleteFailed);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    TQApplication::postEvent(parent, event);
+                }                
+                break;
+            }
+            case(CameraCommand::gp_lock):
+            {
+                TQString folder = cmd->map["folder"].asString();
+                TQString file   = cmd->map["file"].asString();
+                bool    lock   = cmd->map["lock"].asBool();
+    
+                sendInfo(i18n("Toggle lock file %1...").arg(file));
+    
+                bool result = d->camera->setLockItem(folder, file, lock);
+    
+                if (result)
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_locked);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    TQApplication::postEvent(parent, event);
+                }
+                else
+                {
+                    CameraEvent* event = new CameraEvent(CameraEvent::gp_lockFailed);
+                    event->map.insert("folder", TQVariant(folder));
+                    event->map.insert("file", TQVariant(file));
+                    TQApplication::postEvent(parent, event);
+                }                
+                break;
+            }
+            default:
+                DWarning() << k_funcinfo << " unknown action specified" << endl;
+        }    
+
+        delete cmd;
+    }
+
+    sendBusy(false);
+}
+
+void CameraThread::sendBusy(bool val)
+{
+    CameraEvent* event = new CameraEvent(CameraEvent::gp_busy);
+    event->result = val;
+    TQApplication::postEvent(parent, event);
+}
+
+void CameraThread::sendError(const TQString& msg)
+{
+    CameraEvent* event = new CameraEvent(CameraEvent::gp_errormsg);
+    event->msg = msg;
+    TQApplication::postEvent(parent, event);
+}
+
+void CameraThread::sendInfo(const TQString& msg)
+{
+    CameraEvent* event = new CameraEvent(CameraEvent::gp_infomsg);
+    event->msg = msg;
+    TQApplication::postEvent(parent, event);
+}
+
+
+//-- Camera Controller ------------------------------------------------------
+
+
+CameraController::CameraController(TQWidget* parent, const TQString& title, const TQString& model,
+                                   const TQString& port, const TQString& path)
+                : TQObject(parent)
+{
+    d = new CameraControllerPriv;   
+    d->parent        = parent;
+    d->canceled      = false;
+    d->close         = false;
+    d->overwriteAll  = false;
+    d->skipAll       = false;
+    d->downloadTotal = 0;
+    d->camera        = 0;
+
+    // URL parsing (c) Stephan Kulow
+    if (path.startsWith("camera:/"))
+    {
+        KURL url(path);
+        DDebug() << "path " << path << " " << url <<  " " << url.host() << endl;
+        TQString xport = url.host();
+        if (xport.startsWith("usb:"))
+        {
+            DDebug() << "xport " << xport << endl;
+            TQRegExp x = TQRegExp("(usb:[0-9,]*)");
+
+            if (x.search(xport) != -1) 
+            {
+                TQString usbport = x.cap(1);
+                DDebug() << "USB " << xport << " " << usbport << endl;
+                // if ((xport == usbport) || ((count == 1) && (xport == "usb:"))) {
+                //   model = xmodel;
+                d->camera = new GPCamera(title, url.user(), "usb:", "/");
+                // }
+            }
+        }
+    }
+
+    if (!d->camera)
+    {
+        if (model.lower() == "directory browse")
+            d->camera = new UMSCamera(title, model, port, path);
+        else
+            d->camera = new GPCamera(title, model, port, path);
+    }
+
+    d->thread = new CameraThread(this);
+    d->timer  = new TQTimer(this);
+
+    connect(d->timer, TQ_SIGNAL(timeout()),
+            this, TQ_SLOT(slotProcessNext()));
+
+    d->timer->start(50, false);
+}
+
+CameraController::~CameraController()
+{
+    if (d->timer->isActive()) 
+    {
+        d->timer->stop();
+        delete d->timer;
+    }
+    
+    d->camera->cancel();
+    d->canceled = true;
+    d->close    = true;
+
+    while (d->thread->running())
+        d->thread->wait();
+        
+    delete d->thread;
+    delete d->camera;
+    delete d;
+}
+
+TQString CameraController::getCameraPath()
+{
+    if (!d->camera) return TQString();
+    return d->camera->path();
+}
+
+TQString CameraController::getCameraTitle()
+{
+    if (!d->camera) return TQString();
+    return d->camera->title();
+}
+
+void CameraController::slotConnect()
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_connect;
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::listFolders()
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_listfolders;
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::listFiles(const TQString& folder)
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_listfiles;
+    cmd->map.insert("folder", TQVariant(folder));
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::getThumbnail(const TQString& folder, const TQString& file)
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_thumbnail;
+    cmd->map.insert("folder", TQVariant(folder));
+    cmd->map.insert("file", TQVariant(file));
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::getExif(const TQString& folder, const TQString& file)
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_exif;
+    cmd->map.insert("folder", TQVariant(folder));
+    cmd->map.insert("file", TQVariant(file));
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::getCameraInformations()
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_cameraInformations;
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::upload(const TQFileInfo& srcFileInfo, const TQString& destFile, const TQString& destFolder)
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_upload;
+    cmd->map.insert("srcFilePath", TQVariant(srcFileInfo.filePath()));
+    cmd->map.insert("destFile", TQVariant(destFile));
+    cmd->map.insert("destFolder", TQVariant(destFolder));
+    d->cmdQueue.enqueue(cmd);
+    DDebug() << "Uploading '" << srcFileInfo.filePath() << "' into camera : '" << destFolder << 
+                 "' (" << destFile << ")" << endl;
+}
+
+void CameraController::downloadPrep()
+{
+    d->overwriteAll  = false;
+    d->skipAll       = false;
+    d->downloadTotal = 0;
+}
+
+void CameraController::download(DownloadSettingsContainer downloadSettings)
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_download;
+    cmd->map.insert("folder", TQVariant(downloadSettings.folder));
+    cmd->map.insert("file", TQVariant(downloadSettings.file));
+    cmd->map.insert("dest", TQVariant(downloadSettings.dest));
+    cmd->map.insert("autoRotate", TQVariant(downloadSettings.autoRotate));
+    cmd->map.insert("fixDateTime", TQVariant(downloadSettings.fixDateTime));
+    cmd->map.insert("newDateTime", TQVariant(downloadSettings.newDateTime));
+    cmd->map.insert("setPhotographerId", TQVariant(downloadSettings.setPhotographerId));
+    cmd->map.insert("author", TQVariant(downloadSettings.author));
+    cmd->map.insert("authorTitle", TQVariant(downloadSettings.authorTitle));
+    cmd->map.insert("setCredits", TQVariant(downloadSettings.setCredits));
+    cmd->map.insert("credit", TQVariant(downloadSettings.credit));
+    cmd->map.insert("source", TQVariant(downloadSettings.source));
+    cmd->map.insert("copyright", TQVariant(downloadSettings.copyright));
+    cmd->map.insert("convertJpeg", TQVariant(downloadSettings.convertJpeg));
+    cmd->map.insert("losslessFormat", TQVariant(downloadSettings.losslessFormat));
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::deleteFile(const TQString& folder, const TQString& file)
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_delete;
+    cmd->map.insert("folder", TQVariant(folder));
+    cmd->map.insert("file", TQVariant(file));
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::lockFile(const TQString& folder, const TQString& file, bool lock)
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_lock;
+    cmd->map.insert("folder", TQVariant(folder));
+    cmd->map.insert("file", TQVariant(file));
+    cmd->map.insert("lock", TQVariant(lock));
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::openFile(const TQString& folder, const TQString& file)
+{
+    d->canceled = false;
+    CameraCommand *cmd = new CameraCommand;
+    cmd->action = CameraCommand::gp_open;
+    cmd->map.insert("folder", TQVariant(folder));
+    cmd->map.insert("file", TQVariant(file));
+    cmd->map.insert("dest", TQVariant(locateLocal("tmp", file)));
+    d->cmdQueue.enqueue(cmd);
+}
+
+void CameraController::slotCancel()
+{
+    d->canceled = true;
+    d->cmdQueue.flush();   
+    d->camera->cancel();
+}
+
+void CameraController::customEvent(TQCustomEvent* e)
+{
+    CameraEvent* event = dynamic_cast<CameraEvent*>(e);
+    if (!event)
+    {
+        return;
+    }
+    
+    switch(event->type()-TQEvent::User)
+    {
+        case (CameraEvent::gp_connected) :
+        {
+            emit signalConnected(event->result);
+            break;
+        }
+        case (CameraEvent::gp_cameraInformations) :
+        {
+            TQString summary = TQDeepCopy<TQString>(event->map["summary"].asString());
+            TQString manual  = TQDeepCopy<TQString>(event->map["manual"].asString());
+            TQString about   = TQDeepCopy<TQString>(event->map["about"].asString());
+            emit signalCameraInformations(summary, manual, about);
+            break;
+        }
+        case (CameraEvent::gp_errormsg) :
+        {
+            emit signalErrorMsg(TQDeepCopy<TQString>(event->msg));
+            break;
+        }
+        case (CameraEvent::gp_busy) :
+        {
+            if (event->result)
+                emit signalBusy(true);
+            break;
+        }
+        case (CameraEvent::gp_infomsg) :
+        {
+            if (!d->canceled)
+                emit signalInfoMsg(TQDeepCopy<TQString>(event->msg));
+            break;
+        }
+        case (CameraEvent::gp_listedfolders) :
+        {
+            /* TODO: ugly hack since qt <= 3.1.2 does not define
+            TQStringList with TQDeepCopy as a friend. */
+            TQValueList<TQVariant> flist = TQDeepCopy< TQValueList<TQVariant> >(event->map["folders"].toList());
+    
+            TQStringList folderList;
+            TQValueList<TQVariant>::Iterator it;
+            for (it = flist.begin(); it != flist.end(); ++it )
+            {
+                folderList.append(TQDeepCopy<TQString>((*it).asString()));
+            }
+            
+            emit signalFolderList(folderList);
+            break;
+        }
+        case (CameraEvent::gp_listedfiles) :
+        {
+            TQString    folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQByteArray ba     = TQDeepCopy<TQByteArray>(event->map["files"].asByteArray());
+            TQDataStream ds(ba, IO_ReadOnly);
+            GPItemInfoList items;
+            ds >> items;
+            emit signalFileList(items);
+            break;
+        }
+        case (CameraEvent::gp_thumbnailed) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+            TQImage  thumb  = TQDeepCopy<TQImage>(event->map["thumbnail"].asImage());
+            emit signalThumbnail(folder, file, thumb);
+            break;
+        }
+        case (CameraEvent::gp_exif) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+            TQByteArray ba  = TQDeepCopy<TQByteArray>(event->map["exifData"].asByteArray());
+            emit signalExifData(ba);
+            break;
+        }
+        case (CameraEvent::gp_downloadstarted) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+            emit signalDownloaded(folder, file, GPItemInfo::DownloadStarted);
+            break;
+        }
+        case (CameraEvent::gp_downloaded) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+            TQString dest   = TQDeepCopy<TQString>(event->map["dest"].asString());
+            TQString temp   = TQDeepCopy<TQString>(event->map["temp"].asString());
+
+            d->timer->stop();
+
+            bool skip      = false;
+            bool cancel    = false;
+            bool overwrite = false;
+
+            // Check if dest file already exist.
+
+            if (!d->overwriteAll)
+            {
+                TQFileInfo info(dest);
+
+                while (info.exists())
+                {
+                    if (d->skipAll)
+                    {
+                        skip = true;
+                        break;
+                    }
+
+                    TDEIO::RenameDlg dlg(d->parent, i18n("Rename File"),
+                                       folder + TQString("/") + file, dest,
+                                       TDEIO::RenameDlg_Mode(TDEIO::M_MULTI | TDEIO::M_OVERWRITE | TDEIO::M_SKIP));
+
+                    int result = dlg.exec();
+                    dest       = dlg.newDestURL().path();
+                    info       = TQFileInfo(dest);
+
+                    switch (result)
+                    {
+                        case TDEIO::R_CANCEL:
+                        {
+                            cancel = true;
+                            break;
+                        }
+                        case TDEIO::R_SKIP:
+                        {
+                            skip = true;
+                            break;
+                        }
+                        case TDEIO::R_AUTO_SKIP:
+                        {
+                            d->skipAll = true;
+                            skip       = true;
+                            break;
+                        }
+                        case TDEIO::R_OVERWRITE:
+                        {
+                            overwrite = true;
+                            break;
+                        }
+                        case TDEIO::R_OVERWRITE_ALL:
+                        {
+                            d->overwriteAll = true;
+                            overwrite       = true;
+                            break;
+                        }
+                        default:
+                            break;
+                    }
+
+                    if (cancel || skip || overwrite)
+                        break;
+                }
+            }
+
+            if (cancel)
+            {
+                unlink(TQFile::encodeName(temp));
+                slotCancel();
+                d->timer->start(50);
+                emit signalSkipped(folder, file);
+                return;
+            }
+            else if (skip)
+            {
+                unlink(TQFile::encodeName(temp));
+                d->timer->start(50);
+                emit signalInfoMsg(i18n("Skipped file %1").arg(file));
+                emit signalSkipped(folder, file);
+                return;
+            }
+
+            // move the file to the destination file
+            if (rename(TQFile::encodeName(temp), TQFile::encodeName(dest)) != 0)
+            {
+                // rename failed. delete the temp file
+                unlink(TQFile::encodeName(temp));
+                d->timer->start(50);
+                emit signalDownloaded(folder, file, GPItemInfo::DownloadFailed);
+            }
+            else
+            {
+                d->timer->start(50);
+                emit signalDownloaded(folder, file, GPItemInfo::DownloadedYes);
+            }
+            break;
+        }
+        case (CameraEvent::gp_downloadFailed) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+
+            d->timer->stop();
+
+            TQString msg = i18n("Failed to download file \"%1\".").arg(file);
+
+            if (!d->canceled)
+            {
+                if (d->cmdQueue.isEmpty())
+                {
+                    KMessageBox::error(d->parent, msg);
+                }
+                else
+                {
+                    msg += i18n(" Do you want to continue?");
+                    int result = KMessageBox::warningContinueCancel(d->parent, msg);
+                    if (result != KMessageBox::Continue)
+                        slotCancel();  
+                }
+            }
+
+            d->timer->start(50);
+            emit signalDownloaded(folder, file, GPItemInfo::DownloadFailed);
+            break;
+        }
+        case (CameraEvent::gp_uploaded) :
+        {
+            TQByteArray ba  = TQDeepCopy<TQByteArray>(event->map["info"].asByteArray());
+            TQDataStream ds(ba, IO_ReadOnly);
+            GPItemInfo itemInfo;
+            ds >> itemInfo;
+
+            emit signalUploaded(itemInfo);
+            break;
+        }
+        case (CameraEvent::gp_uploadFailed) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+            TQString src    = TQDeepCopy<TQString>(event->map["src"].asString());
+
+            d->timer->stop();
+
+            TQString msg = i18n("Failed to upload file \"%1\".").arg(file);
+
+            if (!d->canceled)
+            {
+                if (d->cmdQueue.isEmpty())
+                {
+                    KMessageBox::error(d->parent, msg);
+                }
+                else
+                {
+                    msg += i18n(" Do you want to continue?");
+                    int result = KMessageBox::warningContinueCancel(d->parent, msg);
+                    if (result != KMessageBox::Continue)
+                        slotCancel();
+                }
+            }
+
+            d->timer->start(50);
+            break;
+        }
+        case (CameraEvent::gp_deleted) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+            emit signalDeleted(folder, file, true);
+            break;
+        }
+        case (CameraEvent::gp_deleteFailed) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+
+            d->timer->stop();
+            emit signalDeleted(folder, file, false);
+
+            TQString msg = i18n("Failed to delete file \"%1\".").arg(file);
+
+            if (!d->canceled)
+            {
+                if (d->cmdQueue.isEmpty())
+                {
+                    KMessageBox::error(d->parent, msg);
+                }
+                else
+                {
+                    msg += i18n(" Do you want to continue?");
+                    int result = KMessageBox::warningContinueCancel(d->parent, msg);
+                    if (result != KMessageBox::Continue)
+                        slotCancel();
+                }
+            }
+
+            d->timer->start(50);
+            break;
+        }
+        case (CameraEvent::gp_locked) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+            emit signalLocked(folder, file, true);
+            break;
+        }
+        case (CameraEvent::gp_lockFailed) :
+        {
+            TQString folder = TQDeepCopy<TQString>(event->map["folder"].asString());
+            TQString file   = TQDeepCopy<TQString>(event->map["file"].asString());
+
+            d->timer->stop();
+            emit signalLocked(folder, file, false);
+
+            TQString msg = i18n("Failed to toggle lock file \"%1\".").arg(file);
+
+            if (!d->canceled)
+            {
+                if (d->cmdQueue.isEmpty())
+                {
+                    KMessageBox::error(d->parent, msg);
+                }
+                else
+                {
+                    msg += i18n(" Do you want to continue?");
+                    int result = KMessageBox::warningContinueCancel(d->parent, msg);
+                    if (result != KMessageBox::Continue)
+                        slotCancel();
+                }
+            }
+
+            d->timer->start(50);
+            break;
+        }
+        case (CameraEvent::gp_opened) :
+        {
+            TQString file = TQDeepCopy<TQString>(event->map["file"].asString());
+            TQString dest = TQDeepCopy<TQString>(event->map["dest"].asString());
+
+            KURL url(dest);
+            KURL::List urlList;
+            urlList << url;
+
+            ImageWindow *im = ImageWindow::imagewindow();
+            im->loadURL(urlList, url, i18n("Camera \"%1\"").arg(d->camera->model()), false);
+
+            if (im->isHidden())
+                im->show();
+            else
+                im->raise();
+
+            im->setFocus();
+            break;
+        }
+        default:
+        {
+            DWarning() << k_funcinfo << "Unknown event" << endl;
+        }
+    }
+}
+
+void CameraController::slotProcessNext()
+{
+    if (d->thread->running())
+        return;
+
+    if (d->cmdQueue.isEmpty())
+    {
+        emit signalBusy(false);
+        return;
+    }
+
+    d->timer->stop();
+    emit signalBusy(true);
+
+    CameraCommand* cmd = d->cmdQueue.head();
+
+    TQString folder;
+    TQString file;
+    TQString dest;
+
+    if ((cmd->action == CameraCommand::gp_exif) &&
+        (typeid(*(d->camera)) == typeid(UMSCamera)))
+    {
+        folder = TQDeepCopy<TQString>(cmd->map["folder"].asString());
+        file   = TQDeepCopy<TQString>(cmd->map["file"].asString());
+
+        emit signalExifFromFile(folder, file);
+
+        d->cmdQueue.dequeue();
+        d->timer->start(50, false);
+        return;
+    }
+
+    if (cmd->action == CameraCommand::gp_download)
+    {
+        folder = TQDeepCopy<TQString>(cmd->map["folder"].asString());
+        file   = TQDeepCopy<TQString>(cmd->map["file"].asString());
+        dest   = TQDeepCopy<TQString>(cmd->map["dest"].asString());
+        cmd->map["dest"] = TQVariant(TQDeepCopy<TQString>(dest));
+    }
+
+    d->thread->start();
+    d->timer->start(50, false);
+}
+
+}  // namespace Digikam