}

std::vector<ChatListWindow::Chat> ChatsManager::getRecentChats() const {

return std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());

}

std::vector<Contact::ref> result;

foreach (ChatListWindow::Chat chat, recentChats_) {

if (!chat.isMUC) {

result.push_back(boost::make_shared<Contact>(chat.chatName.empty() ? chat.jid.toString() : chat.chatName, chat.jid, chat.statusType, chat.avatarPath));

}

}

return result;

}

ChatsManager::SingleChatWindowFactoryAdapter::SingleChatWindowFactoryAdapter(ChatWindow* chatWindow) : chatWindow_(chatWindow) {}

ChatsManager::SingleChatWindowFactoryAdapter::~SingleChatWindowFactoryAdapter() {}

ChatWindow* ChatsManager::SingleChatWindowFactoryAdapter::createChatWindow(const JID &, UIEventStream*) {

virtual ~ChatsManager();

void setAvatarManager(AvatarManager* avatarManager);

void setOnline(bool enabled);

void setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info);

void handleIncomingMessage(boost::shared_ptr<Message> message);

std::vector<ChatListWindow::Chat> getRecentChats() const;

boost::signal<void (bool supportsImpromptu)> onImpromptuMUCServiceDiscovered;

private:

class SingleChatWindowFactoryAdapter : public ChatWindowFactory {

public:

handleVCardChanged(jid, vcard);

}

}

void UserSearchController::handleContactSuggestionsRequested(std::string text) {

const std::vector<JID> existingJIDs = window_->getJIDs();

std::vector<Contact::ref>::iterator i = suggestions.begin();

while (i != suggestions.end()) {

bool found = false;

foreach (const JID& jid, existingJIDs) {

if ((*i)->jid == jid) {

found = true;

}

Contact::Contact(const std::string& name, const JID& jid, StatusShow::Type statusType, const boost::filesystem::path& path) : name(name), jid(jid), statusType(statusType), avatarPath(path) {

}

bool Contact::lexicographicalSortPredicate(const Contact::ref& a, const Contact::ref& b) {

}

bool Contact::equalityPredicate(const Contact::ref& a, const Contact::ref& b) {

}

bool Contact::sortPredicate(const Contact::ref& a, const Contact::ref& b, const std::string& search) {

/* perform case insensitive comparisons */

std::string aLower = a->name;

boost::to_lower(aLower);

namespace Swift {

class ContactProvider {

public:

virtual ~ContactProvider();

};

}

void ContactSuggester::addContactProvider(ContactProvider* provider) {

contactProviders_.push_back(provider);

}

bool ContactSuggester::matchContact(const std::string& search, const Contact::ref& c) {

}

std::vector<Contact::ref> results;

foreach(ContactProvider* provider, contactProviders_) {

}

std::sort(results.begin(), results.end(), Contact::lexicographicalSortPredicate);

results.erase(std::unique(results.begin(), results.end(), Contact::equalityPredicate), results.end());

results.erase(std::remove_if(results.begin(), results.end(), !lambda::bind(&matchContact, search, lambda::_1)),

results.end());

public:

ContactSuggester();

~ContactSuggester();

void addContactProvider(ContactProvider* provider);

public:

static bool matchContact(const std::string& search, const Contact::ref& c);

/**

* Performs fuzzy matching on the string text. Matches when each character of match string is present in sequence in text string.

*/

static bool fuzzyMatch(std::string text, std::string match);

ContactsFromXMPPRoster::ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle) : roster_(roster), avatarManager_(avatarManager), presenceOracle_(presenceOracle) {

}

ContactsFromXMPPRoster::~ContactsFromXMPPRoster() {

}

std::vector<Contact::ref> results;

std::vector<XMPPRosterItem> rosterItems = roster_->getItems();

foreach(const XMPPRosterItem& rosterItem, rosterItems) {

Contact::ref contact = boost::make_shared<Contact>(rosterItem.getName().empty() ? rosterItem.getJID().toString() : rosterItem.getName(), rosterItem.getJID(), StatusShow::None,"");

contact->statusType = presenceOracle_->getHighestPriorityPresence(contact->jid) ? presenceOracle_->getHighestPriorityPresence(contact->jid)->getShow() : StatusShow::None;

contact->avatarPath = avatarManager_->getAvatarPath(contact->jid);

class ContactsFromXMPPRoster : public ContactProvider {

public:

ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle);

virtual ~ContactsFromXMPPRoster();

private:

XMPPRoster* roster_;

AvatarManager* avatarManager_;

PresenceOracle* presenceOracle_;

};

}

}

void HighlightEditorController::handleContactSuggestionsRequested(const std::string& text)

{

if (contactSuggester_) {

}

}

}

void QtHighlightEditor::selectSoundFile()

{

QString path = QFileDialog::getOpenFileName(this, tr("Select sound file..."), QString(), "Sounds (*.wav)");

ui_.soundFile->setText(path);

}

/* this might seem like it should be standard behaviour for the suggesting input box, but is not desirable in all cases */

}

void QtHighlightEditor::populateList()

{

previousRow_ = -1;

ui_.listWidget->clear();

void widgetClick();

void disableDialog();

void handleContactSuggestionRequested(const QString& text);

void selectSoundFile();

private:

void populateList();

void selectRow(int row);

int getSelectedRow() const;

HighlightRule ruleFromDialog();

void ruleToDialog(const HighlightRule& rule);

treeViewPopup_->setCurrentIndex(contactListModel_->index(row, 0));

}

} else if (event->key() == Qt::Key_Return && treeViewPopup_->isVisible()) {

QModelIndex index = treeViewPopup_->currentIndex();

if (!contactListModel_->getList().empty() && index.isValid()) {

currentContact_ = contactListModel_->getContact(index.row());

hidePopup();

clearFocus();

} else {

currentContact_.reset();

}

editingDone();

}

}

void QtSuggestingJIDInput::handleClicked(const QModelIndex& index) {

if (index.isValid()) {

currentContact_ = contactListModel_->getContact(index.row());

hidePopup();

}

}

void QtSuggestingJIDInput::positionPopup() {

QDesktopWidget* desktop = QApplication::desktop();

Contact::ref getContact();

void setSuggestions(const std::vector<Contact::ref>& suggestions);

void clear();

signals:

void editingDone();

protected:

virtual void keyPressEvent(QKeyEvent* event);

searchNext_ = false;

if (firstMultiJIDPage_) {

firstMultiJIDPage_->reset();

}

resultsPage_->emitCompletenessCheck();

if (page == 1 && lastPage_ == 3) {

setSecondPage();

}

else if (page == 2 && lastPage_ == 1) {

setError("");

/* next won't be called if JID is selected */

JID server = getServerToSearch();

else {

jid = JID(Q2PSTRING(firstPage_->jid_->text().trimmed()));

}

return jid;

}

std::vector<JID> jids;

handleJIDsAdded(jids);

firstMultiJIDPage_->jid_->clear();

}

void QtUserSearchWindow::show() {

clear();

firstMultiJIDPage_->jid_->setSuggestions(suggestions);

}

}

void QtUserSearchWindow::setJIDs(const std::vector<JID> &jids) {

foreach(JID jid, jids) {

}

onJIDUpdateRequested(jids);

}

void QtUserSearchWindow::setRoomJID(const JID& roomJID) {

roomJID_ = roomJID;

private:

void clearForm();

void setError(const QString& error);

JID getServerToSearch();

void handleSearch();

JID getContactJID() const;

private:

UIEventStream* eventStream_;

UserSearchWindow::Type type_;

QAbstractItemModel* model_;

UserSearchDelegate* delegate_;