+#include <Swift/Controllers/ScreenSharing/ScreenSharingController.h>

+#include <Swiften/ScreenSharing/IncomingScreenSharing.h>

+ ScreenSharingController* ssController,

+ ssController_(ssController),

+ ssController->onNewIncomingScreenSharing.connect(boost::bind(&ChatsManager::handleNewIncomingScreenSharing, this, _1));

+void ChatsManager::handleNewIncomingScreenSharing(boost::shared_ptr<IncomingScreenSharing> iss)

+{

+ ChatController* chatController = getChatControllerOrCreate(iss->getSender());

+// chatController->handleNewFileTransferController(ftc);

+ chatController->activateChatWindow();

+}

+

+ class ScreenSharingController;

+ class IncomingScreenSharing;

+ 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* profileSettings, FileTransferOverview* ftOverview, ScreenSharingController* ssController, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager);

+ void handleNewIncomingScreenSharing(boost::shared_ptr<IncomingScreenSharing> iss);

+ ScreenSharingController* ssController_;

+#include "Swift/Controllers/ScreenSharing/ScreenSharingController.h"

+ ftOverview_(NULL),

+ ssController_(NULL) {

+ delete ssController_;

+ ssController_ = NULL;

+ ssController_ = new ScreenSharingController(client_->getScreenSharingManager(), uiFactory_, networkFactories_->getTimerFactory());

+ 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_, ssController_);

+ 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_, ssController_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, NULL, whiteboardManager_);

+ // Screen sharing

+ discoInfo.addFeature(DiscoInfo::JingleRTPFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportRawUDPFeature);

+ discoInfo.addFeature(DiscoInfo::JingleScreenSharingFeature);

+ class ScreenSharingController;

+ ScreenSharingController* ssController_;

+ ScreenSharingFeature,

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

+#include "Swift/Controllers/ScreenSharing/ScreenSharingController.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, ScreenSharingController *ssController)

+ : 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), ssController_(ssController) {

+ else if (boost::shared_ptr<ShareScreenUIEvent> shareScreenEvent = boost::dynamic_pointer_cast<ShareScreenUIEvent>(event)) {

+ std::cout << "Create sharing: " << ssController_->createOugoingScreenSharing(shareScreenEvent->jid);

+ std::cout << std::endl;

+ }

+ if (info->hasFeature(DiscoInfo::JingleFeature)

+ && info->hasFeature(DiscoInfo::JingleRTPFeature)

+ && info->hasFeature(DiscoInfo::JingleTransportRawUDPFeature)

+ && info->hasFeature(DiscoInfo::JingleScreenSharingFeature)) {

+ features.insert(ContactRosterItem::ScreenSharingFeature);

+ }

+ class ScreenSharingController;

+ 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, ScreenSharingController* ssController);

+ ScreenSharingController* ssController_;

+ "WhiteboardManager.cpp",

+ "ScreenSharing/ScreenSharingController.cpp",

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+namespace Swift {

+ class Image;

+

+ class DesktopScreenGrabber {

+ public:

+ virtual ~DesktopScreenGrabber() {}

+

+ virtual Image grab() const = 0;

+ };

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "ScreenSharingController.h"

+

+#include <Swiften/ScreenSharing/ScreenSharingManager.h>

+#include <Swiften/ScreenSharing/IncomingScreenSharing.h>

+#include <Swiften/ScreenSharing/OutgoingScreenSharing.h>

+#include <Swiften/ScreenSharing/Image.h>

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

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

+#include "Swift/QtUI/ScreenSharing/QtDesktopScreenGrabber.h"

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

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

+

+#include <boost/bind.hpp>

+

+namespace Swift {

+

+ScreenSharingController::ScreenSharingController(ScreenSharingManager *screenSharingManager, RemoteScreenWindowFactory* remoteScreenViewerFactory, TimerFactory* timerFactory)

+ : screenSharingManager(screenSharingManager), remoteScreenWindowFactory(remoteScreenViewerFactory), remoteScreenWindow(0),

+ grabTimer(timerFactory->createTimer(500)), screenGrabber(new QtDesktopScreenGrabber)

+{

+ screenSharingManager->onIncomingScreenSharing.connect(boost::bind(&ScreenSharingController::handleIncomingScreenSharing, this, _1));

+ grabTimer->onTick.connect(boost::bind(&ScreenSharingController::handleGrabTimerTick, this));

+}

+

+ScreenSharingController::~ScreenSharingController()

+{

+ grabTimer->onTick.disconnect(boost::bind(&ScreenSharingController::handleGrabTimerTick, this));

+ delete remoteScreenWindow;

+}

+

+boost::shared_ptr<OutgoingScreenSharing> ScreenSharingController::createOugoingScreenSharing(const JID& to)

+{

+ if (!oss) {

+ oss = screenSharingManager->createOutgoingScreenSharing(to);

+ if (oss) {

+ oss->onReady.connect(boost::bind(&ScreenSharingController::handleOssReady, this));

+ oss->onFinished.connect(boost::bind(&ScreenSharingController::handleOutgoingFinished, this));

+ const Image& image = screenGrabber->grab();

+ oss->start(image.width, image.height);

+ }

+ return oss;

+ }

+ return boost::shared_ptr<OutgoingScreenSharing>();

+}

+

+void ScreenSharingController::handleIncomingScreenSharing(boost::shared_ptr<IncomingScreenSharing> incomingScreenSharing)

+{

+ if (iss) {

+ incomingScreenSharing->cancel();

+ } else {

+ iss = incomingScreenSharing;

+ iss->accept();

+ iss->onFinished.connect(boost::bind(&ScreenSharingController::handleIncomingFinished, this));

+ remoteScreenWindow = remoteScreenWindowFactory->createRemoteScreenViewer(iss);

+// onNewIncomingScreenSharing(iss);

+ }

+}

+

+void ScreenSharingController::handleGrabTimerTick()

+{

+ if (oss) {

+ grabTimer->start();

+ oss->addImage(screenGrabber->grab());

+ }

+}

+

+void ScreenSharingController::handleOssReady()

+{

+ handleGrabTimerTick();

+}

+

+void ScreenSharingController::handleIncomingFinished()

+{

+ iss->onFinished.disconnect(boost::bind(&ScreenSharingController::handleIncomingFinished, this));

+ iss.reset();

+ delete remoteScreenWindow;

+ remoteScreenWindow = 0;

+}

+

+void ScreenSharingController::handleOutgoingFinished()

+{

+ oss->onReady.disconnect(boost::bind(&ScreenSharingController::handleOssReady, this));

+ oss->onFinished.disconnect(boost::bind(&ScreenSharingController::handleOutgoingFinished, this));

+ oss.reset();

+}

+

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+#include <boost/shared_ptr.hpp>

+

+namespace Swift {

+ class ScreenSharingManager;

+ class IncomingScreenSharing;

+ class OutgoingScreenSharing;

+ class Timer;

+ class TimerFactory;

+ class DesktopScreenGrabber;

+ class RemoteScreenWindowFactory;

+ class RemoteScreenWindow;

+ class JID;

+

+ class ScreenSharingController {

+ public:

+ ScreenSharingController(ScreenSharingManager* screenSharingManager, RemoteScreenWindowFactory* remoteScreenWindowFactory, TimerFactory* timerFactory);

+ ~ScreenSharingController();

+

+ boost::shared_ptr<OutgoingScreenSharing> createOugoingScreenSharing(const JID& to);

+

+ public:

+ boost::signal<void (boost::shared_ptr<IncomingScreenSharing>)> onNewIncomingScreenSharing;

+

+ private:

+ void handleIncomingScreenSharing(boost::shared_ptr<IncomingScreenSharing> incomingScreenSharing);

+ void handleGrabTimerTick();

+ void handleOssReady();

+ void handleIncomingFinished();

+ void handleOutgoingFinished();

+

+ private:

+ ScreenSharingManager* screenSharingManager;

+ RemoteScreenWindowFactory* remoteScreenWindowFactory;

+

+ RemoteScreenWindow* remoteScreenWindow;

+ boost::shared_ptr<Timer> grabTimer;

+ DesktopScreenGrabber* screenGrabber;

+ boost::shared_ptr<IncomingScreenSharing> iss;

+ boost::shared_ptr<OutgoingScreenSharing> oss;

+ };

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

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

+

+#include <boost/shared_ptr.hpp>

+

+namespace Swift {

+ class ShareScreenUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<SendFileUIEvent> ref;

+

+ ShareScreenUIEvent(const JID& jid) : jid(jid) {}

+

+ public:

+ JID jid;

+ };

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+namespace Swift {

+ class IncomingScreenSharing;

+ class Image;

+

+ class RemoteScreenWindow {

+ public:

+ RemoteScreenWindow(boost::shared_ptr<IncomingScreenSharing> incScreenSharing)

+ : iss(incScreenSharing) {}

+ virtual ~RemoteScreenWindow() {}

+

+ protected:

+ boost::shared_ptr<IncomingScreenSharing> iss;

+ };

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+#include <boost/shared_ptr.hpp>

+

+namespace Swift {

+ class IncomingScreenSharing;

+ class RemoteScreenWindowFactory {

+ public:

+ virtual ~RemoteScreenWindowFactory() {}

+

+ virtual RemoteScreenWindow* createRemoteScreenViewer(boost::shared_ptr<IncomingScreenSharing> iss) = 0;

+ };

+}

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

+ public WhiteboardWindowFactory,

+ public RemoteScreenWindowFactory {

+#include <Swift/QtUI/ScreenSharing/QtRemoteScreenWindow.h>

+RemoteScreenWindow* QtUIFactory::createRemoteScreenViewer(boost::shared_ptr<IncomingScreenSharing> iss)

+{

+ QtRemoteScreenWindow* rsv = new QtRemoteScreenWindow(iss);

+ rsv->show();

+ return rsv;

+}

+

+ virtual RemoteScreenWindow* createRemoteScreenViewer(boost::shared_ptr<IncomingScreenSharing> iss);

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

+ QAction* shareScreen = NULL;

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

+ shareScreen = contextMenu.addAction(tr("Share my screen"));

+ }

+ else if (shareScreen && result == shareScreen) {

+ eventStream_->send(boost::make_shared<ShareScreenUIEvent>(contact->getJID()));

+ }

+ "QtUISettingConstants.cpp",

+ "ScreenSharing/RemoteScreenViewerWidget.cpp",

+ "ScreenSharing/QtRemoteScreenWindow.cpp",

+ "ScreenSharing/QtDesktopScreenGrabber.cpp",

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtDesktopScreenGrabber.h"

+

+#include <QImage>

+#include <QPixmap>

+#include <QApplication>

+#include <QDesktopWidget>

+

+#include <Swiften/ScreenSharing/Image.h>

+

+/*#include <QImage>

+#include <QLabel>*/

+

+namespace Swift {

+

+QtDesktopScreenGrabber::QtDesktopScreenGrabber()

+{

+ /*Image img = grab();

+ QImage qImg(img.data.data(), img.width, img.height, QImage::Format_RGB888);

+ QLabel *label = new QLabel;

+ label->setPixmap(QPixmap::fromImage(qImg));

+ label->show();*/

+}

+

+QtDesktopScreenGrabber::~QtDesktopScreenGrabber()

+{

+}

+

+Image QtDesktopScreenGrabber::grab() const

+{

+ QImage qImg = QPixmap::grabWindow(QApplication::desktop()->winId()).toImage().convertToFormat(QImage::Format_RGB888);

+ return Image(qImg.width(), qImg.height(), qImg.constBits());

+}

+

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include "Swift/Controllers/ScreenSharing/DesktopScreenGrabber.h"

+

+namespace Swift {

+ class QtDesktopScreenGrabber : public DesktopScreenGrabber {

+ public:

+ QtDesktopScreenGrabber();

+ virtual ~QtDesktopScreenGrabber();

+

+ virtual Image grab() const;

+ };

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "QtRemoteScreenWindow.h"

+#include "RemoteScreenViewerWidget.h"

+

+#include <QToolBar>

+

+#include <Swiften/ScreenSharing/IncomingScreenSharing.h>

+

+namespace Swift {

+

+QtRemoteScreenWindow::QtRemoteScreenWindow(boost::shared_ptr<IncomingScreenSharing> incScreenSharing, QWidget *parent)

+ : QMainWindow(parent), RemoteScreenWindow(incScreenSharing)

+{

+ setCentralWidget(new RemoteScreenViewerWidget(iss));

+

+ controlToolBar = addToolBar(tr("Control"));

+ closeAction = controlToolBar->addAction(QIcon::fromTheme("window-close"), tr("&Terminate session"), this, SLOT(handleCloseTriggered()));

+}

+

+QtRemoteScreenWindow::~QtRemoteScreenWindow()

+{

+}

+

+void QtRemoteScreenWindow::handleCloseTriggered()

+{

+ iss->stop();

+}

+

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

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

+

+#include <QMainWindow>

+

+class QToolBar;

+

+namespace Swift {

+

+ class QtRemoteScreenWindow : public QMainWindow, public RemoteScreenWindow {

+ Q_OBJECT

+

+ public:

+ QtRemoteScreenWindow(boost::shared_ptr<IncomingScreenSharing> incScreenSharing, QWidget *parent = 0);

+ virtual ~QtRemoteScreenWindow();

+

+ private slots:

+ void handleCloseTriggered();

+

+ private:

+ QAction* closeAction;

+ QToolBar* controlToolBar;

+ };

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "RemoteScreenViewerWidget.h"

+

+#include <QResizeEvent>

+#include <QPainter>

+

+#include <boost/bind.hpp>

+

+#include <Swiften/ScreenSharing/IncomingScreenSharing.h>

+#include <Swiften/ScreenSharing/Image.h>

+

+

+namespace Swift {

+

+RemoteScreenViewerWidget::RemoteScreenViewerWidget(boost::shared_ptr<IncomingScreenSharing> incScreenSharing, QWidget *parent) :

+ QWidget(parent), iss(incScreenSharing)

+{

+ iss->onNewImageReceived.connect(boost::bind(&RemoteScreenViewerWidget::handleNewImageReceived, this, _1));

+}

+

+RemoteScreenViewerWidget::~RemoteScreenViewerWidget()

+{

+ iss->onNewImageReceived.disconnect(boost::bind(&RemoteScreenViewerWidget::handleNewImageReceived, this, _1));

+}

+

+void RemoteScreenViewerWidget::paintEvent(QPaintEvent *)

+{

+ QPainter painter(this);

+ if (!pixmap.isNull()) {

+ painter.translate(geometry().center());

+ painter.drawPixmap(-pixmap.rect().center(), pixmap);

+ }

+}

+

+void RemoteScreenViewerWidget::resizeEvent(QResizeEvent *event)

+{

+ if (!pixmap.isNull())

+ pixmap = pixmap.scaled(event->size(), Qt::KeepAspectRatio);

+ QWidget::resizeEvent(event);

+}

+

+void RemoteScreenViewerWidget::handleNewImageReceived(const Image& image)

+{

+ QImage qImg(image.data.data(), image.width, image.height, QImage::Format_RGB888);

+ pixmap = QPixmap::fromImage(qImg).scaled(size(), Qt::KeepAspectRatio);

+ update();

+}

+

+}

+/*

+ * Copyright (c) 2012 Yoann Blein

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QWidget>

+

+#include <boost/shared_ptr.hpp>

+

+namespace Swift {

+ class IncomingScreenSharing;

+ class Image;

+

+ class RemoteScreenViewerWidget : public QWidget {

+ Q_OBJECT

+ public:

+ RemoteScreenViewerWidget(boost::shared_ptr<IncomingScreenSharing> incScreenSharing, QWidget *parent = 0);

+ ~RemoteScreenViewerWidget();

+

+ protected:

+ void paintEvent(QPaintEvent *);

+ void resizeEvent(QResizeEvent *event);

+

+ private:

+ void handleNewImageReceived(const Image& image);

+

+ private:

+ boost::shared_ptr<IncomingScreenSharing> iss;

+ QPixmap pixmap;

+ };

+}