+#include <Swift/Controllers/FileTransfer/FileTransferController.h>

+#include <Swiften/Base/foreach.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIEvents/SendFileUIEvent.h>

+

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider), eventStream_(eventStream) {

+ chatWindow_->onFileTransferStart.connect(boost::bind(&ChatController::handleFileTransferStart, this, _1, _2));

+ chatWindow_->onFileTransferAccept.connect(boost::bind(&ChatController::handleFileTransferAccept, this, _1, _2));

+ chatWindow_->onFileTransferCancel.connect(boost::bind(&ChatController::handleFileTransferCancel, this, _1));

+ chatWindow_->onSendFileRequest.connect(boost::bind(&ChatController::handleSendFileRequest, this, _1));

+void ChatController::handleNewFileTransferController(FileTransferController* ftc) {

+ std::string nick = senderDisplayNameFromMessage(ftc->getOtherParty());

+ std::string ftID = ftc->setChatWindow(chatWindow_, nick);

+

+ ftControllers[ftID] = ftc;

+}

+

+void ChatController::handleFileTransferCancel(std::string id) {

+ std::cout << "handleFileTransferCancel(" << id << ")" << std::endl;

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->cancel();

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+}

+

+void ChatController::handleFileTransferStart(std::string id, std::string description) {

+ std::cout << "handleFileTransferStart(" << id << ", " << description << ")" << std::endl;

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->start(description);

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+}

+

+void ChatController::handleFileTransferAccept(std::string id, std::string filename) {

+ std::cout << "handleFileTransferAccept(" << id << ", " << filename << ")" << std::endl;

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->accept(filename);

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+}

+

+void ChatController::handleSendFileRequest(std::string filename) {

+ std::cout << "ChatController::handleSendFileRequest(" << filename << ")" << std::endl;

+ eventStream_->send(boost::make_shared<SendFileUIEvent>(getToJID(), filename));

+}

+

+#include <map>

+#include <string>

+

+ class FileTransferController;

+ virtual void handleNewFileTransferController(FileTransferController* ftc);

+ void handleFileTransferCancel(std::string /* id */);

+ void handleFileTransferStart(std::string /* id */, std::string /* description */);

+ void handleFileTransferAccept(std::string /* id */, std::string /* filename */);

+ void handleSendFileRequest(std::string filename);

+

+ UIEventStream* eventStream_;

+

+ std::map<std::string, FileTransferController*> ftControllers;

+#include <Swift/Controllers/FileTransfer/FileTransferController.h>

+#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

+ ProfileSettingsProvider* settings,

+ FileTransferOverview* ftOverview) :

+ mucManager(mucManager),

+ ftOverview_(ftOverview) {

+ ftOverview_->onNewFileTransferController.connect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));

+void ChatsManager::handleNewFileTransferController(FileTransferController* ftc) {

+ ChatController* chatController = getChatControllerOrCreate(ftc->getOtherParty());

+ chatController->handleNewFileTransferController(ftc);

+ chatController->activateChatWindow();

+}

+

+ class FileTransferOverview;

+ class FileTransferController;

+

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* settings, FileTransferOverview* ftOverview);

+ void handleNewFileTransferController(FileTransferController*);

+ FileTransferOverview* ftOverview_;

+#include <boost/bind.hpp>

+

+#include "Swiften/Jingle/JingleSessionManager.h"

+#include "Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h"

+#include "Swift/Controllers/FileTransfer/FileTransferOverview.h"

+#include <Swiften/Base/Algorithm.h>

+ ftManager_ = new DummyFileTransferManager();

+ ftOverview_ = new FileTransferOverview(ftManager_);

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_);

+ //delete chatListWindowFactory

+ delete ftOverview_;

+ delete ftManager_;

+ FileTransferOverview* ftOverview_;

+ FileTransferManager* ftManager_;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "FileTransferController.h"

+#include "Swiften/FileTransfer/OutgoingJingleFileTransfer.h"

+#include "Swiften/FileTransfer/FileTransferManager.h"

+#include <Swiften/FileTransfer/FileReadBytestream.h>

+#include <Swiften/Base/boost_bsignals.h>

+#include <boost/bind.hpp>

+#include "Swift/Controllers/UIInterfaces/ChatWindow.h"

+

+#include <boost/smart_ptr/make_shared.hpp>

+

+namespace Swift {

+

+FileTransferController::FileTransferController(const JID& receipient, const std::string& filename, FileTransferManager* fileTransferManager) :

+ sending(true), otherParty(receipient), filename(filename), ftManager(fileTransferManager), ftProgressInfo(0), chatWindow(0), currentState(FileTransfer::State::WaitingForStart) {

+

+}

+

+FileTransferController::FileTransferController(IncomingFileTransfer::ref transfer) :

+ sending(false), otherParty(transfer->getSender()), filename(transfer->filename), transfer(transfer), ftManager(0), ftProgressInfo(0), chatWindow(0), currentState(FileTransfer::State::WaitingForStart) {

+

+}

+

+FileTransferController::~FileTransferController() {

+ delete ftProgressInfo;

+}

+

+const JID &FileTransferController::getOtherParty() const {

+ return otherParty;

+}

+

+std::string FileTransferController::setChatWindow(ChatWindow* wnd, std::string nickname) {

+ chatWindow = wnd;

+ if (sending) {

+ uiID = wnd->addFileTransfer("me", true, filename, boost::filesystem::file_size(boost::filesystem::path(filename)));

+ } else {

+ uiID = wnd->addFileTransfer(nickname, false, filename, transfer->fileSizeInBytes);

+ }

+ return uiID;

+}

+

+void FileTransferController::setReceipient(const JID& receipient) {

+ this->otherParty = receipient;

+}

+

+bool FileTransferController::isIncoming() const {

+ return !sending;

+}

+

+FileTransfer::State FileTransferController::getState() const {

+ return currentState;

+}

+

+int FileTransferController::getProgress() const {

+ return ftProgressInfo ? ftProgressInfo->getPercentage() : 0;

+}

+

+boost::uintmax_t FileTransferController::getSize() const {

+ if (transfer) {

+ return transfer->fileSizeInBytes;

+ } else {

+ return 0;

+ }

+}

+

+void FileTransferController::start(std::string& description) {

+ std::cout << "FileTransferController::start" << std::endl;

+ fileReadStream = boost::make_shared<FileReadBytestream>(boost::filesystem::path(filename));

+ OutgoingFileTransfer::ref outgoingTransfer = ftManager->createOutgoingFileTransfer(otherParty, boost::filesystem::path(filename), description, fileReadStream);

+ if (outgoingTransfer) {

+ ftProgressInfo = new FileTransferProgressInfo(outgoingTransfer->fileSizeInBytes);

+ ftProgressInfo->onProgressPercentage.connect(boost::bind(&FileTransferController::handleProgressPercentageChange, this, _1));

+ outgoingTransfer->onStateChange.connect(boost::bind(&FileTransferController::handleFileTransferStateChange, this, _1));

+ outgoingTransfer->onProcessedBytes.connect(boost::bind(&FileTransferProgressInfo::setBytesProcessed, ftProgressInfo, _1));

+ outgoingTransfer->start();

+ transfer = outgoingTransfer;

+ } else {

+ std::cerr << "File transfer not supported!" << std::endl;

+ }

+}

+

+void FileTransferController::accept(std::string& file) {

+ std::cout << "FileTransferController::accept" << std::endl;

+ IncomingFileTransfer::ref incomingTransfer = boost::dynamic_pointer_cast<IncomingFileTransfer>(transfer);

+ if (incomingTransfer) {

+ fileWriteStream = boost::make_shared<FileWriteBytestream>(boost::filesystem::path(file));

+

+ ftProgressInfo = new FileTransferProgressInfo(transfer->fileSizeInBytes);

+ ftProgressInfo->onProgressPercentage.connect(boost::bind(&FileTransferController::handleProgressPercentageChange, this, _1));

+ transfer->onStateChange.connect(boost::bind(&FileTransferController::handleFileTransferStateChange, this, _1));

+ transfer->onProcessedBytes.connect(boost::bind(&FileTransferProgressInfo::setBytesProcessed, ftProgressInfo, _1));

+ incomingTransfer->accept(fileWriteStream);

+ } else {

+ std::cerr << "Expected an incoming transfer in this situation!" << std::endl;

+ }

+}

+

+void FileTransferController::cancel() {

+ if (transfer) {

+ transfer->cancel();

+ } else {

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Canceled);

+ }

+}

+

+void FileTransferController::handleFileTransferStateChange(FileTransfer::State state) {

+ currentState = state;

+ onStateChage();

+ switch(state.state) {

+ case FileTransfer::State::Negotiating:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Negotiating);

+ return;

+ case FileTransfer::State::Transferring:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Transferring);

+ return;

+ case FileTransfer::State::Canceled:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Canceled);

+ return;

+ case FileTransfer::State::Finished:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Finished);

+ if (fileWriteStream) {

+ fileWriteStream->close();

+ }

+ return;

+ case FileTransfer::State::Failed:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::FTFailed);

+ return;

+ case FileTransfer::State::WaitingForAccept:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::WaitingForAccept);

+ return;

+ case FileTransfer::State::WaitingForStart:

+ return;

+ }

+ std::cerr << "Unhandled FileTransfer::State!" << std::endl;

+}

+

+void FileTransferController::handleProgressPercentageChange(int percentage) {

+ onProgressChange();

+ chatWindow->setFileTransferProgress(uiID, percentage);

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/JID/JID.h>

+#include <Swiften/FileTransfer/FileTransfer.h>

+#include <Swiften/FileTransfer/IncomingFileTransfer.h>

+#include <Swiften/FileTransfer/FileReadBytestream.h>

+#include <Swiften/FileTransfer/FileWriteBytestream.h>

+#include <Swift/Controllers/FileTransfer/FileTransferProgressInfo.h>

+

+namespace Swift {

+

+class FileTransferManager;

+class ChatWindow;

+

+class FileTransferController {

+public:

+ /**

+ * For outgoing file transfers. It'll create a file transfer via FileTransferManager as soon as the descriptive information is available.

+ */

+ FileTransferController(const JID&, const std::string&, FileTransferManager*);

+

+ /**

+ * For incoming file transfers.

+ */

+ FileTransferController(IncomingFileTransfer::ref transfer);

+ ~FileTransferController();

+

+ std::string setChatWindow(ChatWindow*, std::string nickname);

+ void setReceipient(const JID& otherParty);

+

+ void start(std::string& description);

+ void accept(std::string& file);

+ void cancel();

+

+ const JID &getOtherParty() const;

+ bool isIncoming() const;

+ FileTransfer::State getState() const;

+ int getProgress() const;

+ boost::uintmax_t getSize() const;

+

+ boost::signal<void ()> onStateChage;

+ boost::signal<void ()> onProgressChange;

+

+private:

+ void handleFileTransferStateChange(FileTransfer::State);

+ void handleProgressPercentageChange(int percentage);

+

+private:

+ bool sending;

+ JID otherParty;

+ std::string filename;

+ FileTransfer::ref transfer;

+ boost::shared_ptr<FileReadBytestream> fileReadStream;

+ boost::shared_ptr<FileWriteBytestream> fileWriteStream;

+ FileTransferManager* ftManager;

+ FileTransferProgressInfo* ftProgressInfo;

+ ChatWindow* chatWindow;

+ std::string uiID;

+ FileTransfer::State currentState;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "FileTransferOverview.h"

+

+#include <boost/bind.hpp>

+#include <Swiften/Base/boost_bsignals.h>

+

+#include <Swiften/FileTransfer/FileTransferManager.h>

+

+namespace Swift {

+

+FileTransferOverview::FileTransferOverview(FileTransferManager* ftm) : fileTransferManager(ftm) {

+ fileTransferManager->onIncomingFileTransfer.connect(boost::bind(&FileTransferOverview::handleIncomingFileTransfer, this, _1));

+}

+

+FileTransferOverview::~FileTransferOverview() {

+

+}

+

+void FileTransferOverview::sendFile(const JID& jid, const std::string& filename) {

+ FileTransferController* controller = new FileTransferController(jid, filename, fileTransferManager);

+ fileTransfers.push_back(controller);

+

+ onNewFileTransferController(controller);

+}

+

+void FileTransferOverview::handleIncomingFileTransfer(IncomingFileTransfer::ref transfer) {

+ FileTransferController* controller = new FileTransferController(transfer);

+ fileTransfers.push_back(controller);

+ onNewFileTransferController(controller);

+}

+

+const std::vector<FileTransferController*>& FileTransferOverview::getFileTransfers() const {

+ return fileTransfers;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+

+#include "Swift/Controllers/FileTransfer/FileTransferController.h"

+

+#include <Swiften/Base/boost_bsignals.h>

+

+namespace Swift {

+

+class ChatsManager;

+class FileTransferManager;

+

+class FileTransferOverview {

+public:

+ FileTransferOverview(FileTransferManager*);

+ ~FileTransferOverview();

+

+ void sendFile(const JID&, const std::string&);

+ const std::vector<FileTransferController*>& getFileTransfers() const;

+

+ boost::signal<void (FileTransferController*)> onNewFileTransferController;

+

+private:

+ void handleIncomingFileTransfer(IncomingFileTransfer::ref transfer);

+

+private:

+ std::vector<FileTransferController*> fileTransfers;

+ FileTransferManager *fileTransferManager;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "FileTransferProgressInfo.h"

+

+#include <Swiften/Base/Log.h>

+

+namespace Swift {

+

+FileTransferProgressInfo::FileTransferProgressInfo(boost::uintmax_t completeBytes) : completeBytes(completeBytes), completedBytes(0), percentage(0) {

+ onProgressPercentage(0);

+}

+

+void FileTransferProgressInfo::setBytesProcessed(int processedBytes) {

+ int oldPercentage = int(double(completedBytes) / double(completeBytes) * 100.0);

+ completedBytes += processedBytes;

+ int newPercentage = int(double(completedBytes) / double(completeBytes) * 100.0);

+ if (oldPercentage != newPercentage) {

+ onProgressPercentage(newPercentage);

+ }

+ percentage = newPercentage;

+}

+

+int FileTransferProgressInfo::getPercentage() const {

+ return percentage;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Base/boost_bsignals.h>

+

+namespace Swift {

+

+class FileTransferProgressInfo {

+public:

+ FileTransferProgressInfo(boost::uintmax_t completeBytes);

+

+public:

+ void setBytesProcessed(int processedBytes);

+

+ int getPercentage() const;

+ boost::signal<void (int)> onProgressPercentage;

+

+private:

+ boost::uintmax_t completeBytes;

+ boost::uintmax_t completedBytes;

+ int percentage;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "SOCKS5BytestreamProxyFinder.h"

+

+#include <boost/smart_ptr/make_shared.hpp>

+#include <boost/bind.hpp>

+

+#include <Swiften/Base/Log.h>

+#include <Swiften/Elements/S5BProxyRequest.h>

+#include <Swiften/Queries/GenericRequest.h>

+#include <Swiften/Queries/IQRouter.h>

+

+namespace Swift {

+

+SOCKS5BytestreamProxyFinder::SOCKS5BytestreamProxyFinder(const JID& service, IQRouter *iqRouter) : iqRouter(iqRouter) {

+ serviceWalker = boost::make_shared<DiscoServiceWalker>(service, iqRouter);

+ serviceWalker->onServiceFound.connect(boost::bind(&SOCKS5BytestreamProxyFinder::handleServiceFound, this, _1, _2));

+}

+

+void SOCKS5BytestreamProxyFinder::start() {

+ serviceWalker->beginWalk();

+}

+

+void SOCKS5BytestreamProxyFinder::sendBytestreamQuery(const JID& jid) {

+ S5BProxyRequest::ref proxyRequest = boost::make_shared<S5BProxyRequest>();

+ boost::shared_ptr<GenericRequest<S5BProxyRequest> > request = boost::make_shared<GenericRequest<S5BProxyRequest> >(IQ::Get, jid, proxyRequest, iqRouter);

+ request->onResponse.connect(boost::bind(&SOCKS5BytestreamProxyFinder::handleProxyResponse, this, _1, _2));

+ request->send();

+}

+

+void SOCKS5BytestreamProxyFinder::handleServiceFound(const JID& jid, boost::shared_ptr<DiscoInfo> discoInfo) {

+ if (discoInfo->hasFeature(DiscoInfo::Bytestream)) {

+ sendBytestreamQuery(jid);

+ }

+}

+

+void SOCKS5BytestreamProxyFinder::handleProxyResponse(boost::shared_ptr<S5BProxyRequest> request, ErrorPayload::ref error) {

+ if (error) {

+ SWIFT_LOG(debug) << "ERROR" << std::endl;

+ } else {

+ if (request) {

+ onProxyFound(request);

+ } else {

+ //assert(false);

+ }

+ }

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swift/Controllers/DiscoServiceWalker.h>

+#include <Swiften/Network/HostAddressPort.h>

+#include <Swiften/Elements/S5BProxyRequest.h>

+

+namespace Swift {

+

+class JID;

+class IQRouter;

+

+class SOCKS5BytestreamProxyFinder {

+public:

+ SOCKS5BytestreamProxyFinder(const JID& service, IQRouter *iqRouter);

+ void start();

+

+ boost::signal<void(boost::shared_ptr<S5BProxyRequest>)> onProxyFound;

+

+private:

+ void sendBytestreamQuery(const JID&);

+

+ void handleServiceFound(const JID&, boost::shared_ptr<DiscoInfo>);

+ void handleProxyResponse(boost::shared_ptr<S5BProxyRequest>, ErrorPayload::ref);

+private:

+ boost::shared_ptr<DiscoServiceWalker> serviceWalker;

+ IQRouter* iqRouter;

+ std::vector<boost::shared_ptr<GenericRequest<S5BProxyRequest> > > requests;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "Swift/Controllers/FileTransferListController.h"

+

+#include <boost/bind.hpp>

+

+#include "Swift/Controllers/UIInterfaces/FileTransferListWidgetFactory.h"

+#include "Swift/Controllers/UIEvents/RequestFileTransferListUIEvent.h"

+

+namespace Swift {

+

+FileTransferListController::FileTransferListController(UIEventStream* uiEventStream, FileTransferListWidgetFactory* fileTransferListWidgetFactory) : fileTransferListWidgetFactory(fileTransferListWidgetFactory), fileTransferListWidget(NULL), fileTransferOverview(0) {

+ uiEventStream->onUIEvent.connect(boost::bind(&FileTransferListController::handleUIEvent, this, _1));

+}

+

+FileTransferListController::~FileTransferListController() {

+ delete fileTransferListWidget;

+}

+

+void FileTransferListController::setFileTransferOverview(FileTransferOverview *overview) {

+ fileTransferOverview = overview;

+ if (fileTransferListWidget) {

+ fileTransferListWidget->setFileTransferOverview(fileTransferOverview);

+ }

+}

+

+void FileTransferListController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

+ boost::shared_ptr<RequestFileTransferListUIEvent> event = boost::dynamic_pointer_cast<RequestFileTransferListUIEvent>(rawEvent);

+ if (event != NULL) {

+ if (fileTransferListWidget == NULL) {

+ fileTransferListWidget = fileTransferListWidgetFactory->createFileTransferListWidget();

+ if (fileTransferOverview) {

+ fileTransferListWidget->setFileTransferOverview(fileTransferOverview);

+ }

+ }

+ fileTransferListWidget->show();

+ fileTransferListWidget->activate();

+ }

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include "Swift/Controllers/UIEvents/UIEventStream.h"

+

+namespace Swift {

+

+class FileTransferListWidgetFactory;

+class FileTransferListWidget;

+class FileTransferOverview;

+

+class FileTransferListController {

+public:

+ FileTransferListController(UIEventStream* uiEventStream, FileTransferListWidgetFactory* fileTransferListWidgetFactory);

+ ~FileTransferListController();

+

+ void setFileTransferOverview(FileTransferOverview* overview);

+

+private:

+ void handleUIEvent(boost::shared_ptr<UIEvent> event);

+

+private:

+ FileTransferListWidgetFactory* fileTransferListWidgetFactory;

+ FileTransferListWidget* fileTransferListWidget;

+ FileTransferOverview* fileTransferOverview;

+};

+

+}

+#include "Swift/Controllers/FileTransferListController.h"

+#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

+#include <Swiften/FileTransfer/FileTransferManager.h>

+#include <Swiften/Client/ClientXMLTracer.h>

+ eagleMode_(eagleMode),

+ ftOverview_(NULL) {

+ fileTransferListController_ = new FileTransferListController(uiEventStream_, uiFactory_);

+

+ delete fileTransferListController_;

+ delete s5bProxyFinder_;

+ s5bProxyFinder_ = NULL;

+ delete ftOverview_;

+ ftOverview_ = NULL;

+ srand(time(NULL));

+ int randomPort = 10000 + rand() % 10000;

+ client_->getFileTransferManager()->startListeningOnPort(randomPort);

+ s5bProxyFinder_ = new SOCKS5BytestreamProxyFinder(client_->getJID().getDomain(), client_->getIQRouter());

+ s5bProxyFinder_->onProxyFound.connect(boost::bind(&FileTransferManager::addS5BProxy, client_->getFileTransferManager(), _1));

+ s5bProxyFinder_->start();

+ ftOverview_ = new FileTransferOverview(client_->getFileTransferManager());

+ fileTransferListController_->setFileTransferOverview(ftOverview_);

+ rosterController_ = new RosterController(jid_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), ftOverview_);

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_);

+

+ discoInfo.addFeature(DiscoInfo::JingleFeature);

+ discoInfo.addFeature(DiscoInfo::JingleFTFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsIBBFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsS5BFeature);

+#include "Swift/Controllers/FileTransfer/SOCKS5BytestreamProxyFinder.h"

+#include "Swiften/Client/ClientXMLTracer.h"

+ class FileTransferListController;

+ class FileTransferOverview;

+ FileTransferListController* fileTransferListController_;

+ FileTransferOverview* ftOverview_;

+ SOCKS5BytestreamProxyFinder* s5bProxyFinder_;

+void ContactRosterItem::setSupportedFeatures(const std::set<Feature>& features) {

+ features_ = features;

+}

+

+bool ContactRosterItem::supportsFeature(const Feature feat) const {

+ return features_.find(feat) != features_.end();

+}

+

+#include <set>

+ enum Feature {

+ FileTransferFeature,

+ };

+

+ public:

+

+ void setSupportedFeatures(const std::set<Feature>& features);

+ bool supportsFeature(Feature feat) const;

+ std::set<Feature> features_;

+#include <set>

+void Roster::setAvailableFeatures(const JID& jid, const std::set<ContactRosterItem::Feature>& features) {

+ if (itemMap_[fullJIDMapping_ ? jid : jid.toBare()].empty()) return;

+ foreach(ContactRosterItem* item, itemMap_[fullJIDMapping_ ? jid : jid.toBare()]) {

+ item->setSupportedFeatures(features);

+ }

+}

+

+ ContactRosterItem *item = new ContactRosterItem(jid, displayJID, name, group);

+#include <Swift/Controllers/Roster/ContactRosterItem.h>

+ void setAvailableFeatures(const JID& jid, const std::set<ContactRosterItem::Feature>& features);

+

+#include "Swift/Controllers/UIEvents/SendFileUIEvent.h"

+#include <Swiften/FileTransfer/FileTransferManager.h>

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/Disco/EntityCapsManager.h>

+#include <Swiften/Jingle/JingleSessionManager.h>

+RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, FileTransferOverview* fileTransferOverview)

+ : myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), nickManager_(nickManager), nickResolver_(nickResolver), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), ftOverview_(fileTransferOverview) {

+ assert(fileTransferOverview);

+

+ entityCapsManager_->onCapsChanged.connect(boost::bind(&RosterController::handleOnCapsChanged, this, _1));

+RosterController::~RosterController() {

+

+

+ else if (boost::shared_ptr<SendFileUIEvent> sendFileEvent = boost::dynamic_pointer_cast<SendFileUIEvent>(event)) {

+ //TODO add send file dialog to ChatView of receipient jid

+ ftOverview_->sendFile(sendFileEvent->getJID(), sendFileEvent->getFilename());

+ }

+void RosterController::handleOnCapsChanged(const JID& jid) {

+ DiscoInfo::ref info = entityCapsManager_->getCaps(jid);

+ if (info) {

+ std::set<ContactRosterItem::Feature> features;

+ if (info->hasFeature(DiscoInfo::JingleFeature) && info->hasFeature(DiscoInfo::JingleFTFeature) && info->hasFeature(DiscoInfo::JingleTransportsIBBFeature)) {

+ features.insert(ContactRosterItem::FileTransferFeature);

+ }

+ roster_->setAvailableFeatures(jid, features);

+ }

+}

+

+#include <set>

+#include "Swift/Controllers/FileTransfer/FileTransferOverview.h"

+ class EntityCapsProvider;

+ class FileTransferManager;

+

+ RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter_, SettingsProvider* settings, EntityCapsProvider* entityCapsProvider, FileTransferOverview* fileTransferOverview);

+ void handleOnCapsChanged(const JID& jid);

+ EntityCapsProvider* entityCapsManager_;

+ FileTransferOverview* ftOverview_;

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <Swiften/Disco/EntityCapsManager.h>

+#include <Swiften/Disco/CapsProvider.h>

+#include <Swiften/Jingle/JingleSessionManager.h>

+#include <Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h>

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/EventLoop/DummyEventLoop.h>

+class DummyCapsProvider : public CapsProvider {

+ DiscoInfo::ref getCaps(const std::string&) const {return DiscoInfo::ref(new DiscoInfo());}

+};

+

+ capsProvider_ = new DummyCapsProvider();

+ entityCapsManager_ = new EntityCapsManager(capsProvider_, stanzaChannel_);

+ jingleSessionManager_ = new JingleSessionManager(router_);

+

+ ftManager_ = new DummyFileTransferManager();

+ ftOverview_ = new FileTransferOverview(ftManager_);

+ rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickManager_, nickResolver_, presenceOracle_, subscriptionManager_, eventController_, uiEventStream_, router_, settings_, entityCapsManager_, ftOverview_);

+ delete ftManager_;

+ delete jingleSessionManager_;

+

+ DummyCapsProvider* capsProvider_;

+ EntityCapsManager* entityCapsManager_;

+ JingleSessionManager* jingleSessionManager_;

+ FileTransferManager* ftManager_;

+ FileTransferOverview* ftOverview_;

+ "FileTransfer/FileTransferController.cpp",

+ "FileTransfer/FileTransferOverview.cpp",

+ "FileTransfer/FileTransferProgressInfo.cpp",

+ "FileTransfer/SOCKS5BytestreamProxyFinder.cpp",

+ "FileTransferListController.cpp",

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+

+class RequestFileTransferListUIEvent : public UIEvent {

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+

+#include <Swiften/JID/JID.h>

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+ class SendFileUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<SendFileUIEvent> ref;

+

+ SendFileUIEvent(const JID& jid, const std::string& filename) : jid(jid), filename(filename) {

+ }

+

+ const JID& getJID() const {

+ return jid;

+ }

+

+ const std::string& getFilename() const {

+ return filename;

+ }

+

+ private:

+ JID jid;

+ std::string filename;

+ };

+}

+ class FileTransferController;

+ enum FileTransferState {WaitingForAccept, Negotiating, Transferring, Canceled, Finished, FTFailed};

+

+ // File transfer related stuff

+ virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) = 0;

+ virtual void setFileTransferProgress(std::string, const int percentageDone) = 0;

+ virtual void setFileTransferStatus(std::string, const FileTransferState state, const std::string& msg = "") = 0;

+

+ // File transfer related

+ boost::signal<void (std::string /* id */)> onFileTransferCancel;

+ boost::signal<void (std::string /* id */, std::string /* description */)> onFileTransferStart;

+ boost::signal<void (std::string /* id */, std::string /* path */)> onFileTransferAccept;

+ boost::signal<void (std::string /* path */)> onSendFileRequest;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+namespace Swift {

+

+class FileTransferOverview;

+

+class FileTransferListWidget {

+public:

+ virtual ~FileTransferListWidget() {}

+

+ virtual void show() = 0;

+ virtual void activate() = 0;

+

+ virtual void setFileTransferOverview(FileTransferOverview*) = 0;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include "Swift/Controllers/UIInterfaces/FileTransferListWidget.h"

+

+namespace Swift {

+

+class FileTransferListWidgetFactory {

+public:

+ virtual ~FileTransferListWidgetFactory() {}

+

+ virtual FileTransferListWidget* createFileTransferListWidget() = 0;

+};

+

+}

+#include <Swift/Controllers/UIInterfaces/FileTransferListWidgetFactory.h>

+ public XMLConsoleWidgetFactory,

+ public AdHocCommandWindowFactory,

+ public FileTransferListWidgetFactory {

+ // File transfer related stuff

+ virtual std::string addFileTransfer(const std::string& /*senderName*/, bool /*senderIsSelf*/,const std::string& /*filename*/, const boost::uintmax_t /*sizeInBytes*/) { return 0; };

+ virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { };

+ virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { };

+

+ void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}

+#include <Swiften/Base/Log.h>

+

+ setAcceptDrops(true);

+ webPage_->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);

+void QtChatView::addToJSEnvironment(const QString& name, QObject* obj) {

+ webView_->page()->currentFrame()->addToJavaScriptWindowObject(name, obj);

+}

+

+QWebElement findDivElementWithID(QWebElement document, QString id) {

+ QWebElementCollection divs = document.findAll("div");

+ foreach(QWebElement div, divs) {

+ if (div.attribute("id") == id) {

+ return div;

+ }

+ }

+ return QWebElement();

+}

+

+void QtChatView::setFileTransferProgress(QString id, const int percentageDone) {

+ QWebElement ftElement = findDivElementWithID(document_, id);

+ if (ftElement.isNull()) {

+ SWIFT_LOG(debug) << "Tried to access FT UI via invalid id!" << std::endl;

+ return;

+ }

+ QWebElement progressBar = ftElement.findFirst("div.progressbar");

+ progressBar.setStyleProperty("width", QString::number(percentageDone) + "%");

+

+ QWebElement progressBarValue = ftElement.findFirst("div.progressbar-value");

+ progressBarValue.setInnerXml(QString::number(percentageDone) + " %");

+}

+

+void QtChatView::setFileTransferStatus(QString id, const ChatWindow::FileTransferState state, const QString& /* msg */) {

+ QWebElement ftElement = findDivElementWithID(document_, id);

+ if (ftElement.isNull()) {

+ SWIFT_LOG(debug) << "Tried to access FT UI via invalid id! id = " << id.toStdString() << std::endl;

+ return;

+ }

+

+ QString newInnerHTML = "";

+ if (state == ChatWindow::WaitingForAccept) {

+ newInnerHTML = "Waiting for other side to accept the transfer.<br/>"

+ "<input id=\"discard\" type=\"submit\" value=\"Cancel\" onclick=\"filetransfer.cancel(\'" + id + "\');\">";

+ }

+ if (state == ChatWindow::Negotiating) {

+ // replace with text "Negotiaging" + Cancel button

+ newInnerHTML = "Negotiating...<br/>"

+ "<input id=\"discard\" type=\"submit\" value=\"Cancel\" onclick=\"filetransfer.cancel(\'" + id + "\');\">";

+ }

+ else if (state == ChatWindow::Transferring) {

+ // progress bar + Cancel Button

+ newInnerHTML = "<div style=\"position: relative; width: 90%; height: 20px; border: 2px solid grey; -webkit-border-radius: 10px;\">"

+ "<div class=\"progressbar\" style=\"width: 0%; height: 100%; background: #AAA; -webkit-border-radius: 6px;\">"

+ "<div class=\"progressbar-value\" style=\"position: absolute; top: 0px; left: 0px; width: 100%; text-align: center; padding-top: 2px;\">"

+ "0%"

+ "</div>"

+ "</div>"

+ "</div>"

+ "<input id=\"discard\" type=\"submit\" value=\"Cancel\" onclick=\"filetransfer.cancel(\'" + id + "\');\">";

+ }

+ else if (state == ChatWindow::Canceled) {

+ newInnerHTML = "Transfer has been canceled!";

+ }

+ else if (state == ChatWindow::Finished) {

+ // text "Successful transfer"

+ newInnerHTML = "Transfer completed successfully.";

+ }

+ else if (state == ChatWindow::FTFailed) {

+ newInnerHTML = "Transfer failed.";

+ }

+

+ ftElement.setInnerXml(newInnerHTML);

+}

+

+#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

+

+ void addToJSEnvironment(const QString&, QObject*);

+ void setFileTransferProgress(QString id, const int percentageDone);

+ void setFileTransferStatus(QString id, const ChatWindow::FileTransferState state, const QString& msg);

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIEvents/SendFileUIEvent.h>

+#include "QtFileTransferJSBridge.h"

+

+#include <boost/format.hpp>

+#include <boost/lexical_cast.hpp>

+#include <QInputDialog>

+#include <QFileDialog>

+

+#include <QDebug>

+QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageWasSystem_(false), previousMessageWasPresence_(false), previousMessageWasFileTransfer_(false), eventStream_(eventStream) {

+ setAcceptDrops(true);

+

+

+ fileTransferJS = new QtFileTransferJSBridge();

+ messageLog_->addToJSEnvironment("filetransfer", fileTransferJS);

+ connect(fileTransferJS, SIGNAL(setDescription(QString)), this, SLOT(handleFileTransferSetDescription(QString)));

+ connect(fileTransferJS, SIGNAL(sendRequest(QString)), this, SLOT(handleFileTransferStart(QString)));

+ connect(fileTransferJS, SIGNAL(acceptRequest(QString, QString)), this, SLOT(handleFileTransferAccept(QString, QString)));

+ connect(fileTransferJS, SIGNAL(cancel(QString)), this, SLOT(handleFileTransferCancel(QString)));

+ delete fileTransferJS;

+

+ setAcceptDrops(false);

+ bool appendToPrevious = !previousMessageWasFileTransfer_ && !previousMessageWasSystem_ && !previousMessageWasPresence_ && ((senderIsSelf && previousMessageWasSelf_) || (!senderIsSelf && !previousMessageWasSelf_ && previousSenderName_ == P2QSTRING(senderName)));

+ previousMessageWasFileTransfer_ = false;

+std::string formatSize(const uintmax_t bytes) {

+ static const char *siPrefix[] = {"k", "M", "G", "T", "P", "E", "Z", "Y", NULL};

+ int power = 0;

+ double engBytes = bytes;

+ while (engBytes >= 1000) {

+ ++power;

+ engBytes = engBytes / 1000.0;

+ }

+ return str( boost::format("%.1lf %sB") % engBytes % (power > 0 ? siPrefix[power-1] : "") );

+}

+

+std::string QtChatWindow::addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) {

+ qDebug() << "addFileTransfer";

+ std::string ft_id = id_.generateID();

+

+ std::string htmlString;

+ if (senderIsSelf) {

+ // outgoing

+ htmlString = "Send file: " + filename + " ( " + formatSize(sizeInBytes) + ") </br>" +

+ "<div id='" + ft_id + "'>" +

+ "<input id='discard' type='submit' value='Cancel' onclick='filetransfer.cancel(\"" + ft_id + "\");' />" +

+ "<input id='description' type='submit' value='Set Description' onclick='filetransfer.setDescription(\"" + ft_id + "\");' />" +

+ "<input id='send' type='submit' value='Send' onclick='filetransfer.sendRequest(\"" + ft_id + "\");' />" +

+ "</div>";

+ } else {

+ // incoming

+ htmlString = "Receiving file: " + filename + " ( " + formatSize(sizeInBytes) + ") </br>" +

+ "<div id='" + ft_id + "'>" +

+ "<input id='discard' type='submit' value='Cancel' onclick='filetransfer.cancel(\"" + ft_id + "\");' />" +

+ "<input id='accept' type='submit' value='Accept' onclick='filetransfer.acceptRequest(\"" + ft_id + "\", \"" + filename + "\");' />" +

+ "</div>";

+ }

+

+ //addMessage(message, senderName, senderIsSelf, boost::shared_ptr<SecurityLabel>(), "", boost::posix_time::second_clock::local_time());

+

+ bool appendToPrevious = !previousMessageWasFileTransfer_ && !previousMessageWasSystem_ && !previousMessageWasPresence_ && ((senderIsSelf && previousMessageWasSelf_) || (!senderIsSelf && !previousMessageWasSelf_ && previousSenderName_ == P2QSTRING(senderName)));

+ if (lastLineTracker_.getShouldMoveLastLine()) {

+ /* should this be queued? */

+ messageLog_->addLastSeenLine();

+ /* if the line is added we should break the snippet */

+ appendToPrevious = false;

+ }

+ QString qAvatarPath = "qrc:/icons/avatar.png";

+ std::string id = id_.generateID();

+ messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new MessageSnippet(QString::fromStdString(htmlString), Qt::escape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

+

+

+ return ft_id;

+}

+

+void QtChatWindow::setFileTransferProgress(std::string id, const int percentageDone) {

+ messageLog_->setFileTransferProgress(QString::fromStdString(id), percentageDone);

+}

+

+void QtChatWindow::setFileTransferStatus(std::string id, const FileTransferState state, const std::string& msg) {

+ messageLog_->setFileTransferStatus(QString::fromStdString(id), state, QString::fromStdString(msg));

+}

+

+void QtChatWindow::handleFileTransferCancel(QString id) {

+ qDebug() << "QtChatWindow::handleFileTransferCancel(" << id << ")";

+ onFileTransferCancel(id.toStdString());

+}

+

+void QtChatWindow::handleFileTransferSetDescription(QString id) {

+ bool ok = false;

+ QString text = QInputDialog::getText(this, tr("File transfer description"),

+ tr("Description:"), QLineEdit::Normal, "", &ok);

+ if (ok) {

+ descriptions[id] = text;

+ }

+}

+

+void QtChatWindow::handleFileTransferStart(QString id) {

+ qDebug() << "QtChatWindow::handleFileTransferStart(" << id << ")";

+

+ QString text = descriptions.find(id) == descriptions.end() ? QString() : descriptions[id];

+ onFileTransferStart(id.toStdString(), text.toStdString());

+}

+

+void QtChatWindow::handleFileTransferAccept(QString id, QString filename) {

+ qDebug() << "QtChatWindow::handleFileTransferAccept(" << id << ", " << filename << ")";

+

+ QString path = QFileDialog::getSaveFileName(this, tr("Save File"), filename);

+ if (!path.isEmpty()) {

+ onFileTransferAccept(id.toStdString(), path.toStdString());

+ }

+}

+

+ previousMessageWasFileTransfer_ = false;

+ previousMessageWasFileTransfer_ = false;

+void QtChatWindow::dragEnterEvent(QDragEnterEvent *event) {

+ if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() == 1) {

+ // TODO: check whether contact actually supports file transfer

+ event->acceptProposedAction();

+ }

+}

+

+void QtChatWindow::dropEvent(QDropEvent *event) {

+ if (event->mimeData()->urls().size() == 1) {

+ onSendFileRequest(event->mimeData()->urls().at(0).toLocalFile().toStdString());

+ } else {

+ addSystemMessage("Sending of multiple files at once isn't supported at this time.");

+ }

+}

+

+#include <map>

+

+ class QtFileTransferJSBridge;

+ // File transfer related stuff

+ std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes);

+ void setFileTransferProgress(std::string id, const int percentageDone);

+ void setFileTransferStatus(std::string id, const FileTransferState state, const std::string& msg);

+

+ void dragEnterEvent(QDragEnterEvent *event);

+ void dropEvent(QDropEvent *event);

+

+

+

+ void handleFileTransferCancel(QString id);

+ void handleFileTransferSetDescription(QString id);

+ void handleFileTransferStart(QString id);

+ void handleFileTransferAccept(QString id, QString filename);

+

+ bool previousMessageWasFileTransfer_;

+

+ std::map<QString, QString> descriptions;

+ QtFileTransferJSBridge* fileTransferJS;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "QtFileTransferJSBridge.h"

+

+namespace Swift {

+

+QtFileTransferJSBridge::QtFileTransferJSBridge() {

+

+}

+

+QtFileTransferJSBridge::~QtFileTransferJSBridge() {

+

+}

+

+} \ No newline at end of file

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <QObject>

+

+#include <map>

+

+namespace Swift {

+

+class FileTransferController;

+

+class QtFileTransferJSBridge : public QObject {

+ Q_OBJECT

+public:

+ QtFileTransferJSBridge();

+ virtual ~QtFileTransferJSBridge();

+signals:

+ void discard(QString id);

+ void sendRequest(QString id);

+ void setDescription(QString id);

+ void acceptRequest(QString id, QString filename);

+ void cancel(QString id);

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "QtFileTransferListItemModel.h"

+

+#include <boost/bind.hpp>

+

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swift/Controllers/FileTransfer/FileTransferController.h>

+#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

+

+namespace Swift {

+

+extern std::string formatSize(const uintmax_t bytes);

+

+QtFileTransferListItemModel::QtFileTransferListItemModel(QObject *parent) : QAbstractItemModel(parent), fileTransferOverview(0) {

+}

+

+void QtFileTransferListItemModel::setFileTransferOverview(FileTransferOverview *overview) {

+ fileTransferOverview = overview;

+ fileTransferOverview->onNewFileTransferController.connect(boost::bind(&QtFileTransferListItemModel::handleNewFileTransferController, this, _1));

+}

+

+void QtFileTransferListItemModel::handleNewFileTransferController(FileTransferController* newController) {

+ emit layoutAboutToBeChanged();

+ emit layoutChanged();

+ dataChanged(createIndex(0,0), createIndex(fileTransferOverview->getFileTransfers().size(),4));

+ newController->onStateChage.connect(boost::bind(&QtFileTransferListItemModel::handleStateChange, this, fileTransferOverview->getFileTransfers().size() - 1));

+ newController->onProgressChange.connect(boost::bind(&QtFileTransferListItemModel::handleProgressChange, this, fileTransferOverview->getFileTransfers().size() - 1));

+}

+

+void QtFileTransferListItemModel::handleStateChange(int index) {

+ emit dataChanged(createIndex(index, 2), createIndex(index, 2));

+}

+

+void QtFileTransferListItemModel::handleProgressChange(int index) {

+ emit dataChanged(createIndex(index, 3), createIndex(index, 3));

+}

+

+QVariant QtFileTransferListItemModel::headerData(int section, Qt::Orientation /* orientation */, int role) const {

+ if (role != Qt::DisplayRole) return QVariant();

+ if (section == Direction) return QVariant("Direction");

+ if (section == OtherParty) return QVariant("Other Party");

+ if (section == State) return QVariant("State");

+ if (section == Progress) return QVariant("Progress");

+ if (section == OverallSize) return QVariant("Size");

+ return QVariant();

+}

+

+int QtFileTransferListItemModel::columnCount(const QModelIndex& /* parent */) const {

+ return NoOfColumns;

+}

+

+QVariant QtFileTransferListItemModel::data(const QModelIndex &index, int role) const {

+ if (role != Qt::DisplayRole || !index.isValid() ||

+ !fileTransferOverview || static_cast<size_t>(index.row()) >= fileTransferOverview->getFileTransfers().size()) {

+ return QVariant();

+ }

+ FileTransferController* controller = fileTransferOverview->getFileTransfers().at(index.row());

+ if (index.column() == Direction) {

+ return controller->isIncoming() ? QVariant("Incoming") : QVariant("Outgoing");

+ }

+ if (index.column() == OtherParty) {

+ return QVariant(QString::fromStdString(controller->getOtherParty().toString()));

+ }

+ if (index.column() == State) {

+ FileTransfer::State state = controller->getState();

+ switch(state.state) {

+ case FileTransfer::State::WaitingForStart:

+ return QVariant("Waiting for start");

+ case FileTransfer::State::WaitingForAccept:

+ return QVariant("Waiting for other side to accept");

+ case FileTransfer::State::Negotiating:

+ return QVariant("Negotiating");

+ case FileTransfer::State::Transferring:

+ return QVariant("Transferring");

+ case FileTransfer::State::Finished:

+ return QVariant("Finished");

+ case FileTransfer::State::Failed:

+ return QVariant("Failed");

+ case FileTransfer::State::Canceled:

+ return QVariant("Canceled");

+ }

+ }

+

+ if (index.column() == Progress) {

+ return QVariant(QString::number(controller->getProgress()));

+ }

+ if (index.column() == OverallSize) {

+ return QVariant(QString::fromStdString(formatSize((controller->getSize()))));

+ }

+ return QVariant();

+}

+

+QModelIndex QtFileTransferListItemModel::parent(const QModelIndex& /* child */) const {

+ return createIndex(0,0);

+}

+

+int QtFileTransferListItemModel::rowCount(const QModelIndex& /* parent */) const {

+ return fileTransferOverview ? fileTransferOverview->getFileTransfers().size() : 0;

+}

+

+QModelIndex QtFileTransferListItemModel::index(int row, int column, const QModelIndex& /* parent */) const {

+ return createIndex(row, column, 0);

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <QAbstractItemModel>

+

+namespace Swift {

+

+class FileTransferController;

+class FileTransferOverview;

+

+class QtFileTransferListItemModel : public QAbstractItemModel {

+ Q_OBJECT

+public:

+ explicit QtFileTransferListItemModel(QObject *parent = 0);

+

+ void setFileTransferOverview(FileTransferOverview*);

+

+ QVariant headerData(int section, Qt::Orientation orientation, int role) const;

+ int columnCount(const QModelIndex &parent) const;

+ QVariant data(const QModelIndex &index, int role) const;

+ QModelIndex parent(const QModelIndex &child) const;

+ int rowCount(const QModelIndex &parent) const;

+ QModelIndex index(int row, int column, const QModelIndex &parent) const;

+

+private:

+ enum Columns {

+ Direction = 0,

+ OtherParty,

+ State,

+ Progress,

+ OverallSize,

+ NoOfColumns,

+ };

+

+private:

+ void handleNewFileTransferController(FileTransferController*);

+ void handleStateChange(int index);

+ void handleProgressChange(int index);

+

+signals:

+

+public slots:

+

+private:

+ FileTransferOverview *fileTransferOverview;

+

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "QtFileTransferListWidget.h"

+

+#include <Swift/QtUI/QtFileTransferListItemModel.h>

+

+#include <QVBoxLayout>

+#include <QHBoxLayout>

+#include <QWidget>

+#include <QPushButton>

+

+namespace Swift {

+

+QtFileTransferListWidget::QtFileTransferListWidget() : fileTransferOverview(0) {

+ QVBoxLayout* layout = new QVBoxLayout(this);

+ layout->setSpacing(0);

+ layout->setContentsMargins(0,0,0,0);

+

+ treeView = new QTreeView(this);

+ treeView->setRootIsDecorated(false);

+ treeView->setItemsExpandable(false);

+ layout->addWidget(treeView);

+

+ itemModel = new QtFileTransferListItemModel();

+ treeView->setModel(itemModel);

+

+ QWidget* bottom = new QWidget(this);

+ layout->addWidget(bottom);

+ bottom->setAutoFillBackground(true);

+

+ QHBoxLayout* buttonLayout = new QHBoxLayout(bottom);

+ buttonLayout->setContentsMargins(10,0,20,0);

+ buttonLayout->setSpacing(0);

+

+ QPushButton* clearFinished = new QPushButton(tr("Clear Finished Transfers"), bottom);

+ clearFinished->setEnabled(false);

+ //connect(clearButton, SIGNAL(clicked()), textEdit, SLOT(clear()));

+ buttonLayout->addWidget(clearFinished);

+

+ setWindowTitle(tr("File Transfer List"));

+ emit titleUpdated();

+}

+

+QtFileTransferListWidget::~QtFileTransferListWidget() {

+ delete itemModel;

+}

+

+void QtFileTransferListWidget::showEvent(QShowEvent* event) {

+ emit windowOpening();

+ emit titleUpdated(); /* This just needs to be somewhere after construction */

+ QWidget::showEvent(event);

+}

+

+void QtFileTransferListWidget::show() {

+ QWidget::show();

+ emit windowOpening();

+}

+

+void QtFileTransferListWidget::activate() {

+ emit wantsToActivate();

+}

+

+void QtFileTransferListWidget::setFileTransferOverview(FileTransferOverview *overview) {

+ fileTransferOverview = overview;

+ itemModel->setFileTransferOverview(overview);

+}

+

+void QtFileTransferListWidget::closeEvent(QCloseEvent* event) {

+ emit windowClosing();

+ event->accept();

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include "Swift/Controllers/UIInterfaces/FileTransferListWidget.h"

+

+#include "QtTabbable.h"

+

+#include <QCloseEvent>

+#include <QShowEvent>

+#include <QTreeView>

+

+namespace Swift {

+

+class FileTransferOverview;

+class QtFileTransferListItemModel;

+

+class QtFileTransferListWidget : public QtTabbable, public FileTransferListWidget {

+ Q_OBJECT

+

+public:

+ QtFileTransferListWidget();

+ virtual ~QtFileTransferListWidget();

+

+ void show();

+ void activate();

+

+ void setFileTransferOverview(FileTransferOverview *);

+

+private:

+ virtual void closeEvent(QCloseEvent* event);

+ virtual void showEvent(QShowEvent* event);

+

+private:

+ QTreeView* treeView;

+

+ QtFileTransferListItemModel* itemModel;

+ FileTransferOverview* fileTransferOverview;

+};

+

+}

+#include <boost/smart_ptr/make_shared.hpp>

+#include "Swift/Controllers/UIEvents/RequestFileTransferListUIEvent.h"

+ fileTransferOverviewAction_ = new QAction(tr("Show &File Transfer Overview"), this);

+ connect(fileTransferOverviewAction_, SIGNAL(triggered()), SLOT(handleShowFileTransferOverview()));

+ generalMenu_->addAction(fileTransferOverviewAction_);

+

+void QtLoginWindow::handleShowFileTransferOverview() {

+ uiEventStream_->send(boost::make_shared<RequestFileTransferListUIEvent>());

+}

+

+ void handleShowFileTransferOverview();

+ QAction* fileTransferOverviewAction_;

+#include "QtFileTransferListWidget.h"

+FileTransferListWidget* QtUIFactory::createFileTransferListWidget() {

+ QtFileTransferListWidget* widget = new QtFileTransferListWidget();

+ tabs->addTab(widget);

+ if (!tabs->isVisible()) {

+ tabs->show();

+ }

+ widget->show();

+ return widget;

+}

+ virtual FileTransferListWidget* createFileTransferListWidget();

+

+ /*

+ }*/

+#include <Swiften/Client/XMLBeautifier.h>

+

+ beautifier = new XMLBeautifier(true, false);

+}

+

+QtXMLConsoleWidget::~QtXMLConsoleWidget() {

+ delete beautifier;

+ appendTextIfEnabled(std::string(tr("<!-- IN -->").toUtf8()) + "\n" + beautifier->beautify(safeByteArrayToString(data)) + "\n", QColor(33,98,33));

+ appendTextIfEnabled(std::string(tr("<!-- OUT -->").toUtf8()) + "\n" + beautifier->beautify(safeByteArrayToString(data)) + "\n", QColor(155,1,0));

+ class XMLBeautifier;

+

+ ~QtXMLConsoleWidget();

+ XMLBeautifier* beautifier;

+#include <QFileDialog>

+#include "Swift/Controllers/UIEvents/SendFileUIEvent.h"

+ QAction* sendFile = NULL;

+ if (contact->supportsFeature(ContactRosterItem::FileTransferFeature)) {

+ sendFile = contextMenu.addAction(tr("Send File"));

+ }

+ else if (result == sendFile) {

+ QString fileName = QFileDialog::getOpenFileName(this, tr("Send File"), "", tr("All Files (*);;"));

+ if (!fileName.isEmpty()) {

+ eventStream_->send(boost::make_shared<SendFileUIEvent>(contact->getJID(), fileName.toStdString()));

+ }

+ }

+#include <QUrl>

+

+#include "Swift/Controllers/UIEvents/SendFileUIEvent.h"

+ setAcceptDrops(true);

+void QtTreeWidget::dragEnterEvent(QDragEnterEvent *event) {

+ if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() == 1) {

+ event->acceptProposedAction();

+ }

+}

+

+void QtTreeWidget::dropEvent(QDropEvent *event) {

+ QModelIndex index = indexAt(event->pos());

+ if (index.isValid()) {

+ RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

+ if (ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item)) {

+ if (contact->supportsFeature(ContactRosterItem::FileTransferFeature)) {

+ QString filename = event->mimeData()->urls().at(0).toLocalFile();

+ if (!filename.isEmpty()) {

+ eventStream_->send(boost::make_shared<SendFileUIEvent>(contact->getJID(), filename.toStdString()));

+ }

+ }

+ }

+ }

+}

+

+void QtTreeWidget::dragMoveEvent(QDragMoveEvent* event) {

+ QModelIndex index = indexAt(event->pos());

+ if (index.isValid()) {

+ RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

+ if (ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item)) {

+ if (contact->supportsFeature(ContactRosterItem::FileTransferFeature)) {

+ event->accept();

+ return;

+ }

+ }

+ }

+ event->ignore();

+}

+

+#include <QDragEnterEvent>

+#include <QDropEvent>

+#include <QDragMoveEvent>

+ protected:

+ void dragEnterEvent(QDragEnterEvent* event);

+ void dropEvent(QDropEvent* event);

+ void dragMoveEvent(QDragMoveEvent* event);

+ "QtFileTransferListWidget.cpp",

+ "QtFileTransferListItemModel.cpp",

+ "QtFileTransferJSBridge.cpp",