#include <QDesktopServices>

#include <QVBoxLayout>

#include <QWebFrame>

#include <QKeyEvent>

#include <QStackedWidget>

#include <QTimer>

#include <QMessageBox>

#include <QApplication>

#include "QtWebView.h"

#include "QtChatTheme.h"

namespace Swift {

QtChatView::QtChatView(QtChatTheme* theme, QWidget* parent) : QWidget(parent), fontSizeSteps_(0) {

theme_ = theme;

/* To give a border on Linux, where it looks bad without */

QStackedWidget* stack = new QStackedWidget(this);

stack->addWidget(webView_);

stack->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);

stack->setLineWidth(2);

mainLayout->addWidget(stack);

#else

mainLayout->addWidget(webView_);

#endif

webPage_ = new QWebPage(this);

webPage_->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);

webView_->setPage(webPage_);

connect(webPage_, SIGNAL(selectionChanged()), SLOT(copySelectionToClipboard()));

viewReady_ = false;

isAtBottom_ = true;

resetView();

}

void QtChatView::handleClearRequested() {

QWebElement replace = lastElement_.findFirst("span.swift_time");

assert(!replace.isNull());

replace.setInnerXml(ChatSnippet::escape(note));

}

QString QtChatView::getLastSentMessage() {

return lastElement_.toPlainText();

}

void QtChatView::replaceMessage(const QString& newMessage, const QString& id, const QDateTime& editTime) {

rememberScrolledToBottom();

QWebElement message = document_.findFirst("#" + id);

if (!message.isNull()) {

QWebElement replaceContent = message.findFirst("span.swift_message");

assert(!replaceContent.isNull());

QString old = replaceContent.toOuterXml();

replaceContent.setInnerXml(ChatSnippet::escape(newMessage));

QWebElement replaceTime = message.findFirst("span.swift_time");

QWebElement chatElement = document_.findFirst("#Chat");

newInsertPoint_ = chatElement.clone();

newInsertPoint_.setOuterXml("<div id='swift_insert'/>");

chatElement.appendInside(newInsertPoint_);

Q_ASSERT(!newInsertPoint_.isNull());

connect(webPage_->mainFrame(), SIGNAL(contentsSizeChanged(const QSize&)), this, SLOT(handleFrameSizeChanged()), Qt::UniqueConnection);

}

}

#include <QString>

#include <QWidget>

#include <QList>

#include <QWebElement>

#include <boost/shared_ptr.hpp>

#include "ChatSnippet.h"

class QWebPage;

class QUrl;

namespace Swift {

class QtWebView;

class QtChatTheme;

class QtChatView : public QWidget {

Q_OBJECT

public:

QtChatView(QtChatTheme* theme, QWidget* parent);

void addMessage(boost::shared_ptr<ChatSnippet> snippet);

void addLastSeenLine();

void replaceLastMessage(const QString& newMessage);

void replaceLastMessage(const QString& newMessage, const QString& note);

void replaceMessage(const QString& newMessage, const QString& id, const QDateTime& time);

void rememberScrolledToBottom();

void setAckXML(const QString& id, const QString& xml);

QString getLastSentMessage();

signals:

void gotFocus();

void fontResized(int);

public slots:

void copySelectionToClipboard();

void scrollToBottom();

void handleLinkClicked(const QUrl&);

#include "SwifTools/Linkify.h"

#include "QtChatView.h"

#include "MessageSnippet.h"

#include "SystemMessageSnippet.h"

#include "QtTextEdit.h"

#include "QtSettingsProvider.h"

#include "QtScaledAvatarCache.h"

#include "SwifTools/TabComplete.h"

#include <QLabel>

#include <QApplication>

#include <QBoxLayout>

#include <QCloseEvent>

#include <QComboBox>

#include <QFileInfo>

#include <QLineEdit>

#include <QSplitter>

#include <QString>

#include <QTextEdit>

#include <QTime>

#include <QUrl>

#include <QPushButton>

namespace Swift {

unreadCount_ = 0;

inputEnabled_ = true;

completer_ = NULL;

theme_ = theme;

isCorrection_ = false;

correctionEnabled_ = Maybe;

updateTitleWithUnreadCount();

QtSettingsProvider settings;

alertStyleSheet_ = "background: rgb(255, 255, 153); color: black";

QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, this);

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

layout->setSpacing(2);

alertWidget_ = new QWidget(this);

QHBoxLayout* alertLayout = new QHBoxLayout(alertWidget_);

layout->addWidget(alertWidget_);

connect(input_, SIGNAL(textChanged()), this, SLOT(handleInputChanged()));

setFocusProxy(input_);

logRosterSplitter_->setFocusProxy(input_);

midBar->setFocusProxy(input_);

messageLog_->setFocusProxy(input_);

connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(qAppFocusChanged(QWidget*, QWidget*)));

connect(messageLog_, SIGNAL(gotFocus()), input_, SLOT(setFocus()));

resize(400,300);

connect(messageLog_, SIGNAL(fontResized(int)), this, SIGNAL(fontResized(int)));

treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QtChatWindow::handleOccupantSelectionChanged, this, _1));

treeWidget_->onOccupantActionSelected.connect(boost::bind(boost::ref(onOccupantActionSelected), _1, _2));

}

QtChatWindow::~QtChatWindow() {

}

void QtChatWindow::handleOccupantSelectionChanged(RosterItem* item) {

onOccupantSelectionChanged(dynamic_cast<ContactRosterItem*>(item));

}

void QtChatWindow::handleFontResized(int fontSizeSteps) {

messageLog_->resizeFont(fontSizeSteps);

}

void QtChatWindow::handleAlertButtonClicked() {

}

void QtChatWindow::closeEvent(QCloseEvent* event) {

event->accept();

emit windowClosing();

onClosed();

}

void QtChatWindow::convertToMUC() {

treeWidget_->show();

}

void QtChatWindow::qAppFocusChanged(QWidget *old, QWidget *now) {

Q_UNUSED(old);

Q_UNUSED(now);

if (isWidgetSelected()) {

lastLineTracker_.setHasFocus(true);

input_->setFocus();

htmlString += QString("%3</span> ").arg(Qt::escape(P2QSTRING(label->getDisplayMarking())));

}

QString messageHTML(Qt::escape(P2QSTRING(message)));

messageHTML = P2QSTRING(Linkify::linkify(Q2PSTRING(messageHTML)));

messageHTML.replace("\n","<br/>");

QString styleSpanStart = style == "" ? "" : "<span style=\"" + style + "\">";

QString styleSpanEnd = style == "" ? "" : "</span>";

htmlString += styleSpanStart + messageHTML + styleSpanEnd;

if (lastLineTracker_.getShouldMoveLastLine()) {

/* should this be queued? */

messageLog_->addLastSeenLine();

/* if the line is added we should break the snippet */

appendToPrevious = false;

}

QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.png" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();

std::string id = id_.generateID();

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new MessageSnippet(htmlString, Qt::escape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

previousMessageWasSelf_ = senderIsSelf;

previousSenderName_ = P2QSTRING(senderName);

previousMessageWasSystem_ = false;

previousMessageWasPresence_ = false;

return id;

}

void QtChatWindow::flash() {

emit requestFlash();

}

void QtChatWindow::setAckState(std::string const& id, ChatWindow::AckState state) {

QString xml;

int QtChatWindow::getCount() {

return unreadCount_;

}

std::string QtChatWindow::addAction(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time) {

return addMessage(" *" + message + "*", senderName, senderIsSelf, label, avatarPath, "font-style:italic ", time);

}

void QtChatWindow::addErrorMessage(const std::string& errorMessage) {

if (isWidgetSelected()) {

onAllMessagesRead();

}

QString errorMessageHTML(Qt::escape(P2QSTRING(errorMessage)));

errorMessageHTML.replace("\n","<br/>");

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new SystemMessageSnippet("<span class=\"error\">" + errorMessageHTML + "</span>", QDateTime::currentDateTime(), false, theme_)));

previousMessageWasSelf_ = false;

previousMessageWasSystem_ = true;

previousMessageWasPresence_ = false;

}

void QtChatWindow::addSystemMessage(const std::string& message) {

if (isWidgetSelected()) {

onAllMessagesRead();

}

QString messageHTML(Qt::escape(P2QSTRING(message)));

messageHTML = P2QSTRING(Linkify::linkify(Q2PSTRING(messageHTML)));

messageHTML.replace("\n","<br/>");

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new SystemMessageSnippet(messageHTML, QDateTime::currentDateTime(), false, theme_)));

previousMessageWasSelf_ = false;

previousMessageWasSystem_ = true;

previousMessageWasPresence_ = false;

}

void QtChatWindow::replaceMessage(const std::string& message, const std::string& id, const boost::posix_time::ptime& time) {

if (!id.empty()) {

QString messageHTML(Qt::escape(P2QSTRING(message)));

messageHTML = P2QSTRING(Linkify::linkify(Q2PSTRING(messageHTML)));

messageHTML.replace("\n","<br/>");

messageLog_->replaceMessage(messageHTML, P2QSTRING(id), B2QDATE(time));

}

void QtChatWindow::resizeEvent(QResizeEvent*) {

emit geometryChanged();

}

void QtChatWindow::moveEvent(QMoveEvent*) {

emit geometryChanged();

}

void QtChatWindow::replaceLastMessage(const std::string& message) {

messageLog_->replaceLastMessage(P2QSTRING(Linkify::linkify(message)));

}

void QtChatWindow::setAvailableOccupantActions(const std::vector<OccupantAction>& actions) {

treeWidget_->setAvailableOccupantActions(actions);

}

}

#include "Swift/Controllers/UIInterfaces/ChatWindow.h"

#include "QtTabbable.h"

#include "SwifTools/LastLineTracker.h"

#include "Swiften/Base/IDGenerator.h"

class QTextEdit;

class QLineEdit;

class QComboBox;

class QLabel;

class QSplitter;

class QPushButton;

namespace Swift {

class QtChatView;

class QtOccupantListWidget;

class QtChatTheme;

class TreeWidget;

class QtTextEdit;

class UIEventStream;

class QtChatWindow : public QtTabbable, public ChatWindow {

Q_OBJECT

public:

QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream);

~QtChatWindow();

std::string addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time);

std::string addAction(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time);

void addSystemMessage(const std::string& message);

void addPresenceMessage(const std::string& message);

void addErrorMessage(const std::string& errorMessage);

void replaceMessage(const std::string& message, const std::string& id, const boost::posix_time::ptime& time);

void show();

void activate();

void setUnreadMessageCount(int count);

void convertToMUC();

// TreeWidget *getTreeWidget();

void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels);

void setSecurityLabelsEnabled(bool enabled);

void setSecurityLabelsError();

SecurityLabelsCatalog::Item getSelectedSecurityLabel();

void splitterMoved();

void fontResized(int);

protected slots:

void qAppFocusChanged(QWidget* old, QWidget* now);

void closeEvent(QCloseEvent* event);

void resizeEvent(QResizeEvent* event);

void moveEvent(QMoveEvent* event);

protected:

void showEvent(QShowEvent* event);

private slots:

void returnPressed();

void handleInputChanged();

void handleKeyPressEvent(QKeyEvent* event);

void handleSplitterMoved(int pos, int index);

void handleAlertButtonClicked();

private:

void updateTitleWithUnreadCount();

void tabComplete();

void beginCorrection();

void cancelCorrection();

std::string addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const QString& style, const boost::posix_time::ptime& time);

void handleOccupantSelectionChanged(RosterItem* item);

int unreadCount_;

QLabel* alertLabel_;

QWidget* alertWidget_;

QPushButton* alertButton_;

TabComplete* completer_;

std::vector<SecurityLabelsCatalog::Item> availableLabels_;

bool isCorrection_;

bool previousMessageWasSelf_;

bool previousMessageWasSystem_;

bool previousMessageWasPresence_;

QString previousSenderName_;

bool inputClearing_;

UIEventStream* eventStream_;

bool inputEnabled_;

IDGenerator id_;

QSplitter *logRosterSplitter_;

Tristate correctionEnabled_;

QString alertStyleSheet_;

};

}

/*

* Copyright (c) 2010-2011 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include "QtLoginWindow.h"

#include <boost/bind.hpp>

#include <algorithm>

#include <cassert>

#include <QApplication>

#include <QBoxLayout>

#include <QComboBox>

#include <QDesktopWidget>

#include <QFileDialog>

#include <QStatusBar>

#include <QHBoxLayout>

#include <qdebug.h>

#include <QCloseEvent>

#include <QCursor>

#include <QMessageBox>

#include <QKeyEvent>

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swift/Controllers/UIEvents/RequestXMLConsoleUIEvent.h"

#include "Swift/Controllers/UIEvents/ToggleSoundsUIEvent.h"

#include "Swift/Controllers/UIEvents/ToggleNotificationsUIEvent.h"

#include "Swiften/Base/Platform.h"

#include "QtAboutWidget.h"

#include "QtSwiftUtil.h"

#include "QtMainWindow.h"

#include "QtUtilities.h"

QAction* aboutAction = new QAction(QString(tr("&About %1")).arg("Swift"), this);

#endif

connect(aboutAction, SIGNAL(triggered()), SLOT(handleAbout()));

swiftMenu_->addAction(aboutAction);

xmlConsoleAction_ = new QAction(tr("&Show Debug Console"), this);

connect(xmlConsoleAction_, SIGNAL(triggered()), SLOT(handleShowXMLConsole()));

generalMenu_->addAction(xmlConsoleAction_);

toggleSoundsAction_ = new QAction(tr("&Play Sounds"), this);

toggleSoundsAction_->setCheckable(true);

toggleSoundsAction_->setChecked(true);

connect(toggleSoundsAction_, SIGNAL(toggled(bool)), SLOT(handleToggleSounds(bool)));

generalMenu_->addAction(toggleSoundsAction_);

toggleNotificationsAction_ = new QAction(tr("Display Pop-up &Notifications"), this);

toggleNotificationsAction_->setCheckable(true);

toggleNotificationsAction_->setChecked(true);

aboutDialog_->raise();

aboutDialog_->activateWindow();

}

}

void QtLoginWindow::handleShowXMLConsole() {

uiEventStream_->send(boost::shared_ptr<RequestXMLConsoleUIEvent>(new RequestXMLConsoleUIEvent()));

}

void QtLoginWindow::handleToggleSounds(bool enabled) {

uiEventStream_->send(boost::shared_ptr<ToggleSoundsUIEvent>(new ToggleSoundsUIEvent(enabled)));

}

void QtLoginWindow::handleToggleNotifications(bool enabled) {

uiEventStream_->send(boost::shared_ptr<ToggleNotificationsUIEvent>(new ToggleNotificationsUIEvent(enabled)));

}

void QtLoginWindow::handleQuit() {

signals:

void geometryChanged();

private slots:

void loginClicked();

void handleCertficateChecked(bool);

void handleQuit();

void handleShowXMLConsole();

void handleToggleSounds(bool enabled);

void handleToggleNotifications(bool enabled);

void handleAbout();

void bringToFront();

void handleUsernameTextChanged();

void resizeEvent(QResizeEvent* event);

void moveEvent(QMoveEvent* event);

void handleUIEvent(boost::shared_ptr<UIEvent> event);

QMenuBar* menuBar_;

QMenu* swiftMenu_;

QMenu* generalMenu_;

QAction* toggleSoundsAction_;

QAction* toggleNotificationsAction_;

UIEventStream* uiEventStream_;

QPointer<QtAboutWidget> aboutDialog_;

bool forgetful_;

QAction* xmlConsoleAction_;

};

}

#include "QtChatWindow.h"

#include "QtJoinMUCWindow.h"

#include "QtChatWindowFactory.h"

#include "QtSwiftUtil.h"

#include "MUCSearch/QtMUCSearchWindow.h"

#include "UserSearch/QtUserSearchWindow.h"

#include "QtProfileWindow.h"

#include "QtContactEditWindow.h"

#include "QtAdHocCommandWindow.h"

#define CHATWINDOW_FONT_SIZE "chatWindowFontSize"

namespace Swift {

QtUIFactory::QtUIFactory(QtSettingsProvider* settings, QtChatTabs* tabs, QSplitter* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, bool startMinimized) : settings(settings), tabs(tabs), netbookSplitter(netbookSplitter), systemTray(systemTray), chatWindowFactory(chatWindowFactory), lastMainWindow(NULL), loginWindow(NULL), startMinimized(startMinimized) {

chatFontSize = settings->getIntSetting(CHATWINDOW_FONT_SIZE, 0);

}

QtXMLConsoleWidget* widget = new QtXMLConsoleWidget();

tabs->addTab(widget);

if (!tabs->isVisible()) {

tabs->show();

}

widget->show();

return widget;

}

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

lastMainWindow = new QtMainWindow(settings, eventStream);

return lastMainWindow;

}

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

loginWindow = new QtLoginWindow(eventStream);

if (netbookSplitter) {

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 void createAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command);

private slots:

void handleLoginWindowGeometryChanged();

void handleChatWindowFontResized(int);

private:

QtSettingsProvider* settings;

QtChatTabs* tabs;

}

void QtWebView::setFontSizeIsMinimal(bool minimum) {

fontSizeIsMinimal = minimum;

}

void QtWebView::contextMenuEvent(QContextMenuEvent* ev) {

// Filter out the relevant actions from the standard actions

QMenu* menu = page()->createStandardContextMenu();

QList<QAction*> actions(menu->actions());

for (int i = 0; i < actions.size(); ++i) {

QAction* action = actions.at(i);

bool removeAction = true;

for(size_t j = 0; j < filteredActions.size(); ++j) {

if (action == pageAction(filteredActions[j])) {

removeAction = false;

break;

}

}

if (removeAction) {

menu->removeAction(action);

}

// Add our own custom actions

menu->addAction(tr("Clear"), this, SIGNAL(clearRequested()));

menu->addAction(tr("Increase font size"), this, SIGNAL(fontGrowRequested()));

QAction* shrink = new QAction(tr("Decrease font size"), this);

shrink->setEnabled(!fontSizeIsMinimal);

connect(shrink, SIGNAL(triggered()), this, SIGNAL(fontShrinkRequested()));

menu->addAction(shrink);

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include "QtXMLConsoleWidget.h"

#include <QCloseEvent>

#include <QTextEdit>

#include <QVBoxLayout>

#include <QPushButton>

#include <QScrollBar>

#include <QCheckBox>

#include "QtSwiftUtil.h"

#include <string>

buttonLayout->addStretch();

QPushButton* clearButton = new QPushButton(tr("Clear"), bottom);

connect(clearButton, SIGNAL(clicked()), textEdit, SLOT(clear()));

buttonLayout->addWidget(clearButton);

setWindowTitle(tr("Debug Console"));

emit titleUpdated();

}

void QtXMLConsoleWidget::showEvent(QShowEvent* event) {

emit windowOpening();

emit titleUpdated(); /* This just needs to be somewhere after construction */

QWidget::showEvent(event);

}

void QtXMLConsoleWidget::show() {

emit wantsToActivate();

}

void QtXMLConsoleWidget::closeEvent(QCloseEvent* event) {

emit windowClosing();

event->accept();

}

void QtXMLConsoleWidget::handleDataRead(const SafeByteArray& data) {

}

void QtXMLConsoleWidget::handleDataWritten(const SafeByteArray& data) {

}

void QtXMLConsoleWidget::appendTextIfEnabled(const std::string& data, const QColor& color) {

if (enabled->isChecked()) {

QScrollBar* scrollBar = textEdit->verticalScrollBar();

bool scrollToBottom = (!scrollBar || scrollBar->value() == scrollBar->maximum());

QTextCursor cursor(textEdit->document());

cursor.beginEditBlock();

#include "Swift/Controllers/UIInterfaces/XMLConsoleWidget.h"

#include "QtTabbable.h"

class QTextEdit;

class QCheckBox;

class QColor;

namespace Swift {

class QtXMLConsoleWidget : public QtTabbable, public XMLConsoleWidget {

Q_OBJECT

public:

QtXMLConsoleWidget();

void show();

void activate();

virtual void handleDataRead(const SafeByteArray& data);

virtual void handleDataWritten(const SafeByteArray& data);

private:

virtual void closeEvent(QCloseEvent* event);

virtual void showEvent(QShowEvent* event);

void appendTextIfEnabled(const std::string& data, const QColor& color);

private:

QTextEdit* textEdit;

QCheckBox* enabled;

};

}

* Licensed under the GNU General Public License v3.

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

*/

#include "Roster/QtRosterWidget.h"

#include <QContextMenuEvent>

#include <QMenu>

#include <QInputDialog>

#include "Swift/Controllers/UIEvents/RequestContactEditorUIEvent.h"

#include "Swift/Controllers/UIEvents/RemoveRosterItemUIEvent.h"

#include "Swift/Controllers/UIEvents/RenameGroupUIEvent.h"

#include "QtContactEditWindow.h"

#include "Swift/Controllers/Roster/ContactRosterItem.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "QtSwiftUtil.h"

namespace Swift {

QtRosterWidget::QtRosterWidget(UIEventStream* eventStream, QWidget* parent) : QtTreeWidget(eventStream, parent) {

QModelIndex index = indexAt(event->pos());

if (!index.isValid()) {

return;

}

RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

QMenu contextMenu;

if (ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item)) {

QAction* editContact = contextMenu.addAction(tr("Edit"));

QAction* removeContact = contextMenu.addAction(tr("Remove"));

QAction* result = contextMenu.exec(event->globalPos());

if (result == editContact) {

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

}

else if (result == removeContact) {

if (QtContactEditWindow::confirmContactDeletion(contact->getJID())) {

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

}

}

}

else if (GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item)) {

QAction* renameGroupAction = contextMenu.addAction(tr("Rename"));

QAction* result = contextMenu.exec(event->globalPos());

if (result == renameGroupAction) {

renameGroup(group);

}

}

}

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include "Roster/QtTreeWidget.h"

#include <boost/smart_ptr/make_shared.hpp>

#include "Swiften/Base/Platform.h"

#include "Swift/Controllers/Roster/ContactRosterItem.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

#include "QtSwiftUtil.h"

namespace Swift {

QtTreeWidget::QtTreeWidget(UIEventStream* eventStream, QWidget* parent) : QTreeView(parent) {

eventStream_ = eventStream;

model_ = new RosterModel(this);

setModel(model_);

delegate_ = new RosterDelegate(this);

setItemDelegate(delegate_);

setHeaderHidden(true);

#ifdef SWIFT_PLATFORM_MACOSX

setAlternatingRowColors(true);

#endif

setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);

expandAll();

setAnimated(true);

setIndentation(0);

setRootIsDecorated(true);

connect(this, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleItemActivated(const QModelIndex&)));

connect(model_, SIGNAL(itemExpanded(const QModelIndex&, bool)), this, SLOT(handleModelItemExpanded(const QModelIndex&, bool)));

connect(this, SIGNAL(expanded(const QModelIndex&)), this, SLOT(handleExpanded(const QModelIndex&)));

connect(this, SIGNAL(collapsed(const QModelIndex&)), this, SLOT(handleCollapsed(const QModelIndex&)));

connect(this, SIGNAL(clicked(const QModelIndex&)), this, SLOT(handleClicked(const QModelIndex&)));

}

QtTreeWidget::~QtTreeWidget() {

void QtTreeWidget::handleItemActivated(const QModelIndex& index) {

RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

if (contact) {

eventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(contact->getJID())));

}

}

void QtTreeWidget::handleExpanded(const QModelIndex& index) {

GroupRosterItem* item = dynamic_cast<GroupRosterItem*>(static_cast<RosterItem*>(index.internalPointer()));

if (item) {

item->setExpanded(true);

}

}

void QtTreeWidget::handleCollapsed(const QModelIndex& index) {

GroupRosterItem* item = dynamic_cast<GroupRosterItem*>(static_cast<RosterItem*>(index.internalPointer()));

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <QTreeView>

#include <QModelIndex>

#include "Swift/QtUI/Roster/RosterModel.h"

#include "Swift/QtUI/Roster/RosterDelegate.h"

namespace Swift {

class UIEventStream;

class QtTreeWidget : public QTreeView{

Q_OBJECT

public:

Roster* getRoster() {return roster_;}

boost::signal<void (RosterItem*)> onSomethingSelectedChanged;

private slots:

void handleItemActivated(const QModelIndex&);

void handleModelItemExpanded(const QModelIndex&, bool expanded);

void handleExpanded(const QModelIndex&);

void handleCollapsed(const QModelIndex&);

void handleClicked(const QModelIndex&);

protected:

QModelIndexList getSelectedIndexes() const;

private:

void drawBranches(QPainter*, const QRect&, const QModelIndex&) const;

protected slots:

virtual void currentChanged(const QModelIndex& current, const QModelIndex& previous);

protected:

UIEventStream* eventStream_;

"QtChatTheme.cpp",

"QtChatTabs.cpp",

"QtSoundPlayer.cpp",

"QtSystemTray.cpp",

"QtCachedImageScaler.cpp",

"QtTabbable.cpp",

"QtTabWidget.cpp",

"QtTextEdit.cpp",

"QtXMLConsoleWidget.cpp",

"QtAdHocCommandWindow.cpp",

"QtUtilities.cpp",

"QtBookmarkDetailWindow.cpp",

"QtAddBookmarkWindow.cpp",

"QtEditBookmarkWindow.cpp",

"QtContactEditWindow.cpp",

"QtContactEditWidget.cpp",

"ChatSnippet.cpp",

"MessageSnippet.cpp",

"UserSearch/QtUserSearchDetailsPage.cpp",

"UserSearch/QtUserSearchWindow.cpp",

"UserSearch/UserSearchModel.cpp",

"UserSearch/UserSearchDelegate.cpp",

"QtSubscriptionRequestWindow.cpp",

"QtRosterHeader.cpp",

"QtWebView.cpp",

"qrc_DefaultTheme.cc",

"qrc_Swift.cc",

]

myenv["SWIFT_VERSION"] = Version.getBuildVersion(env.Dir("#").abspath, "swift")

if env["PLATFORM"] == "win32" :

res = myenv.RES("#/Swift/resources/Windows/Swift.rc")

# For some reason, SCons isn't picking up the dependency correctly

# Adding it explicitly until i figure out why

myenv.Depends(res, "../Controllers/BuildVersion.h")