/*

* 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());

/*

* 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 {

}

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_;

};

}