#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Disco/DiscoServiceWalker.h>

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

#include <Swift/Controllers/UIEvents/RequestChatWithUserDialogUIEvent.h>

#include <Swift/Controllers/UIEvents/RequestAddUserDialogUIEvent.h>

#include <Swift/Controllers/Roster/RosterController.h>

namespace Swift {

uiEventStream_->onUIEvent.connect(boost::bind(&UserSearchController::handleUIEvent, this, _1));

window_ = NULL;

discoWalker_ = NULL;

}

endDiscoWalker();

delete discoWalker_;

if (window_) {

window_->onFormRequested.disconnect(boost::bind(&UserSearchController::handleFormRequested, this, _1));

window_->onSearchRequested.disconnect(boost::bind(&UserSearchController::handleSearch, this, _1, _2));

delete window_;

}

uiEventStream_->onUIEvent.disconnect(boost::bind(&UserSearchController::handleUIEvent, this, _1));

}

if (handle) {

if (!window_) {

window_ = factory_->createUserSearchWindow(type_ == AddContact ? UserSearchWindow::AddContact : UserSearchWindow::ChatToContact, uiEventStream_, rosterController_->getGroups());

window_->onFormRequested.connect(boost::bind(&UserSearchController::handleFormRequested, this, _1));

window_->onSearchRequested.connect(boost::bind(&UserSearchController::handleSearch, this, _1, _2));

window_->setSelectedService(JID(jid_.getDomain()));

}

}

void UserSearchController::handleDiscoWalkFinished() {

window_->setServerSupportsSearch(false);

endDiscoWalker();

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

namespace Swift {

class UIEventStream;

class IQRouter;

class DiscoServiceWalker;

class RosterController;

class UserSearchResult {

public:

class UserSearchController {

public:

enum Type {AddContact, StartChat};

~UserSearchController();

private:

void handleFormResponse(boost::shared_ptr<SearchPayload> items, ErrorPayload::ref error);

void handleSearch(boost::shared_ptr<SearchPayload> fields, const JID& jid);

void handleSearchResponse(boost::shared_ptr<SearchPayload> results, ErrorPayload::ref error);

void endDiscoWalker();

private:

Type type_;

JID jid_;

UIEventStream* uiEventStream_;

UserSearchWindowFactory* factory_;

IQRouter* iqRouter_;

RosterController* rosterController_;

#include <Swift/Controllers/ContactEditController.h>

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swift/Controllers/UIEvents/RemoveRosterItemUIEvent.h>

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

#include <Swift/Controllers/Roster/RosterController.h>

namespace Swift {

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

}

}

currentContact = rosterController->getItem(editEvent->getJID());

assert(currentContact);

contactEditWindow->show();

}

void ContactEditController::setAvailable(bool b) {

}

}

void ContactEditController::handleRemoveContactRequest() {

assert(currentContact);

uiEventStream->send(boost::make_shared<RemoveRosterItemUIEvent>(currentContact->getJID()));

#include <Swiften/JID/JID.h>

#include <string>

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

#include <Swiften/Roster/XMPPRosterItem.h>

class ContactEditWindowFactory;

class ContactEditWindow;

class RosterController;

class ContactEditController {

public:

~ContactEditController();

void setAvailable(bool b);

private:

void handleRemoveContactRequest();

void handleChangeContactRequest(const std::string& name, const std::set<std::string>& groups);

private:

void handleUIEvent(UIEvent::ref event);

private:

boost::optional<XMPPRosterItem> currentContact;

RosterController* rosterController;

ContactEditWindowFactory* contactEditWindowFactory;

UIEventStream* uiEventStream;

ContactEditWindow* contactEditWindow;

};

}

rosterController_->onChangeStatusRequest.connect(boost::bind(&MainController::handleChangeStatusRequest, this, _1, _2));

rosterController_->onSignOutRequest.connect(boost::bind(&MainController::signOut, this));

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

client_->getDiscoManager()->setCapsNode(CLIENT_NODE);

client_->getDiscoManager()->setDiscoInfo(discoInfo);

adHocManager_ = new AdHocManager(JID(boundJID_.getDomain()), uiFactory_, client_->getIQRouter(), uiEventStream_, rosterController_->getWindow());

}

loginWindow_->setIsLoggingIn(false);

namespace Swift {

class JID;

class ContactEditWindow {

public:

virtual void setEnabled(bool b) = 0;

virtual void setContact(const JID& jid, const std::string& name, const std::vector<std::string>& groups, const std::set<std::string>& allGroups) = 0;

virtual void show() = 0;

#include "Swiften/Base/boost_bsignals.h"

#include <vector>

#include <string>

#include "Swiften/JID/JID.h"

#include "Swift/Controllers/Chat/UserSearchController.h"

class UserSearchWindow {

public:

enum Type {AddContact, ChatToContact};

virtual void clear() = 0;

virtual void setResults(const std::vector<UserSearchResult>& results) = 0;

virtual void setServerSupportsSearch(bool support) = 0;

virtual void setSearchError(bool support) = 0;

virtual void setSearchFields(boost::shared_ptr<SearchPayload> fields) = 0;

virtual void show() = 0;

boost::signal<void (const JID&)> onFormRequested;

boost::signal<void (boost::shared_ptr<SearchPayload>, const JID&)> onSearchRequested;

};

}

#include <algorithm>

#include <QBoxLayout>

#include <QCheckBox>

#include <QLineEdit>

#include "Swift/QtUI/QtSwiftUtil.h"

namespace Swift {

QBoxLayout* layout = new QVBoxLayout(this);

setContentsMargins(0,0,0,0);

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

name_ = new QLineEdit(this);

layout->addWidget(new QLabel(tr("Groups:"), this));

}

std::string QtContactEditWidget::getName() const {

}

void QtContactEditWidget::setSelectedGroups(const std::vector<std::string>& groups) {

return groups;

}

void QtContactEditWidget::clear() {

name_->clear();

setSelectedGroups(std::vector<std::string>());

newGroup_->setChecked(false);

newGroupName_->clear();

}

}

#include <QWidget>

#include <string>

class QLineEdit;

class QCheckBox;

namespace Swift {

class QtContactEditWidget : public QWidget {

void setSelectedGroups(const std::vector<std::string>& groups);

std::set<std::string> getSelectedGroups() const;

void clear();

private:

typedef std::map<std::string, QCheckBox*> CheckBoxMap;

CheckBoxMap checkBoxes_;

QLineEdit* name_;

QWidget* groups_;

QCheckBox* newGroup_;

QLineEdit* newGroupName_;

};

}

#include <algorithm>

#include <QScrollArea>

#include <QBoxLayout>

#include <QLabel>

namespace Swift {

QtContactEditWindow::QtContactEditWindow() : contactEditWidget_(NULL) {

setWindowTitle(tr("Edit contact"));

setContentsMargins(0,0,0,0);

buttonLayout->addWidget(okButton);

}

void QtContactEditWindow::setContact(const JID& jid, const std::string& name, const std::vector<std::string>& groups, const std::set<std::string>& allGroups) {

delete contactEditWidget_;

jid_ = jid;

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

#include <string>

#include <Swiften/JID/JID.h>

class QLabel;

class QVBoxLayout;

public:

QtContactEditWindow();

virtual void setContact(const JID& jid, const std::string& name, const std::vector<std::string>& groups, const std::set<std::string>& allGroups);

void setEnabled(bool);

#include <QVBoxLayout>

#include <Swift/QtUI/QtContactEditWidget.h>

namespace Swift {

layout->addWidget(editWidget);

}

std::set<std::string> QtUserSearchDetailsPage::getSelectedGroups() {

return editWidget->getSelectedGroups();

}

editWidget->clear();

}

}

#pragma once

#include <QWizardPage>

#include <set>

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

namespace Swift {

Q_OBJECT

public:

QtUserSearchDetailsPage(const std::set<std::string>& availableGroups);

std::set<std::string> getSelectedGroups();

std::string getName();

void clear();

signals:

private:

};

}

}

else if (page == 4) {

detailsPage_->clear();

}

lastPage_ = page;

}

}

void QtUserSearchWindow::handleAccepted() {

if (type_ == AddContact) {

eventStream_->send(boost::make_shared<AddContactUIEvent>(jid, detailsPage_->getName(), detailsPage_->getSelectedGroups()));

onSearchRequested(search, getServerToSearch());

}

void QtUserSearchWindow::show() {

clear();

QWidget::show();

fieldsPage_->emitCompletenessCheck();

}

void QtUserSearchWindow::setResults(const std::vector<UserSearchResult>& results) {

UserSearchModel *newModel = new UserSearchModel();

newModel->setResults(results);

virtual void setSelectedService(const JID& jid);

virtual void setServerSupportsSearch(bool error);

virtual void setSearchError(bool error);

protected:

virtual int nextId() const;

private slots:

void setError(const QString& error);

JID getServerToSearch();

void handleSearch();

private:

UIEventStream* eventStream_;