/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <boost/bind.hpp>

#include <QBoxLayout>

#include <Swift/QtUI/QtFormWidget.h>

#include <Swift/QtUI/QtSwiftUtil.h>

const int FormLayoutIndex = 1;

namespace Swift {

QtAdHocCommandWindow::QtAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command) : command_(command) {

formWidget_ = NULL;

setAttribute(Qt::WA_DeleteOnClose);

command->onNextStageReceived.connect(boost::bind(&QtAdHocCommandWindow::handleNextStageReceived, this, _1));

command->onError.connect(boost::bind(&QtAdHocCommandWindow::handleError, this, _1));

command->start();

layout_ = new QBoxLayout(QBoxLayout::TopToBottom, this);

layout_->setContentsMargins(0,0,0,0);

layout_->setSpacing(2);

label_ = new QLabel(this);

label_->setTextFormat(Qt::PlainText);

layout_->addWidget(label_);

QWidget* buttonsWidget = new QWidget(this);

layout_->addWidget(buttonsWidget);

QBoxLayout* buttonsLayout = new QBoxLayout(QBoxLayout::LeftToRight, buttonsWidget);

cancelButton_ = new QPushButton(tr("Cancel"), buttonsWidget);

buttonsLayout->addWidget(cancelButton_);

connect(cancelButton_, SIGNAL(clicked()), this, SLOT(handleCancelClicked()));

backButton_ = new QPushButton(tr("Back"), buttonsWidget);

buttonsLayout->addWidget(backButton_);

connect(backButton_, SIGNAL(clicked()), this, SLOT(handlePrevClicked()));

nextButton_ = new QPushButton(tr("Next"), buttonsWidget);

buttonsLayout->addWidget(nextButton_);

connect(nextButton_, SIGNAL(clicked()), this, SLOT(handleNextClicked()));

completeButton_ = new QPushButton(tr("Complete"), buttonsWidget);

buttonsLayout->addWidget(completeButton_);

connect(completeButton_, SIGNAL(clicked()), this, SLOT(handleCompleteClicked()));

nextButton_->setEnabled(false);

backButton_->setEnabled(false);

completeButton_->setEnabled(false);

actions_[Command::Next] = nextButton_;

actions_[Command::Prev] = backButton_;

actions_[Command::Complete] = completeButton_;

actions_[Command::Cancel] = cancelButton_;

}

QtAdHocCommandWindow::~QtAdHocCommandWindow() {

}

void QtAdHocCommandWindow::handleCancelClicked() {

command_->cancel();

close();

}

void QtAdHocCommandWindow::handlePrevClicked() {

command_->goBack();

}

void QtAdHocCommandWindow::handleNextClicked() {

command_->goNext(formWidget_ ? formWidget_->getCompletedForm() : Form::ref());

}

void QtAdHocCommandWindow::handleCompleteClicked() {

command_->complete(formWidget_ ? formWidget_->getCompletedForm() : Form::ref());

}

void QtAdHocCommandWindow::handleNextStageReceived(Command::ref command) {

QString notes;

foreach (Command::Note note, command->getNotes()) {

if (!notes.isEmpty()) {

notes += "\n";

}

QString qNote(P2QSTRING(note.note));

switch (note.type) {

case Command::Note::Error: notes += tr("Error: %1").arg(qNote); break;

case Command::Note::Warn: notes += tr("Warning: %1").arg(qNote); break;

case Command::Note::Info: notes += qNote; break;

}

}

label_->setText(notes);

if (command->getForm()) {

setForm(command->getForm());

} else {

setNoForm(notes.isEmpty());

}

setAvailableActions(command);

}

void QtAdHocCommandWindow::handleError(ErrorPayload::ref /*error*/) {

nextButton_->setEnabled(false);

backButton_->setEnabled(false);

completeButton_->setEnabled(false);

label_->setText(tr("Error executing command"));

}

void QtAdHocCommandWindow::setForm(Form::ref form) {

form_ = form;

delete formWidget_;

formWidget_ = new QtFormWidget(form, this);

layout_->insertWidget(FormLayoutIndex, formWidget_);

show();

}

void QtAdHocCommandWindow::setNoForm(bool andHide) {

form_.reset();

delete formWidget_;

formWidget_ = NULL;

resize(minimumSize());

setVisible(!andHide);

}

typedef std::pair<Command::Action, QPushButton*> ActionButton;

void QtAdHocCommandWindow::setAvailableActions(Command::ref /*commandResult*/) {

foreach (ActionButton pair, actions_) {

OutgoingAdHocCommandSession::ActionState state = command_->getActionState(pair.first);

if (state & OutgoingAdHocCommandSession::Present) {

pair.second->show();

}

else {

pair.second->hide();

}

if (state & OutgoingAdHocCommandSession::Enabled) {

pair.second->setEnabled(true);

}

else {

pair.second->setEnabled(false);

}

}

}

}

/*

* Copyright (c) 2010-2012 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <QWidget>

#include <QPushButton>

#include <QLabel>

#include <Swift/Controllers/UIInterfaces/AdHocCommandWindow.h>

#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

class QBoxLayout;

namespace Swift {

class QtFormWidget;

class QtAdHocCommandWindow : public QWidget, public AdHocCommandWindow {

Q_OBJECT

public:

QtAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command);

virtual ~QtAdHocCommandWindow();

private:

void handleNextStageReceived(Command::ref command);

void handleError(ErrorPayload::ref error);

void setForm(Form::ref);

void setNoForm(bool andHide);

void setAvailableActions(Command::ref commandResult);

private slots:

void handleCancelClicked();

void handlePrevClicked();

void handleNextClicked();

void handleCompleteClicked();

private:

boost::shared_ptr<OutgoingAdHocCommandSession> command_;

QtFormWidget* formWidget_;

Form::ref form_;

QLabel* label_;

QPushButton* backButton_;

QPushButton* nextButton_;

QPushButton* completeButton_;

QPushButton* cancelButton_;

std::map<Command::Action, QPushButton*> actions_;

QBoxLayout* layout_;

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swift/QtUI/QtUIFactory.h>

#include <QSplitter>

#include <Swift/QtUI/QtXMLConsoleWidget.h>

#include <Swift/QtUI/QtChatTabs.h>

#include <Swift/QtUI/QtMainWindow.h>

#include <Swift/QtUI/QtLoginWindow.h>

#include <Swift/QtUI/QtSystemTray.h>

#include <Swift/QtUI/QtSettingsProvider.h>

#include <Swift/QtUI/QtMainWindow.h>

#include <Swift/QtUI/QtChatWindow.h>

#include <Swift/QtUI/QtJoinMUCWindow.h>

#include <Swift/QtUI/QtChatWindowFactory.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/MUCSearch/QtMUCSearchWindow.h>

#include <Swift/QtUI/UserSearch/QtUserSearchWindow.h>

#include <Swift/QtUI/QtProfileWindow.h>

#include <Swift/QtUI/QtContactEditWindow.h>

#include <Swift/QtUI/QtAdHocCommandWindow.h>

#include <Swift/QtUI/QtFileTransferListWidget.h>

#include <Swift/QtUI/QtHighlightEditorWidget.h>

#include <Swift/QtUI/Whiteboard/QtWhiteboardWindow.h>

#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>

#include <Swift/QtUI/QtUISettingConstants.h>

#include <Swift/QtUI/QtHistoryWindow.h>

#include <Swiften/Whiteboard/WhiteboardSession.h>

#include <Swift/QtUI/QtSingleWindow.h>

#include <Swift/QtUI/QtBlockListEditorWindow.h>

namespace Swift {

QtUIFactory::QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabs* tabs, QtSingleWindow* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, TimerFactory* timerFactory, StatusCache* statusCache, bool startMinimized, bool emoticonsExist) : settings(settings), qtOnlySettings(qtOnlySettings), tabs(tabs), netbookSplitter(netbookSplitter), systemTray(systemTray), chatWindowFactory(chatWindowFactory), timerFactory_(timerFactory), lastMainWindow(NULL), loginWindow(NULL), statusCache(statusCache), startMinimized(startMinimized), emoticonsExist_(emoticonsExist) {

chatFontSize = settings->getSetting(QtUISettingConstants::CHATWINDOW_FONT_SIZE);

historyFontSize_ = settings->getSetting(QtUISettingConstants::HISTORYWINDOW_FONT_SIZE);

}

XMLConsoleWidget* QtUIFactory::createXMLConsoleWidget() {

QtXMLConsoleWidget* widget = new QtXMLConsoleWidget();

tabs->addTab(widget);

if (!tabs->isVisible()) {

tabs->show();

}

widget->show();

return widget;

}

HistoryWindow* QtUIFactory::createHistoryWindow(UIEventStream* uiEventStream) {

QtHistoryWindow* window = new QtHistoryWindow(settings, uiEventStream);

tabs->addTab(window);

if (!tabs->isVisible()) {

tabs->show();

}

connect(window, SIGNAL(fontResized(int)), this, SLOT(handleHistoryWindowFontResized(int)));

window->handleFontResized(historyFontSize_);

window->show();

return window;

}

void QtUIFactory::handleHistoryWindowFontResized(int size) {

historyFontSize_ = size;

settings->storeSetting(QtUISettingConstants::HISTORYWINDOW_FONT_SIZE, size);

}

FileTransferListWidget* QtUIFactory::createFileTransferListWidget() {

QtFileTransferListWidget* widget = new QtFileTransferListWidget();

tabs->addTab(widget);

if (!tabs->isVisible()) {

tabs->show();

}

widget->show();

return widget;

}

MainWindow* QtUIFactory::createMainWindow(UIEventStream* eventStream) {

lastMainWindow = new QtMainWindow(settings, eventStream, loginWindow->getMenus(), statusCache, emoticonsExist_);

return lastMainWindow;

}

LoginWindow* QtUIFactory::createLoginWindow(UIEventStream* eventStream) {

loginWindow = new QtLoginWindow(eventStream, settings, timerFactory_);

if (netbookSplitter) {

netbookSplitter->insertAtFront(loginWindow);

}

connect(systemTray, SIGNAL(clicked()), loginWindow, SLOT(toggleBringToFront()));

#ifndef SWIFT_MOBILE

QVariant loginWindowGeometryVariant = qtOnlySettings->getQSettings()->value("loginWindowGeometry");

if (loginWindowGeometryVariant.isValid()) {

loginWindow->restoreGeometry(loginWindowGeometryVariant.toByteArray());

}

connect(loginWindow, SIGNAL(geometryChanged()), this, SLOT(handleLoginWindowGeometryChanged()));

if (startMinimized) loginWindow->hide();

#endif

return loginWindow;

}

void QtUIFactory::handleLoginWindowGeometryChanged() {

qtOnlySettings->getQSettings()->setValue("loginWindowGeometry", loginWindow->saveGeometry());

}

EventWindow* QtUIFactory::createEventWindow() {

return lastMainWindow->getEventWindow();

}

ChatListWindow* QtUIFactory::createChatListWindow(UIEventStream*) {

return lastMainWindow->getChatListWindow();

}

MUCSearchWindow* QtUIFactory::createMUCSearchWindow() {

return new QtMUCSearchWindow();

}

ChatWindow* QtUIFactory::createChatWindow(const JID& contact, UIEventStream* eventStream) {

QtChatWindow* window = dynamic_cast<QtChatWindow*>(chatWindowFactory->createChatWindow(contact, eventStream));

chatWindows.push_back(window);

std::vector<QPointer<QtChatWindow> > deletions;

foreach (QPointer<QtChatWindow> existingWindow, chatWindows) {

if (existingWindow.isNull()) {

deletions.push_back(existingWindow);

} else {

connect(window, SIGNAL(fontResized(int)), existingWindow, SLOT(handleFontResized(int)));

connect(existingWindow, SIGNAL(fontResized(int)), window, SLOT(handleFontResized(int)));

}

}

foreach (QPointer<QtChatWindow> deletedWindow, deletions) {

chatWindows.erase(std::remove(chatWindows.begin(), chatWindows.end(), deletedWindow), chatWindows.end());

}

connect(window, SIGNAL(fontResized(int)), this, SLOT(handleChatWindowFontResized(int)));

window->handleFontResized(chatFontSize);

return window;

}

void QtUIFactory::handleChatWindowFontResized(int size) {

chatFontSize = size;

settings->storeSetting(QtUISettingConstants::CHATWINDOW_FONT_SIZE, size);

}

UserSearchWindow* QtUIFactory::createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups) {

return new QtUserSearchWindow(eventStream, type, groups, qtOnlySettings);

}

JoinMUCWindow* QtUIFactory::createJoinMUCWindow(UIEventStream* uiEventStream) {

return new QtJoinMUCWindow(uiEventStream);

}

ProfileWindow* QtUIFactory::createProfileWindow() {

return new QtProfileWindow();

}

ContactEditWindow* QtUIFactory::createContactEditWindow() {

return new QtContactEditWindow();

}

WhiteboardWindow* QtUIFactory::createWhiteboardWindow(boost::shared_ptr<WhiteboardSession> whiteboardSession) {

return new QtWhiteboardWindow(whiteboardSession);

}

HighlightEditorWidget* QtUIFactory::createHighlightEditorWidget() {

return new QtHighlightEditorWidget();

}

BlockListEditorWidget *QtUIFactory::createBlockListEditorWidget() {

return new QtBlockListEditorWindow();

}

}

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <QObject>

#include <QPointer>

#include <Swift/Controllers/UIInterfaces/UIFactory.h>

class QSplitter;

namespace Swift {

class QtSettingsProvider;

class SettingsProviderHierachy;

class QtChatTabs;

class QtSystemTray;

class QtLoginWindow;

class QtMainWindow;

class QtChatTheme;

class QtChatWindowFactory;

class QtChatWindow;

class TimerFactory;

class historyWindow_;

class WhiteboardSession;

class StatusCache;

class QtSingleWindow;

class QtUIFactory : public QObject, public UIFactory {

Q_OBJECT

public:

QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabs* tabs, QtSingleWindow* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, TimerFactory* timerFactory, StatusCache* statusCache, bool startMinimized, bool emoticonsExist);

virtual XMLConsoleWidget* createXMLConsoleWidget();

virtual HistoryWindow* createHistoryWindow(UIEventStream*);

virtual MainWindow* createMainWindow(UIEventStream* eventStream);

virtual LoginWindow* createLoginWindow(UIEventStream* eventStream);

virtual EventWindow* createEventWindow();

virtual ChatListWindow* createChatListWindow(UIEventStream*);

virtual MUCSearchWindow* createMUCSearchWindow();

virtual ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream);

virtual UserSearchWindow* createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups);

virtual JoinMUCWindow* createJoinMUCWindow(UIEventStream* uiEventStream);

virtual ProfileWindow* createProfileWindow();

virtual ContactEditWindow* createContactEditWindow();

virtual FileTransferListWidget* createFileTransferListWidget();

virtual WhiteboardWindow* createWhiteboardWindow(boost::shared_ptr<WhiteboardSession> whiteboardSession);

virtual HighlightEditorWidget* createHighlightEditorWidget();

virtual BlockListEditorWidget* createBlockListEditorWidget();

private slots:

void handleLoginWindowGeometryChanged();

void handleChatWindowFontResized(int);

void handleHistoryWindowFontResized(int);

private:

SettingsProviderHierachy* settings;

QtSettingsProvider* qtOnlySettings;

QtChatTabs* tabs;

QtSingleWindow* netbookSplitter;

QtSystemTray* systemTray;

QtChatWindowFactory* chatWindowFactory;

TimerFactory* timerFactory_;

QtMainWindow* lastMainWindow;

QtLoginWindow* loginWindow;

StatusCache* statusCache;

std::vector<QPointer<QtChatWindow> > chatWindows;

bool startMinimized;

int chatFontSize;

int historyFontSize_;

bool emoticonsExist_;

};

}