DEFINES = BUILD_CORE
QT -= gui
-QT += network sql
+QT += network sql script
MODULES = core qtui uisupport client common
DEFINES = BUILD_MONO
-QT += network sql
+QT += network sql script
MODULES = qtui uisupport client common
DEFINES = BUILD_QTUI
-QT += network
+QT += network script
/*****************************************
* Fancy Buffer Items
*****************************************/
-BufferTreeItem::BufferTreeItem(Buffer *buffer, AbstractTreeItem *parent)
+BufferItem::BufferItem(Buffer *buffer, AbstractTreeItem *parent)
: PropertyMapItem(QStringList() << "bufferName" << "topic" << "nickCount", parent),
buf(buffer),
activity(Buffer::NoActivity)
setFlags(flags);
}
-quint64 BufferTreeItem::id() const {
+quint64 BufferItem::id() const {
return buf->bufferInfo().uid();
}
-void BufferTreeItem::setActivity(const Buffer::ActivityLevel &level) {
+void BufferItem::setActivity(const Buffer::ActivityLevel &level) {
activity = level;
}
-QColor BufferTreeItem::foreground(int column) const {
+QColor BufferItem::foreground(int column) const {
Q_UNUSED(column)
// for the time beeing we ignore the column :)
if(activity & Buffer::Highlight) {
}
}
-QVariant BufferTreeItem::data(int column, int role) const {
+QVariant BufferItem::data(int column, int role) const {
switch(role) {
- case BufferTreeModel::BufferUidRole:
+ case NetworkModel::ItemTypeRole:
+ return NetworkModel::BufferItemType;
+ case NetworkModel::BufferUidRole:
return buf->bufferInfo().uid();
- case BufferTreeModel::NetworkIdRole:
+ case NetworkModel::NetworkIdRole:
return buf->bufferInfo().networkId();
- case BufferTreeModel::BufferTypeRole:
+ case NetworkModel::BufferTypeRole:
return int(buf->bufferType());
- case BufferTreeModel::BufferActiveRole:
+ case NetworkModel::BufferActiveRole:
return buf->isActive();
case Qt::ForegroundRole:
return foreground(column);
}
}
-void BufferTreeItem::attachIrcChannel(IrcChannel *ircChannel) {
+void BufferItem::attachIrcChannel(IrcChannel *ircChannel) {
if(!ircChannel)
return;
this, SLOT(part(IrcUser *)));
}
-QString BufferTreeItem::bufferName() const {
+QString BufferItem::bufferName() const {
return buf->name();
}
-QString BufferTreeItem::topic() const {
+QString BufferItem::topic() const {
if(_ircChannel)
return _ircChannel->topic();
else
return QString();
}
-int BufferTreeItem::nickCount() const {
+int BufferItem::nickCount() const {
if(_ircChannel)
return _ircChannel->ircUsers().count();
else
return 0;
}
-void BufferTreeItem::setTopic(const QString &topic) {
+void BufferItem::setTopic(const QString &topic) {
Q_UNUSED(topic);
emit dataChanged(1);
}
-void BufferTreeItem::join(IrcUser *ircUser) {
- Q_UNUSED(ircUser);
- emit dataChanged(2);
+void BufferItem::join(IrcUser *ircUser) {
+// emit newChild(new IrcUserItem(ircUser, this));
+// emit dataChanged(2);
}
-void BufferTreeItem::part(IrcUser *ircUser) {
+void BufferItem::part(IrcUser *ircUser) {
Q_UNUSED(ircUser);
emit dataChanged(2);
}
/*****************************************
* Network Items
*****************************************/
-NetworkTreeItem::NetworkTreeItem(const uint &netid, const QString &network, AbstractTreeItem *parent)
+NetworkItem::NetworkItem(const uint &netid, const QString &network, AbstractTreeItem *parent)
: PropertyMapItem(QList<QString>() << "networkName" << "currentServer" << "nickCount", parent),
_networkId(netid),
_networkName(network)
setFlags(Qt::ItemIsEnabled);
}
-QVariant NetworkTreeItem::data(int column, int role) const {
+QVariant NetworkItem::data(int column, int role) const {
switch(role) {
- case BufferTreeModel::NetworkIdRole:
+ case NetworkModel::NetworkIdRole:
return _networkId;
- case BufferTreeModel::ItemTypeRole:
- return BufferTreeModel::NetworkItem;
+ case NetworkModel::ItemTypeRole:
+ return NetworkModel::NetworkItemType;
default:
return PropertyMapItem::data(column, role);
}
}
-quint64 NetworkTreeItem::id() const {
+quint64 NetworkItem::id() const {
return _networkId;
}
-QString NetworkTreeItem::networkName() const {
+QString NetworkItem::networkName() const {
if(_networkInfo)
return _networkInfo->networkName();
else
return _networkName;
}
-QString NetworkTreeItem::currentServer() const {
+QString NetworkItem::currentServer() const {
if(_networkInfo)
return _networkInfo->currentServer();
else
return QString();
}
-int NetworkTreeItem::nickCount() const {
- BufferTreeItem *bufferItem;
+int NetworkItem::nickCount() const {
+ BufferItem *bufferItem;
int count = 0;
for(int i = 0; i < childCount(); i++) {
- bufferItem = qobject_cast<BufferTreeItem *>(child(i));
+ bufferItem = qobject_cast<BufferItem *>(child(i));
if(!bufferItem)
continue;
count += bufferItem->nickCount();
return count;
}
-void NetworkTreeItem::attachNetworkInfo(NetworkInfo *networkInfo) {
+void NetworkItem::attachNetworkInfo(NetworkInfo *networkInfo) {
if(!networkInfo)
return;
// FIXME: connect this and that...
}
-void NetworkTreeItem::attachIrcChannel(const QString &channelName) {
+void NetworkItem::attachIrcChannel(const QString &channelName) {
IrcChannel *ircChannel = _networkInfo->ircChannel(channelName);
if(!ircChannel) {
- qWarning() << "NetworkTreeItem::attachIrcChannel(): unkown Channel" << channelName;
+ qWarning() << "NetworkItem::attachIrcChannel(): unkown Channel" << channelName;
return;
}
- BufferTreeItem *bufferItem;
+ BufferItem *bufferItem;
for(int i = 0; i < childCount(); i++) {
- bufferItem = qobject_cast<BufferTreeItem *>(child(i));
+ bufferItem = qobject_cast<BufferItem *>(child(i));
if(bufferItem->bufferName() == ircChannel->name()) {
bufferItem->attachIrcChannel(ircChannel);
break;
}
}
-void NetworkTreeItem::setNetworkName(const QString &networkName) {
+void NetworkItem::setNetworkName(const QString &networkName) {
Q_UNUSED(networkName);
emit dataChanged(0);
}
-void NetworkTreeItem::setCurrentServer(const QString &serverName) {
+void NetworkItem::setCurrentServer(const QString &serverName) {
Q_UNUSED(serverName);
emit dataChanged(1);
}
/*****************************************
- * BufferTreeModel
+* Irc User Items
+*****************************************/
+IrcUserItem::IrcUserItem(IrcUser *ircUser, AbstractTreeItem *parent)
+ : PropertyMapItem(QStringList() << "nickName", parent),
+ _ircUser(ircUser)
+{
+ connect(ircUser, SIGNAL(destroyed()),
+ this, SLOT(ircUserDestroyed()));
+
+ connect(ircUser, SIGNAL(nickSet(QString)),
+ this, SLOT(setNick(QString)));
+}
+
+QString IrcUserItem::nickName() {
+ return _ircUser->nick();
+}
+
+void IrcUserItem::setNick(QString newNick) {
+ Q_UNUSED(newNick);
+ emit dataChanged(0);
+}
+void IrcUserItem::ircUserDestroyed() {
+ deleteLater();
+}
+
+
+/*****************************************
+ * NetworkModel
*****************************************/
-BufferTreeModel::BufferTreeModel(QObject *parent)
- : TreeModel(BufferTreeModel::defaultHeader(), parent),
+NetworkModel::NetworkModel(QObject *parent)
+ : TreeModel(NetworkModel::defaultHeader(), parent),
_selectionModelSynchronizer(new SelectionModelSynchronizer(this)),
_propertyMapper(new ModelPropertyMapper(this))
{
this, SLOT(setCurrentIndex(QModelIndex, QItemSelectionModel::SelectionFlags)));
}
-QList<QVariant >BufferTreeModel::defaultHeader() {
+QList<QVariant >NetworkModel::defaultHeader() {
QList<QVariant> data;
data << tr("Buffer") << tr("Topic") << tr("Nick Count");
return data;
}
-void BufferTreeModel::synchronizeSelectionModel(MappedSelectionModel *selectionModel) {
+void NetworkModel::synchronizeSelectionModel(MappedSelectionModel *selectionModel) {
selectionModelSynchronizer()->addSelectionModel(selectionModel);
}
-void BufferTreeModel::synchronizeView(QAbstractItemView *view) {
+void NetworkModel::synchronizeView(QAbstractItemView *view) {
MappedSelectionModel *mappedSelectionModel = new MappedSelectionModel(view->model());
selectionModelSynchronizer()->addSelectionModel(mappedSelectionModel);
Q_ASSERT(mappedSelectionModel);
view->setSelectionModel(mappedSelectionModel);
}
-void BufferTreeModel::mapProperty(int column, int role, QObject *target, const QByteArray &property) {
+void NetworkModel::mapProperty(int column, int role, QObject *target, const QByteArray &property) {
propertyMapper()->addMapping(column, role, target, property);
}
-bool BufferTreeModel::isBufferIndex(const QModelIndex &index) const {
- // not so purdy...
- return parent(index) != QModelIndex();
+bool NetworkModel::isBufferIndex(const QModelIndex &index) const {
+ return index.data(NetworkModel::ItemTypeRole) == NetworkModel::BufferItemType;
}
-Buffer *BufferTreeModel::getBufferByIndex(const QModelIndex &index) const {
- BufferTreeItem *item = static_cast<BufferTreeItem *>(index.internalPointer());
+Buffer *NetworkModel::getBufferByIndex(const QModelIndex &index) const {
+ BufferItem *item = static_cast<BufferItem *>(index.internalPointer());
// FIXME get rid of this
Q_ASSERT(item->buffer() == Client::instance()->buffer(item->id()));
return item->buffer();
// experimental stuff :)
-QModelIndex BufferTreeModel::networkIndex(uint networkId) {
+QModelIndex NetworkModel::networkIndex(uint networkId) {
return indexById(networkId);
}
-NetworkTreeItem *BufferTreeModel::network(uint networkId) {
- return qobject_cast<NetworkTreeItem *>(rootItem->childById(networkId));
+NetworkItem *NetworkModel::network(uint networkId) {
+ return qobject_cast<NetworkItem *>(rootItem->childById(networkId));
}
-NetworkTreeItem *BufferTreeModel::newNetwork(uint networkId, const QString &networkName) {
- NetworkTreeItem *networkItem = network(networkId);
+NetworkItem *NetworkModel::newNetwork(uint networkId, const QString &networkName) {
+ NetworkItem *networkItem = network(networkId);
if(networkItem == 0) {
- networkItem = new NetworkTreeItem(networkId, networkName, rootItem);
+ networkItem = new NetworkItem(networkId, networkName, rootItem);
appendChild(rootItem, networkItem);
}
return networkItem;
}
-QModelIndex BufferTreeModel::bufferIndex(BufferInfo bufferInfo) {
+QModelIndex NetworkModel::bufferIndex(BufferInfo bufferInfo) {
QModelIndex networkIdx = networkIndex(bufferInfo.networkId());
if(!networkIdx.isValid())
return QModelIndex();
return indexById(bufferInfo.uid(), networkIdx);
}
-BufferTreeItem *BufferTreeModel::buffer(BufferInfo bufferInfo) {
+BufferItem *NetworkModel::buffer(BufferInfo bufferInfo) {
QModelIndex bufferIdx = bufferIndex(bufferInfo);
if(bufferIdx.isValid())
- return static_cast<BufferTreeItem *>(bufferIdx.internalPointer());
+ return static_cast<BufferItem *>(bufferIdx.internalPointer());
else
return 0;
}
-BufferTreeItem *BufferTreeModel::newBuffer(BufferInfo bufferInfo) {
- BufferTreeItem *bufferItem = buffer(bufferInfo);
+BufferItem *NetworkModel::newBuffer(BufferInfo bufferInfo) {
+ BufferItem *bufferItem = buffer(bufferInfo);
if(bufferItem == 0) {
- NetworkTreeItem *networkItem = newNetwork(bufferInfo.networkId(), bufferInfo.network());
+ NetworkItem *networkItem = newNetwork(bufferInfo.networkId(), bufferInfo.network());
// FIXME: get rid of the buffer pointer
Buffer *buffer = Client::instance()->buffer(bufferInfo.uid());
- bufferItem = new BufferTreeItem(buffer, networkItem);
+ bufferItem = new BufferItem(buffer, networkItem);
appendChild(networkItem, bufferItem);
}
return bufferItem;
}
-QStringList BufferTreeModel::mimeTypes() const {
+QStringList NetworkModel::mimeTypes() const {
// mimetypes we accept for drops
QStringList types;
// comma separated list of colon separated pairs of networkid and bufferid
return types;
}
-bool BufferTreeModel::mimeContainsBufferList(const QMimeData *mimeData) {
+bool NetworkModel::mimeContainsBufferList(const QMimeData *mimeData) {
return mimeData->hasFormat("application/Quassel/BufferItemList");
}
-QList< QPair<uint, uint> > BufferTreeModel::mimeDataToBufferList(const QMimeData *mimeData) {
+QList< QPair<uint, uint> > NetworkModel::mimeDataToBufferList(const QMimeData *mimeData) {
QList< QPair<uint, uint> > bufferList;
if(!mimeContainsBufferList(mimeData))
}
-QMimeData *BufferTreeModel::mimeData(const QModelIndexList &indexes) const {
+QMimeData *NetworkModel::mimeData(const QModelIndexList &indexes) const {
QMimeData *mimeData = new QMimeData();
QStringList bufferlist;
return mimeData;
}
-bool BufferTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) {
+bool NetworkModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) {
Q_UNUSED(action)
Q_UNUSED(row)
Q_UNUSED(column)
return false;
// target must be a query
- Buffer::Type targetType = (Buffer::Type)parent.data(BufferTreeModel::BufferTypeRole).toInt();
+ Buffer::Type targetType = (Buffer::Type)parent.data(NetworkModel::BufferTypeRole).toInt();
if(targetType != Buffer::QueryType)
return false;
return true;
}
-void BufferTreeModel::attachNetworkInfo(NetworkInfo *networkInfo) {
- NetworkTreeItem *networkItem = network(networkInfo->networkId());
+void NetworkModel::attachNetworkInfo(NetworkInfo *networkInfo) {
+ NetworkItem *networkItem = network(networkInfo->networkId());
if(!networkItem) {
- qWarning() << "BufferTreeModel::attachNetworkInfo(): network is unknown!";
+ qWarning() << "NetworkModel::attachNetworkInfo(): network is unknown!";
return;
}
networkItem->attachNetworkInfo(networkInfo);
}
-void BufferTreeModel::bufferUpdated(Buffer *buffer) {
- BufferTreeItem *bufferItem = newBuffer(buffer->bufferInfo());
+void NetworkModel::bufferUpdated(Buffer *buffer) {
+ BufferItem *bufferItem = newBuffer(buffer->bufferInfo());
QModelIndex itemindex = indexByItem(bufferItem);
emit dataChanged(itemindex, itemindex);
}
// This Slot indicates that the user has selected a different buffer in the gui
-void BufferTreeModel::setCurrentIndex(const QModelIndex &index, QItemSelectionModel::SelectionFlags command) {
+void NetworkModel::setCurrentIndex(const QModelIndex &index, QItemSelectionModel::SelectionFlags command) {
Q_UNUSED(command)
Buffer *newCurrentBuffer;
if(isBufferIndex(index) && currentBuffer != (newCurrentBuffer = getBufferByIndex(index))) {
}
}
-void BufferTreeModel::bufferActivity(Buffer::ActivityLevel level, Buffer *buf) {
- BufferTreeItem *bufferItem = buffer(buf->bufferInfo());
+void NetworkModel::bufferActivity(Buffer::ActivityLevel level, Buffer *buf) {
+ BufferItem *bufferItem = buffer(buf->bufferInfo());
if(!bufferItem) {
- qWarning() << "BufferTreeModel::bufferActivity(): received Activity Info for uknown Buffer";
+ qWarning() << "NetworkModel::bufferActivity(): received Activity Info for uknown Buffer";
return;
}
bufferUpdated(buf);
}
-void BufferTreeModel::selectBuffer(Buffer *buffer) {
+void NetworkModel::selectBuffer(Buffer *buffer) {
QModelIndex index = bufferIndex(buffer->bufferInfo());
if(!index.isValid()) {
- qWarning() << "BufferTreeModel::selectBuffer(): unknown Buffer has been selected.";
+ qWarning() << "NetworkModel::selectBuffer(): unknown Buffer has been selected.";
return;
}
// SUPER UGLY!
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#ifndef _BUFFERTREEMODEL_H_
-#define _BUFFERTREEMODEL_H_
+#ifndef NETWORKMODEL_H
+#define NETWORKMODEL_H
#include <QtCore>
/*****************************************
* Fancy Buffer Items
*****************************************/
-class BufferTreeItem : public PropertyMapItem {
+class BufferItem : public PropertyMapItem {
Q_OBJECT
Q_PROPERTY(QString bufferName READ bufferName)
Q_PROPERTY(QString topic READ topic)
Q_PROPERTY(int nickCount READ nickCount)
public:
- BufferTreeItem(Buffer *, AbstractTreeItem *parent = 0);
+ BufferItem(Buffer *, AbstractTreeItem *parent = 0);
virtual quint64 id() const;
virtual QVariant data(int column, int role) const;
/*****************************************
* Network Items
*****************************************/
-class NetworkTreeItem : public PropertyMapItem {
+class NetworkItem : public PropertyMapItem {
Q_OBJECT
Q_PROPERTY(QString networkName READ networkName)
Q_PROPERTY(QString currentServer READ currentServer)
Q_PROPERTY(int nickCount READ nickCount)
public:
- NetworkTreeItem(const uint &netid, const QString &, AbstractTreeItem *parent = 0);
+ NetworkItem(const uint &netid, const QString &, AbstractTreeItem *parent = 0);
virtual QVariant data(int column, int row) const;
virtual quint64 id() const;
};
/*****************************************
- * BufferTreeModel
+* Irc User Items
+*****************************************/
+class IrcUserItem : public PropertyMapItem {
+ Q_OBJECT
+ Q_PROPERTY(QString nickName READ nickName)
+
+public:
+ IrcUserItem(IrcUser *ircUser, AbstractTreeItem *parent);
+
+ QString nickName();
+
+private slots:
+ void setNick(QString newNick);
+ void ircUserDestroyed();
+
+private:
+ IrcUser *_ircUser;
+};
+
+
+/*****************************************
+ * NetworkModel
*****************************************/
-class BufferTreeModel : public TreeModel {
+class NetworkModel : public TreeModel {
Q_OBJECT
public:
};
enum itemTypes {
- AbstractItem,
- SimpleItem,
- NetworkItem,
- BufferItem,
- NickItem
+ AbstractItemType,
+ SimpleItemType,
+ NetworkItemType,
+ BufferItemType,
+ NickItemType
};
- BufferTreeModel(QObject *parent = 0);
+ NetworkModel(QObject *parent = 0);
static QList<QVariant> defaultHeader();
inline SelectionModelSynchronizer *selectionModelSynchronizer() { return _selectionModelSynchronizer; }
Buffer *getBufferByIndex(const QModelIndex &) const;
QModelIndex networkIndex(uint networkId);
- NetworkTreeItem *network(uint networkId);
- NetworkTreeItem *newNetwork(uint networkId, const QString &networkName);
+ NetworkItem *network(uint networkId);
+ NetworkItem *newNetwork(uint networkId, const QString &networkName);
QModelIndex bufferIndex(BufferInfo bufferInfo);
- BufferTreeItem *buffer(BufferInfo bufferInfo);
- BufferTreeItem *newBuffer(BufferInfo bufferInfo);
+ BufferItem *buffer(BufferInfo bufferInfo);
+ BufferItem *newBuffer(BufferInfo bufferInfo);
QPointer<SelectionModelSynchronizer> _selectionModelSynchronizer;
QPointer<ModelPropertyMapper> _propertyMapper;
Buffer *currentBuffer;
};
-#endif
+#endif // NETWORKMODEL_H
return bufferInfo(net, "");
}
-BufferTreeModel *Client::bufferModel() {
- return instance()->_bufferModel;
+NetworkModel *Client::networkModel() {
+ return instance()->_networkModel;
}
SignalProxy *Client::signalProxy() {
socket(0),
_signalProxy(new SignalProxy(SignalProxy::Client, this)),
mainUi(0),
- _bufferModel(0),
+ _networkModel(0),
connectedToCore(false)
{
}
void Client::init() {
blockSize = 0;
- _bufferModel = new BufferTreeModel(this);
+ _networkModel = new NetworkModel(this);
connect(this, SIGNAL(bufferSelected(Buffer *)),
- _bufferModel, SLOT(selectBuffer(Buffer *)));
+ _networkModel, SLOT(selectBuffer(Buffer *)));
connect(this, SIGNAL(bufferUpdated(Buffer *)),
- _bufferModel, SLOT(bufferUpdated(Buffer *)));
+ _networkModel, SLOT(bufferUpdated(Buffer *)));
connect(this, SIGNAL(bufferActivity(Buffer::ActivityLevel, Buffer *)),
- _bufferModel, SLOT(bufferActivity(Buffer::ActivityLevel, Buffer *)));
+ _networkModel, SLOT(bufferActivity(Buffer::ActivityLevel, Buffer *)));
SignalProxy *p = signalProxy();
p->attachSignal(this, SIGNAL(sendSessionData(const QString &, const QVariant &)),
blockSize = 0;
/* Clear internal data. Hopefully nothing relies on it at this point. */
- _bufferModel->clear();
+ _networkModel->clear();
QHash<uint, Buffer *>::iterator bufferIter = _buffers.begin();
while(bufferIter != _buffers.end()) {
NetworkInfo *netinfo = new NetworkInfo(netid, this);
netinfo->setProxy(signalProxy());
- bufferModel()->attachNetworkInfo(netinfo);
+ networkModel()->attachNetworkInfo(netinfo);
if(!isConnected()) {
connect(netinfo, SIGNAL(initDone()), this, SLOT(updateCoreConnectionProgress()));
class AbstractUi;
class AbstractUiMsg;
-class BufferTreeModel;
+class NetworkModel;
class SignalProxy;
class QTimer;
static BufferInfo statusBufferInfo(QString net);
static BufferInfo bufferInfo(QString net, QString buf);
- static BufferTreeModel *bufferModel();
+ static NetworkModel *networkModel();
static SignalProxy *signalProxy();
static AbstractUiMsg *layoutMsg(const Message &);
QPointer<QIODevice> socket;
QPointer<SignalProxy> _signalProxy;
QPointer<AbstractUi> mainUi;
- QPointer<BufferTreeModel> _bufferModel;
+ QPointer<NetworkModel> _networkModel;
ClientMode clientMode;
}
AbstractTreeItem::~AbstractTreeItem() {
+ AbstractTreeItem *child;
foreach(int key, _childItems.keys()) {
- qDeleteAll(_childItems[key]);
+ QList<AbstractTreeItem *>::iterator iter = _childItems[key].begin();
+ while(iter != _childItems[key].end()) {
+ child = *iter;
+ iter = _childItems[key].erase(iter);
+ disconnect(child, 0, this, 0);
+ child->deleteLater();
+ }
}
}
AbstractTreeItem *treeitem = _childItems[column].value(row);
_childItems[column].removeAt(row);
_childHash[column].remove(_childHash[column].key(treeitem));
+ disconnect(treeitem, 0, this, 0);
treeitem->deleteLater();
}
return -1;
QHash<int, QList<AbstractTreeItem*> >::const_iterator iter = _parentItem->_childItems.constBegin();
- int pos;
while(iter != _parentItem->_childItems.constEnd()) {
- pos = iter.value().indexOf(const_cast<AbstractTreeItem *>(this));
- if(pos != -1)
+ if(iter.value().contains(const_cast<AbstractTreeItem *>(this)))
return iter.key();
iter++;
}
qWarning() << "AbstractTreeItem::childDestroyed() received null pointer!";
return;
}
- _childItems[item->column()].removeAt(item->row());
- _childHash[item->column()].remove(_childHash[item->column()].key(item));
+
+ QHash<int, QList<AbstractTreeItem*> >::const_iterator iter = _childItems.constBegin();
+ int column, row = -1;
+ while(iter != _childItems.constEnd()) {
+ row = iter.value().indexOf(item);
+ if(row != -1) {
+ column = iter.key();
+ break;
+ }
+ iter++;
+ }
+
+ if(row == -1) {
+ qWarning() << "AbstractTreeItem::childDestroyed(): unknown Child died:" << item << "parent:" << this;
+ return;
+ }
+
+ _childItems[column].removeAt(row);
+ _childHash[column].remove(_childHash[column].key(item));
+ emit childDestroyed(row);
}
/*****************************************
}
int TreeModel::columnCount(const QModelIndex &parent) const {
- if(parent.isValid())
- return static_cast<AbstractTreeItem*>(parent.internalPointer())->columnCount();
- else
- return rootItem->columnCount();
+ Q_UNUSED(parent)
+ // since there the Qt Views don't draw more columns than the header has columns
+ // we can be lazy and simply return the count of header columns
+ // actually this gives us more freedom cause we don't have to ensure that a rows parent
+ // has equal or more columns than that row
+
+// if(parent.isValid()) {
+// AbstractTreeItem *child;
+// if(child = static_cast<AbstractTreeItem *>(parent.internalPointer())->child(parent.column(), parent.row()))
+// return child->columnCount();
+// else
+// return static_cast<AbstractTreeItem*>(parent.internalPointer())->columnCount();
+// } else {
+// return rootItem->columnCount();
+// }
+
+ return rootItem->columnCount();
}
QVariant TreeModel::data(const QModelIndex &index, int role) const {
void TreeModel::appendChild(AbstractTreeItem *parent, AbstractTreeItem *child) {
if(parent == 0 or child == 0) {
- qWarning() << "TreeModel::apendChild(parent, child) parent and child have to be valid pointers!" << parent << child;
+ qWarning() << "TreeModel::appendChild(parent, child) parent and child have to be valid pointers!" << parent << child;
return;
}
connect(child, SIGNAL(dataChanged(int)),
this, SLOT(itemDataChanged(int)));
+
+ connect(child, SIGNAL(newChild(AbstractTreeItem *)),
+ this, SLOT(newChild(AbstractTreeItem *)));
+
+ connect(child, SIGNAL(childDestroyed(int)),
+ this, SLOT(childDestroyed(int)));
}
+void TreeModel::newChild(AbstractTreeItem *child) {
+ appendChild(static_cast<AbstractTreeItem *>(sender()), child);
+}
+
+void TreeModel::childDestroyed(int row) {
+ QModelIndex parent = indexByItem(static_cast<AbstractTreeItem *>(sender()));
+ beginRemoveRows(parent, row, row);
+ endRemoveRows();
+}
bool TreeModel::removeRow(int row, const QModelIndex &parent) {
if(row > rowCount(parent))
signals:
void dataChanged(int column);
+ void newChild(AbstractTreeItem *);
+ void childDestroyed(int row);
private slots:
void childDestroyed();
private slots:
void itemDataChanged(int column);
+ void newChild(AbstractTreeItem *child);
+ void childDestroyed(int row);
protected:
void appendChild(AbstractTreeItem *parent, AbstractTreeItem *child);
DEPMOD = common
-QT_MOD = core network sql
+QT_MOD = core network sql script
SRCS = core.cpp coresession.cpp coresettings.cpp server.cpp sqlitestorage.cpp storage.cpp basichandler.cpp ircserverhandler.cpp userinputhandler.cpp ctcphandler.cpp
HDRS = core.h coresession.h coresettings.h server.h sqlitestorage.h storage.h basichandler.h ircserverhandler.h userinputhandler.h ctcphandler.h
#include "util.h"
+#include <QtScript>
CoreSession::CoreSession(UserId uid, Storage *_storage, QObject *parent)
: QObject(parent),
user(uid),
_signalProxy(new SignalProxy(SignalProxy::Server, 0, this)),
- storage(_storage)
+ storage(_storage),
+ scriptEngine(new QScriptEngine(this))
{
QSettings s;
if(list.count()) connectToIrc(list);
*/
+ initScriptEngine();
}
CoreSession::~CoreSession() {
}
if(log.count() > 0) emit backlogData(id, log, true);
}
+
+
+void CoreSession::initScriptEngine() {
+ signalProxy()->attachSlot(SIGNAL(scriptRequest(QString)), this, SLOT(scriptRequest(QString)));
+ signalProxy()->attachSignal(this, SIGNAL(scriptResult(QString)));
+
+ QScriptValue storage_ = scriptEngine->newQObject(storage);
+ scriptEngine->globalObject().setProperty("storage", storage_);
+}
+
+void CoreSession::scriptRequest(QString script) {
+ emit scriptResult(scriptEngine->evaluate(script).toString());
+}
+
class SignalProxy;
class Storage;
+class QScriptEngine;
+
class CoreSession : public QObject {
Q_OBJECT
void sessionDataChanged(const QString &key);
void sessionDataChanged(const QString &key, const QVariant &data);
+ void scriptResult(QString result);
+
private slots:
void recvStatusMsgFromServer(QString msg);
void recvMessageFromServer(Message::Type, QString target, QString text, QString sender = "", quint8 flags = Message::None);
void serverConnected(uint networkid);
void serverDisconnected(uint networkid);
+ void scriptRequest(QString script);
+
private:
+ void initScriptEngine();
+
UserId user;
SignalProxy *_signalProxy;
QVariantMap sessionData;
QMutex mutex;
+
+ QScriptEngine *scriptEngine;
};
#endif
}
void IrcServerHandler::handleMode(QString prefix, QList<QByteArray> params) {
- Q_UNUSED(prefix)
- Q_UNUSED(params)
-
+ if(networkInfo()->isChannelName(params[0])) {
+ } else {
+ }
// if(isChannelName(params[0])) {
// // TODO only channel-user modes supported by now
// QString prefixes = serverSupports["PrefixModes"].toString();
SqliteStorage();
virtual ~SqliteStorage();
+ public slots:
/* General */
static bool isAvailable();
Storage() {};
virtual ~Storage() {};
+ public slots:
/* General */
//! Check if the storage type is available.
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2005-07 by the Quassel IRC Team *
+ * devel@quassel-irc.org *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) version 3. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+
+#include "debugconsole.h"
+#include "client.h"
+#include "signalproxy.h"
+
+DebugConsole::DebugConsole(QWidget *parent)
+ : QDialog(parent)
+{
+ ui.setupUi(this);
+
+ Client::signalProxy()->attachSignal(this, SIGNAL(scriptRequest(QString)));
+ Client::signalProxy()->attachSlot(SIGNAL(scriptResult(QString)), this, SLOT(scriptResult(QString)));
+
+}
+
+DebugConsole::~DebugConsole() {
+}
+
+void DebugConsole::on_evalButton_clicked() {
+ if(ui.selectCore->isChecked()) {
+ emit scriptRequest(ui.scriptEdit->toPlainText());
+ }
+}
+
+void DebugConsole::scriptResult(QString result) {
+ ui.resultLabel->setText(result);
+}
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2005-07 by the Quassel IRC Team *
+ * devel@quassel-irc.org *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) version 3. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+
+#ifndef DEBUGCONSOLE_H
+#define DEBUGCONSOLE_H
+
+#include "ui_debugconsole.h"
+
+class DebugConsole : public QDialog {
+ Q_OBJECT
+
+public:
+ DebugConsole(QWidget *parent = 0);
+ virtual ~DebugConsole();
+
+public slots:
+ void scriptResult(QString result);
+
+signals:
+ void scriptRequest(QString script);
+
+private slots:
+ void on_evalButton_clicked();
+
+private:
+ Ui::DebugConsole ui;
+};
+
+#endif
#include "settingspages/fontssettingspage.h"
+#include "debugconsole.h"
+
MainWin::MainWin(QtUi *_gui, QWidget *parent) : QMainWindow(parent), gui(_gui) {
ui.setupUi(this);
setWindowTitle("Quassel IRC");
statusBar()->showMessage(tr("Waiting for core..."));
serverListDlg = new ServerListDlg(this);
settingsDlg = new SettingsDlg(this);
-
+ debugConsole = new DebugConsole(this);
}
void MainWin::init() {
setDockNestingEnabled(true);
- // TESTING
+ // new Topic Stuff... should be probably refactored out into a separate method
+
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
TopicWidget *topicwidget = new TopicWidget(dock);
dock->setWidget(topicwidget);
- Client::bufferModel()->mapProperty(1, Qt::DisplayRole, topicwidget, "topic");
+ Client::networkModel()->mapProperty(1, Qt::DisplayRole, topicwidget, "topic");
addDockWidget(Qt::TopDockWidgetArea, dock);
ui.menuViews->addAction(dock->toggleViewAction());
//showSettingsDlg();
+
+
}
MainWin::~MainWin() {
connect(ui.actionNetworkList, SIGNAL(triggered()), this, SLOT(showServerList()));
connect(ui.actionEditIdentities, SIGNAL(triggered()), serverListDlg, SLOT(editIdentities()));
connect(ui.actionSettingsDlg, SIGNAL(triggered()), this, SLOT(showSettingsDlg()));
+ connect(ui.actionDebug_Console, SIGNAL(triggered()), this, SLOT(showDebugConsole()));
//ui.actionSettingsDlg->setEnabled(false);
connect(ui.actionAboutQt, SIGNAL(triggered()), QApplication::instance(), SLOT(aboutQt()));
}
void MainWin::setupViews() {
- BufferTreeModel *model = Client::bufferModel();
+ NetworkModel *model = Client::networkModel();
connect(model, SIGNAL(bufferSelected(Buffer *)), this, SLOT(showBuffer(Buffer *)));
addBufferView(tr("All Buffers"), model, BufferViewFilter::AllNets, QList<uint>());
//create the view and initialize it's filter
BufferView *view = new BufferView(dock);
view->setFilteredModel(model, mode, nets);
- Client::bufferModel()->synchronizeView(view);
+ Client::networkModel()->synchronizeView(view);
dock->setWidget(view);
addDockWidget(Qt::LeftDockWidgetArea, dock);
settingsDlg->show();
}
+void MainWin::showDebugConsole() {
+ debugConsole->show();
+}
+
void MainWin::closeEvent(QCloseEvent *event)
{
//if (userReallyWantsToQuit()) {
class Message;
class NickListWidget;
+class DebugConsole;
+
//!\brief The main window of Quassel's QtUi.
class MainWin : public QMainWindow {
Q_OBJECT
void showServerList();
void showSettingsDlg();
+ void showDebugConsole();
void showCoreConnectionDlg(bool autoConnect = false);
void coreConnectionDlgFinished(int result);
QDockWidget *nickDock;
NickListWidget *nickListWidget;
+ DebugConsole *debugConsole;
friend class QtUi;
};
SRCS += bufferwidget.cpp chatline-old.cpp \
chatwidget.cpp coreconnectdlg.cpp configwizard.cpp \
guisettings.cpp identities.cpp mainwin.cpp nicklistwidget.cpp qtui.cpp qtuistyle.cpp serverlist.cpp settingsdlg.cpp \
- topicwidget.cpp
+ topicwidget.cpp debugconsole.cpp
HDRS += bufferwidget.h chatline-old.h chatwidget.h configwizard.h \
coreconnectdlg.h guisettings.h identities.h mainwin.h nicklistwidget.h qtui.h qtuistyle.h serverlist.h settingsdlg.h \
- topicwidget.h
+ topicwidget.h debugconsole.h
FORMNAMES = identitiesdlg.ui identitieseditdlg.ui networkeditdlg.ui mainwin.ui nickeditdlg.ui serverlistdlg.ui \
servereditdlg.ui coreconnectdlg.ui bufferviewwidget.ui bufferwidget.ui nicklistwidget.ui settingsdlg.ui \
- buffermgmtpage.ui connectionpage.ui usermgmtpage.ui topicwidget.ui
+ buffermgmtpage.ui connectionpage.ui usermgmtpage.ui topicwidget.ui debugconsole.ui
for(ui, FORMNAMES) {
FRMS += ui/$${ui}
--- /dev/null
+<ui version="4.0" >
+ <class>DebugConsole</class>
+ <widget class="QDialog" name="DebugConsole" >
+ <property name="geometry" >
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>490</width>
+ <height>435</height>
+ </rect>
+ </property>
+ <property name="windowTitle" >
+ <string>Debug Console</string>
+ </property>
+ <layout class="QVBoxLayout" >
+ <property name="spacing" >
+ <number>2</number>
+ </property>
+ <property name="leftMargin" >
+ <number>3</number>
+ </property>
+ <property name="topMargin" >
+ <number>3</number>
+ </property>
+ <property name="rightMargin" >
+ <number>3</number>
+ </property>
+ <property name="bottomMargin" >
+ <number>3</number>
+ </property>
+ <item>
+ <layout class="QHBoxLayout" >
+ <property name="spacing" >
+ <number>10</number>
+ </property>
+ <item>
+ <spacer>
+ <property name="orientation" >
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" >
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QRadioButton" name="selectLocal" >
+ <property name="text" >
+ <string>local</string>
+ </property>
+ <property name="checked" >
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QRadioButton" name="selectCore" >
+ <property name="text" >
+ <string>core</string>
+ </property>
+ <property name="checked" >
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer>
+ <property name="orientation" >
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" >
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <widget class="QTextEdit" name="scriptEdit" />
+ </item>
+ <item>
+ <widget class="QPushButton" name="evalButton" >
+ <property name="text" >
+ <string>Evaluate!</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLabel" name="resultLabel" >
+ <property name="text" >
+ <string/>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
<x>0</x>
<y>0</y>
<width>800</width>
- <height>28</height>
+ <height>22</height>
</rect>
</property>
<widget class="QMenu" name="menuConnection" >
<property name="title" >
<string>Debug</string>
</property>
+ <addaction name="actionDebug_Console" />
</widget>
<widget class="QMenu" name="menuCore" >
<property name="title" >
<addaction name="menuViews" />
<addaction name="menuCore" />
<addaction name="menuSettings" />
- <addaction name="menuHelp" />
<addaction name="menuDebug" />
+ <addaction name="menuHelp" />
</widget>
<widget class="QStatusBar" name="statusbar" />
<action name="actionNetworkList" >
<string>Connect to Core...</string>
</property>
</action>
+ <action name="actionDebug_Console" >
+ <property name="text" >
+ <string>Debug &Console</string>
+ </property>
+ </action>
</widget>
<customwidgets>
<customwidget>
if(parent != QModelIndex())
return QSortFilterProxyModel::dropMimeData(data, action, row, column, parent);
- if(!BufferTreeModel::mimeContainsBufferList(data))
+ if(!NetworkModel::mimeContainsBufferList(data))
return false;
- QList< QPair<uint, uint> > bufferList = BufferTreeModel::mimeDataToBufferList(data);
+ QList< QPair<uint, uint> > bufferList = NetworkModel::mimeDataToBufferList(data);
uint netId, bufferId;
for(int i = 0; i < bufferList.count(); i++) {
return; // only child elements can be deleted
bool lastBuffer = (rowCount(index.parent()) == 1);
- uint netId = index.data(BufferTreeModel::NetworkIdRole).toUInt();
- uint bufferuid = index.data(BufferTreeModel::BufferUidRole).toUInt();
+ uint netId = index.data(NetworkModel::NetworkIdRole).toUInt();
+ uint bufferuid = index.data(NetworkModel::BufferUidRole).toUInt();
if(buffers.contains(bufferuid)) {
buffers.remove(bufferuid);
bool BufferViewFilter::filterAcceptBuffer(const QModelIndex &source_bufferIndex) const {
- Buffer::Type bufferType = (Buffer::Type) source_bufferIndex.data(BufferTreeModel::BufferTypeRole).toInt();
+ Buffer::Type bufferType = (Buffer::Type) source_bufferIndex.data(NetworkModel::BufferTypeRole).toInt();
if((mode & NoChannels) && bufferType == Buffer::ChannelType)
return false;
if((mode & NoServers) && bufferType == Buffer::StatusType)
return false;
-// bool isActive = source_bufferIndex.data(BufferTreeModel::BufferActiveRole).toBool();
+// bool isActive = source_bufferIndex.data(NetworkModel::BufferActiveRole).toBool();
// if((mode & NoActive) && isActive)
// return false;
// if((mode & NoInactive) && !isActive)
// return false;
if((mode & FullCustom)) {
- uint bufferuid = source_bufferIndex.data(BufferTreeModel::BufferUidRole).toUInt();
+ uint bufferuid = source_bufferIndex.data(NetworkModel::BufferUidRole).toUInt();
return buffers.contains(bufferuid);
}
}
bool BufferViewFilter::filterAcceptNetwork(const QModelIndex &source_index) const {
- uint net = source_index.data(BufferTreeModel::NetworkIdRole).toUInt();
+ uint net = source_index.data(NetworkModel::NetworkIdRole).toUInt();
return !((mode & (SomeNets | FullCustom)) && !networks.contains(net));
}
}
bool BufferViewFilter::lessThan(const QModelIndex &left, const QModelIndex &right) const {
- int lefttype = left.data(BufferTreeModel::BufferTypeRole).toInt();
- int righttype = right.data(BufferTreeModel::BufferTypeRole).toInt();
+ int lefttype = left.data(NetworkModel::BufferTypeRole).toInt();
+ int righttype = right.data(NetworkModel::BufferTypeRole).toInt();
if(lefttype != righttype)
return lefttype < righttype;
projects / quassel.git / commitdiff