/*

* Copyright (c) 2010-2011 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include "QtChatWindow.h"

#include "QtSwiftUtil.h"

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

#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"

alertLabel_->setStyleSheet(alertStyleSheet_);

alertWidget_->hide();

logRosterSplitter_ = new QSplitter(this);

logRosterSplitter_->setAutoFillBackground(true);

layout->addWidget(logRosterSplitter_);

messageLog_ = new QtChatView(theme, this);

logRosterSplitter_->addWidget(messageLog_);

treeWidget_->hide();

logRosterSplitter_->addWidget(treeWidget_);

logRosterSplitter_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

connect(logRosterSplitter_, SIGNAL(splitterMoved(int, int)), this, SLOT(handleSplitterMoved(int, int)));

QWidget* midBar = new QWidget(this);

layout->addWidget(midBar);

midBar->setAutoFillBackground(true);

QHBoxLayout *midBarLayout = new QHBoxLayout(midBar);

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

}

QtChatWindow::~QtChatWindow() {

}

void QtChatWindow::handleFontResized(int fontSizeSteps) {

messageLog_->resizeFont(fontSizeSteps);

}

void QtChatWindow::handleAlertButtonClicked() {

onAlertButtonClicked();

}

void QtChatWindow::moveEvent(QMoveEvent*) {

emit geometryChanged();

}

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

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

}

}

class QTextEdit;

class QLineEdit;

class QComboBox;

class QLabel;

class QSplitter;

class QPushButton;

namespace Swift {

class QtChatView;

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

QtTabbable::AlertType getWidgetAlertState();

void setContactChatState(ChatState::ChatStateType state);

void setRosterModel(Roster* roster);

void setTabComplete(TabComplete* completer);

int getCount();

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

void setAckState(const std::string& id, AckState state);

void flash();

QByteArray getSplitterState();

public slots:

void handleChangeSplitterState(QByteArray state);

void handleFontResized(int fontSizeSteps);

void setAlert(const std::string& alertText, const std::string& buttonText = "");

void cancelAlert();

void setCorrectionEnabled(Tristate enabled);

signals:

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

int unreadCount_;

bool contactIsTyping_;

LastLineTracker lastLineTracker_;

QString contact_;

QString lastSentMessage_;

QtChatView* messageLog_;

QtChatTheme* theme_;

QtTextEdit* input_;

QComboBox* labelsWidget_;

QLabel* correctingLabel_;

QLabel* alertLabel_;

QWidget* alertWidget_;

QPushButton* alertButton_;

TabComplete* completer_;

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

bool isCorrection_;

bool previousMessageWasSelf_;

bool previousMessageWasSystem_;

tabs_->setTabPosition(QTabWidget::South);

mainLayout->addWidget(tabs_);

contactsTabWidget_ = new QWidget(this);

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

QBoxLayout *contactTabLayout = new QBoxLayout(QBoxLayout::TopToBottom, contactsTabWidget_);

contactsTabWidget_->setLayout(contactTabLayout);

contactTabLayout->setSpacing(0);

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

contactTabLayout->addWidget(treeWidget_);

tabs_->addTab(contactsTabWidget_, tr("&Contacts"));

eventWindow_ = new QtEventWindow(uiEventStream_);

connect(eventWindow_, SIGNAL(onNewEventCountUpdated(int)), this, SLOT(handleEventCountUpdated(int)));

chatListWindow_ = new QtChatListWindow(uiEventStream_);

connect(chatListWindow_, SIGNAL(onCountUpdated(int)), this, SLOT(handleChatCountUpdated(int)));

connect(chatUserAction_, SIGNAL(triggered(bool)), this, SLOT(handleChatUserActionTriggered(bool)));

actionsMenu->addAction(chatUserAction_);

serverAdHocMenu_ = new QMenu(tr("Run Server Command"), this);

actionsMenu->addMenu(serverAdHocMenu_);

actionsMenu->addSeparator();

QAction* signOutAction = new QAction(tr("&Sign Out"), this);

connect(signOutAction, SIGNAL(triggered()), SLOT(handleSignOutAction()));

actionsMenu->addAction(signOutAction);

setAvailableAdHocCommands(std::vector<DiscoItems::Item>());

QAction* adHocAction = new QAction(tr("Collecting commands..."), this);

adHocAction->setEnabled(false);

serverAdHocMenu_->addAction(adHocAction);

serverAdHocCommandActions_.append(adHocAction);

lastOfflineState_ = false;

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

* Licensed under the GNU General Public License v3.

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

*/

#include "Roster/QtOccupantListWidget.h"

#include <QContextMenuEvent>

#include <QMenu>

#include <QInputDialog>

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

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

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

#include "QtSwiftUtil.h"

namespace Swift {

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

}

QtOccupantListWidget::~QtOccupantListWidget() {

}

void QtOccupantListWidget::contextMenuEvent(QContextMenuEvent* event) {

}

}

* Copyright (c) 2011 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

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

namespace Swift {

class QtOccupantListWidget : public QtTreeWidget {

Q_OBJECT

public:

QtOccupantListWidget(UIEventStream* eventStream, QWidget* parent = 0);

virtual ~QtOccupantListWidget();

protected:

void contextMenuEvent(QContextMenuEvent* event);

};

}

void QtRosterWidget::renameGroup(GroupRosterItem* group) {

bool ok;

QString newName = QInputDialog::getText(NULL, tr("Rename group"), tr("Enter a new name for group '%1':").arg(P2QSTRING(group->getDisplayName())), QLineEdit::Normal, P2QSTRING(group->getDisplayName()), &ok);

if (ok) {

eventStream_->send(boost::make_shared<RenameGroupUIEvent>(group->getDisplayName(), Q2PSTRING(newName)));

}

}

}

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

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

namespace Swift {

class QtRosterWidget : public QtTreeWidget {

Q_OBJECT

public:

QtRosterWidget(UIEventStream* eventStream, QWidget* parent = 0);

virtual ~QtRosterWidget();

public slots:

void handleEditUserActionTriggered(bool checked);

protected:

void contextMenuEvent(QContextMenuEvent* event);

private:

void renameGroup(GroupRosterItem* group);

};

}

if (ranges.at(i).left() == 0 && ranges.at(i).right() == right) {

for (int r = ranges.at(i).top(); r <= ranges.at(i).bottom(); ++r) {

selectedIndexList.append(ranges.at(i).model()->index(r, 0, parent));

}

}

}

return selectedIndexList;

}

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

class QtTreeWidget : public QTreeView{

Q_OBJECT

public:

QtTreeWidget(UIEventStream* eventStream, QWidget* parent = 0);

~QtTreeWidget();

void show();

QtTreeWidgetItem* getRoot();

void setRosterModel(Roster* roster);

Roster* getRoster() {return roster_;}

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:

UIEventStream* eventStream_;

private:

RosterModel* model_;

Roster* roster_;

RosterDelegate* delegate_;

QtTreeWidgetItem* treeRoot_;

};