src/common/main.cpp
src/common/message.cpp
src/common/message.h
+src/common/network.cpp
+src/common/network.h
src/common/networkinfo.cpp
src/common/networkinfo.h
src/common/settings.cpp
src/common/util.cpp
src/common/util.h
src/core
+src/core/abstractsqlstorage.cpp
+src/core/abstractsqlstorage.h
src/core/basichandler.cpp
src/core/basichandler.h
src/core/core.cpp
src/core/ctcphandler.h
src/core/ircserverhandler.cpp
src/core/ircserverhandler.h
+src/core/networkconnection.cpp
+src/core/networkconnection.h
src/core/server.cpp
src/core/server.h
src/core/sqlitestorage.cpp
}
bool Buffer::isActive() const {
- // FIXME determine status by checking for a networkInfo objekt
+ // FIXME determine status by checking for a network objekt
return true;
}
#include "ircchannel.h"
#include "ircuser.h"
#include "message.h"
-#include "networkinfo.h"
+#include "network.h"
#include "networkmodel.h"
#include "buffermodel.h"
#include "quasselui.h"
/*** public static methods ***/
-QList<NetworkInfo *> Client::networkInfos() {
- return instance()->_networkInfo.values();
+QList<Network *> Client::networks() {
+ return instance()->_network.values();
}
-NetworkInfo *Client::networkInfo(uint networkid) {
- if(instance()->_networkInfo.contains(networkid))
- return instance()->_networkInfo[networkid];
+Network *Client::network(uint networkid) {
+ if(instance()->_network.contains(networkid))
+ return instance()->_network[networkid];
else
return 0;
}
Q_ASSERT(_buffers.isEmpty());
- QHash<NetworkId, NetworkInfo*>::iterator netIter = _networkInfo.begin();
- while(netIter != _networkInfo.end()) {
- NetworkInfo *net = netIter.value();
+ QHash<NetworkId, Network*>::iterator netIter = _network.begin();
+ while(netIter != _network.end()) {
+ Network *net = netIter.value();
disconnect(net, SIGNAL(destroyed()), this, 0);
- netIter = _networkInfo.erase(netIter);
+ netIter = _network.erase(netIter);
net->deleteLater();
}
- Q_ASSERT(_networkInfo.isEmpty());
+ Q_ASSERT(_network.isEmpty());
QHash<IdentityId, Identity*>::iterator idIter = _identities.begin();
while(idIter != _identities.end()) {
buffer(vid.value<BufferInfo>()); // create all buffers, so we see them in the network views
}
- // create networkInfo objects
+ // create network objects
QVariantList networkids = sessionState["Networks"].toList();
foreach(QVariant networkid, networkids) {
networkConnected(networkid.toUInt());
// 2.) channels
// 3.) ircusers
- int numNets = networkInfos().count();
+ int numNets = networks().count();
int numNetsWaiting = 0;
int numIrcUsers = 0;
int numChannels = 0;
int numChannelsWaiting = 0;
- foreach(NetworkInfo *net, networkInfos()) {
+ foreach(Network *net, networks()) {
if(! net->initialized())
numNetsWaiting++;
emit coreConnectionProgress(1,1);
emit connected();
emit coreConnectionStateChanged(true);
- foreach(NetworkInfo *net, networkInfos()) {
+ foreach(Network *net, networks()) {
disconnect(net, 0, this, SLOT(updateCoreConnectionProgress()));
}
//Buffer *b = buffer(id);
//b->setActive(true);
- NetworkInfo *netinfo = new NetworkInfo(netid, this);
+ Network *netinfo = new Network(netid, this);
netinfo->setProxy(signalProxy());
- networkModel()->attachNetworkInfo(netinfo);
+ networkModel()->attachNetwork(netinfo);
if(!isConnected()) {
connect(netinfo, SIGNAL(initDone()), this, SLOT(updateCoreConnectionProgress()));
connect(netinfo, SIGNAL(ircChannelInitDone()), this, SLOT(updateCoreConnectionProgress()));
}
connect(netinfo, SIGNAL(ircChannelAdded(QString)), this, SLOT(ircChannelAdded(QString)));
- connect(netinfo, SIGNAL(destroyed()), this, SLOT(networkInfoDestroyed()));
- _networkInfo[netid] = netinfo;
+ connect(netinfo, SIGNAL(destroyed()), this, SLOT(networkDestroyed()));
+ _network[netid] = netinfo;
}
void Client::networkDisconnected(uint networkid) {
buffer->setActive(false);
}
- Q_ASSERT(networkInfo(networkid));
- if(!networkInfo(networkid)->initialized()) {
+ Q_ASSERT(network(networkid));
+ if(!network(networkid)->initialized()) {
qDebug() << "Network" << networkid << "disconnected while not yet initialized!";
updateCoreConnectionProgress();
}
}
void Client::ircChannelAdded(QString chanName) {
- NetworkInfo *netInfo = qobject_cast<NetworkInfo*>(sender());
+ Network *netInfo = qobject_cast<Network*>(sender());
Q_ASSERT(netInfo);
Buffer *buf = buffer(bufferInfo(netInfo->networkName(), chanName));
Q_ASSERT(buf);
_buffers.remove(bufferUid);
}
-void Client::networkInfoDestroyed() {
- NetworkInfo *netinfo = static_cast<NetworkInfo *>(sender());
+void Client::networkDestroyed() {
+ Network *netinfo = static_cast<Network *>(sender());
uint networkId = netinfo->networkId();
- if(_networkInfo.contains(networkId))
- _networkInfo.remove(networkId);
+ if(_network.contains(networkId))
+ _network.remove(networkId);
}
void Client::recvMessage(const Message &msg) {
class Message;
class Identity;
-class NetworkInfo;
+class Network;
class AbstractUi;
static void destroy();
static void init(AbstractUi *);
- static QList<NetworkInfo *> networkInfos();
- static NetworkInfo *networkInfo(uint networkid);
+ static QList<Network *> networks();
+ static Network *network(uint networkid);
static QList<BufferInfo> allBufferInfos();
static QList<Buffer *> buffers();
void layoutMsg();
void bufferDestroyed();
- void networkInfoDestroyed();
+ void networkDestroyed();
void ircChannelAdded(QString);
void coreIdentityCreated(const Identity &);
void coreIdentityRemoved(IdentityId);
QVariantMap coreConnectionInfo;
QHash<BufferId, Buffer *> _buffers;
- QHash<NetworkId, NetworkInfo *> _networkInfo;
+ QHash<NetworkId, Network *> _network;
QHash<IdentityId, Identity *> _identities;
QTimer *layoutTimer;
#include "bufferinfo.h"
#include "client.h"
#include "signalproxy.h"
-#include "networkinfo.h"
+#include "network.h"
#include "ircchannel.h"
#include "ircuser.h"
}
QString NetworkItem::networkName() const {
- if(_networkInfo)
- return _networkInfo->networkName();
+ if(_network)
+ return _network->networkName();
else
return _networkName;
}
QString NetworkItem::currentServer() const {
- if(_networkInfo)
- return _networkInfo->currentServer();
+ if(_network)
+ return _network->currentServer();
else
return QString();
}
return count;
}
-void NetworkItem::attachNetworkInfo(NetworkInfo *networkInfo) {
- if(!networkInfo)
+void NetworkItem::attachNetwork(Network *network) {
+ if(!network)
return;
- _networkInfo = networkInfo;
+ _network = network;
- connect(networkInfo, SIGNAL(networkNameSet(QString)),
+ connect(network, SIGNAL(networkNameSet(QString)),
this, SLOT(setNetworkName(QString)));
- connect(networkInfo, SIGNAL(currentServerSet(QString)),
+ connect(network, SIGNAL(currentServerSet(QString)),
this, SLOT(setCurrentServer(QString)));
- connect(networkInfo, SIGNAL(ircChannelAdded(QString)),
+ connect(network, SIGNAL(ircChannelAdded(QString)),
this, SLOT(attachIrcChannel(QString)));
// FIXME: connect this and that...
}
void NetworkItem::attachIrcChannel(const QString &channelName) {
- IrcChannel *ircChannel = _networkInfo->ircChannel(channelName);
+ IrcChannel *ircChannel = _network->ircChannel(channelName);
if(!ircChannel) {
qWarning() << "NetworkItem::attachIrcChannel(): unkown Channel" << channelName;
return;
return true;
}
-void NetworkModel::attachNetworkInfo(NetworkInfo *networkInfo) {
- NetworkItem *networkItem = network(networkInfo->networkId());
+void NetworkModel::attachNetwork(Network *net) {
+ NetworkItem *networkItem = network(net->networkId());
if(!networkItem) {
- qWarning() << "NetworkModel::attachNetworkInfo(): network is unknown!";
+ qWarning() << "NetworkModel::attachNetwork(): network is unknown!";
return;
}
- networkItem->attachNetworkInfo(networkInfo);
+ networkItem->attachNetwork(net);
}
void NetworkModel::bufferUpdated(Buffer *buffer) {
#include "modelpropertymapper.h"
class MappedSelectionModel;
class QAbstractItemView;
-class NetworkInfo;
+class Network;
class IrcChannel;
class IrcUser;
void setNetworkName(const QString &networkName);
void setCurrentServer(const QString &serverName);
- void attachNetworkInfo(NetworkInfo *networkInfo);
+ void attachNetwork(Network *network);
void attachIrcChannel(const QString &channelName);
private:
uint _networkId;
QString _networkName;
- QPointer<NetworkInfo> _networkInfo;
+ QPointer<Network> _network;
};
/*****************************************
virtual QMimeData *mimeData(const QModelIndexList &) const;
virtual bool dropMimeData(const QMimeData *, Qt::DropAction, int, int, const QModelIndex &);
- void attachNetworkInfo(NetworkInfo *networkInfo);
+ void attachNetwork(Network *network);
bool isBufferIndex(const QModelIndex &) const;
Buffer *getBufferByIndex(const QModelIndex &) const;
int NickModel::categoryFromModes(const QString &modes) const {
int cat;
- // we hardcode this even though we have PREFIX in networkinfo... but that wouldn't help with mapping modes to
+ // we hardcode this even though we have PREFIX in network... but that wouldn't help with mapping modes to
// category strings anyway.
if(modes.contains('q')) cat = 1;
else if(modes.contains('a')) cat = 2;
if(isChannelName(_bufferName))
return _bufferName;
else
- return nickFromMask(_bufferName); // FIXME get rid of global functions and use the NetworkInfo stuff instead!
+ return nickFromMask(_bufferName); // FIXME get rid of global functions and use the Network stuff instead!
}
QDebug operator<<(QDebug dbg, const BufferInfo &b) {
DEPMOD =
QT_MOD = network
SRCS += bufferinfo.cpp global.cpp identity.cpp logger.cpp message.cpp settings.cpp signalproxy.cpp syncableobject.cpp \
- util.cpp networkinfo.cpp ircuser.cpp ircchannel.cpp
+ util.cpp network.cpp ircuser.cpp ircchannel.cpp
HDRS += bufferinfo.h global.h identity.h logger.h message.h settings.h signalproxy.h syncableobject.h \
- util.h networkinfo.h ircuser.h ircchannel.h types.h
+ util.h network.h ircuser.h ircchannel.h types.h
//#define DEVELMODE
/** The protocol version we use fo the communication between core and GUI */
-#define GUI_PROTOCOL 4
+#define GUI_PROTOCOL 5
//#define DEFAULT_PORT 4242
#include "ircchannel.h"
-#include "networkinfo.h"
+#include "network.h"
//#include "nicktreemodel.h"
#include "signalproxy.h"
#include "ircuser.h"
#include <QDebug>
-IrcChannel::IrcChannel(const QString &channelname, NetworkInfo *networkinfo)
- : SyncableObject(networkinfo),
+IrcChannel::IrcChannel(const QString &channelname, Network *network)
+ : SyncableObject(network),
_initialized(false),
_name(channelname),
_topic(QString()),
- networkInfo(networkinfo)
+ network(network)
{
- setObjectName(QString::number(networkInfo->networkId()) + "/" + channelname);
+ setObjectName(QString::number(network->networkId()) + "/" + channelname);
}
IrcChannel::~IrcChannel() {
}
QString IrcChannel::userModes(const QString &nick) const {
- return userModes(networkInfo->ircUser(nick));
+ return userModes(network->ircUser(nick));
}
QTextCodec *IrcChannel::codecForEncoding() const {
}
QString IrcChannel::decodeString(const QByteArray &text) const {
- if(!codecForDecoding()) return networkInfo->decodeString(text);
+ if(!codecForDecoding()) return network->decodeString(text);
return ::decodeString(text, _codecForDecoding);
}
if(codecForEncoding()) {
return _codecForEncoding->fromUnicode(string);
}
- return networkInfo->encodeString(string);
+ return network->encodeString(string);
}
// ====================
}
void IrcChannel::join(const QString &nick) {
- join(networkInfo->ircUser(nick));
+ join(network->ircUser(nick));
}
void IrcChannel::part(IrcUser *ircuser) {
}
void IrcChannel::part(const QString &nick) {
- part(networkInfo->ircUser(nick));
+ part(network->ircUser(nick));
}
// SET USER MODE
}
void IrcChannel::setUserModes(const QString &nick, const QString &modes) {
- setUserModes(networkInfo->ircUser(nick), modes);
+ setUserModes(network->ircUser(nick), modes);
}
// ADD USER MODE
}
void IrcChannel::addUserMode(const QString &nick, const QString &mode) {
- addUserMode(networkInfo->ircUser(nick), mode);
+ addUserMode(network->ircUser(nick), mode);
}
// REMOVE USER MODE
}
void IrcChannel::removeUserMode(const QString &nick, const QString &mode) {
- removeUserMode(networkInfo->ircUser(nick), mode);
+ removeUserMode(network->ircUser(nick), mode);
}
// INIT SET USER MODES
#include "syncableobject.h"
class IrcUser;
-class NetworkInfo;
+class Network;
class SignalProxy;
class IrcChannel : public SyncableObject {
Q_PROPERTY(QString topic READ topic WRITE setTopic STORED false)
public:
- IrcChannel(const QString &channelname, NetworkInfo *networkInfo);
+ IrcChannel(const QString &channelname, Network *network);
~IrcChannel();
bool isKnownUser(IrcUser *ircuser) const;
QHash<IrcUser *, QString> _userModes;
- NetworkInfo *networkInfo;
+ Network *network;
QTextCodec *_codecForEncoding;
QTextCodec *_codecForDecoding;
#include "ircuser.h"
#include "util.h"
-#include "networkinfo.h"
+#include "network.h"
#include "signalproxy.h"
#include "ircchannel.h"
#include <QTextCodec>
#include <QDebug>
-IrcUser::IrcUser(const QString &hostmask, NetworkInfo *networkinfo)
- : SyncableObject(networkinfo),
+IrcUser::IrcUser(const QString &hostmask, Network *network)
+ : SyncableObject(network),
_initialized(false),
_nick(nickFromMask(hostmask)),
_user(userFromMask(hostmask)),
_host(hostFromMask(hostmask)),
- networkInfo(networkinfo),
+ _network(network),
_codecForEncoding(0),
_codecForDecoding(0)
{
return chanList;
}
+Network* IrcUser::network() const {
+ return _network;
+}
+
QTextCodec *IrcUser::codecForEncoding() const {
return _codecForEncoding;
}
}
QString IrcUser::decodeString(const QByteArray &text) const {
- if(!codecForDecoding()) return networkInfo->decodeString(text);
+ if(!codecForDecoding()) return network()->decodeString(text);
return ::decodeString(text, codecForDecoding());
}
if(codecForEncoding()) {
return codecForEncoding()->fromUnicode(string);
}
- return networkInfo->encodeString(string);
+ return network()->encodeString(string);
}
// ====================
}
void IrcUser::updateObjectName() {
- QString newName = QString::number(networkInfo->networkId()) + "/" + _nick;
+ QString newName = QString::number(network()->networkId()) + "/" + _nick;
QString oldName = objectName();
if(oldName != newName) {
setObjectName(newName);
}
void IrcUser::joinChannel(const QString &channelname) {
- joinChannel(networkInfo->newIrcChannel(channelname));
+ joinChannel(network()->newIrcChannel(channelname));
}
void IrcUser::partChannel(IrcChannel *channel) {
}
void IrcUser::partChannel(const QString &channelname) {
- IrcChannel *channel = networkInfo->ircChannel(channelname);
+ IrcChannel *channel = network()->ircChannel(channelname);
if(channel == 0) {
qWarning() << "IrcUser::partChannel(): received part for unknown Channel" << channelname;
} else {
#include "syncableobject.h"
class SignalProxy;
-class NetworkInfo;
+class Network;
class IrcChannel;
class IrcUser : public SyncableObject {
// Q_PROPERTY(QStringList usermodes READ usermodes WRITE setUsermodes)
public:
- IrcUser(const QString &hostmask, NetworkInfo *networkInfo);
+ IrcUser(const QString &hostmask, Network *network);
virtual ~IrcUser();
bool initialized() const;
QString host() const;
QString nick() const;
QString hostmask() const;
+ Network *network() const;
QString userModes() const;
QSet<IrcChannel *> _channels;
QString _userModes;
- NetworkInfo *networkInfo;
+ Network *_network;
QTextCodec *_codecForEncoding;
QTextCodec *_codecForDecoding;
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include "networkinfo.h"
+#include "network.h"
#include "signalproxy.h"
#include "ircuser.h"
// ====================
// Public:
// ====================
-NetworkInfo::NetworkInfo(const uint &networkid, QObject *parent)
+Network::Network(const uint &networkid, QObject *parent)
: SyncableObject(parent),
_networkId(networkid),
_initialized(false),
}
// I think this is unnecessary since IrcUsers have us as their daddy :)
-//NetworkInfo::~NetworkInfo() {
+//Network::~Network() {
// QHashIterator<QString, IrcUser *> ircuser(_ircUsers);
// while (ircuser.hasNext()) {
// ircuser.next();
// }
//}
-uint NetworkInfo::networkId() const {
+uint Network::networkId() const {
return _networkId;
}
-bool NetworkInfo::initialized() const {
+bool Network::initialized() const {
return _initialized;
}
-SignalProxy *NetworkInfo::proxy() const {
+SignalProxy *Network::proxy() const {
return _proxy;
}
-void NetworkInfo::setProxy(SignalProxy *proxy) {
+void Network::setProxy(SignalProxy *proxy) {
_proxy = proxy;
proxy->synchronize(this);
}
-bool NetworkInfo::isMyNick(const QString &nick) const {
+bool Network::isMyNick(const QString &nick) const {
return (myNick().toLower() == nick.toLower());
}
-bool NetworkInfo::isMyNick(IrcUser *ircuser) const {
+bool Network::isMyNick(IrcUser *ircuser) const {
return (ircuser->nick().toLower() == myNick().toLower());
}
-bool NetworkInfo::isChannelName(const QString &channelname) const {
+bool Network::isChannelName(const QString &channelname) const {
if(channelname.isEmpty())
return false;
return QString("#&!+").contains(channelname[0]);
}
-QString NetworkInfo::prefixToMode(const QString &prefix) {
+QString Network::prefixToMode(const QString &prefix) {
if(prefixes().contains(prefix))
return QString(prefixModes()[prefixes().indexOf(prefix)]);
else
return QString();
}
-QString NetworkInfo::prefixToMode(const QCharRef &prefix) {
+QString Network::prefixToMode(const QCharRef &prefix) {
return prefixToMode(QString(prefix));
}
-QString NetworkInfo::modeToPrefix(const QString &mode) {
+QString Network::modeToPrefix(const QString &mode) {
if(prefixModes().contains(mode))
return QString(prefixes()[prefixModes().indexOf(mode)]);
else
return QString();
}
-QString NetworkInfo::modeToPrefix(const QCharRef &mode) {
+QString Network::modeToPrefix(const QCharRef &mode) {
return modeToPrefix(QString(mode));
}
-QString NetworkInfo::networkName() const {
+QString Network::networkName() const {
return _networkName;
}
-QString NetworkInfo::currentServer() const {
+QString Network::currentServer() const {
return _currentServer;
}
-QString NetworkInfo::myNick() const {
+QString Network::myNick() const {
return _myNick;
}
-QStringList NetworkInfo::nicks() const {
+QStringList Network::nicks() const {
// we don't use _ircUsers.keys() since the keys may be
// not up to date after a nick change
QStringList nicks;
return nicks;
}
-QStringList NetworkInfo::channels() const {
+QStringList Network::channels() const {
return _ircChannels.keys();
}
-QString NetworkInfo::prefixes() {
+QString Network::prefixes() {
if(_prefixes.isNull())
determinePrefixes();
return _prefixes;
}
-QString NetworkInfo::prefixModes() {
+QString Network::prefixModes() {
if(_prefixModes.isNull())
determinePrefixes();
return _prefixModes;
}
-bool NetworkInfo::supports(const QString ¶m) const {
+bool Network::supports(const QString ¶m) const {
return _supports.contains(param);
}
-QString NetworkInfo::support(const QString ¶m) const {
+QString Network::support(const QString ¶m) const {
QString support_ = param.toUpper();
if(_supports.contains(support_))
return _supports[support_];
return QString();
}
-IrcUser *NetworkInfo::newIrcUser(const QString &hostmask) {
+IrcUser *Network::newIrcUser(const QString &hostmask) {
QString nick(nickFromMask(hostmask).toLower());
if(!_ircUsers.contains(nick)) {
IrcUser *ircuser = new IrcUser(hostmask, this);
if(proxy())
proxy()->synchronize(ircuser);
else
- qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call NetworkInfo::setProxy(SignalProxy *)?";
+ qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call Network::setProxy(SignalProxy *)?";
connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString)));
connect(ircuser, SIGNAL(initDone()), this, SIGNAL(ircUserInitDone()));
return _ircUsers[nick];
}
-IrcUser *NetworkInfo::newIrcUser(const QByteArray &hostmask) {
+IrcUser *Network::newIrcUser(const QByteArray &hostmask) {
return newIrcUser(decodeString(hostmask));
}
-void NetworkInfo::removeIrcUser(IrcUser *ircuser) {
+void Network::removeIrcUser(IrcUser *ircuser) {
QString nick = _ircUsers.key(ircuser);
if(nick.isNull())
return;
emit ircUserRemoved(nick);
}
-void NetworkInfo::removeIrcUser(QString nick) {
+void Network::removeIrcUser(QString nick) {
IrcUser *ircuser;
if((ircuser = ircUser(nick)) != 0)
removeIrcUser(ircuser);
}
-IrcUser *NetworkInfo::ircUser(QString nickname) const {
+IrcUser *Network::ircUser(QString nickname) const {
nickname = nickname.toLower();
if(_ircUsers.contains(nickname))
return _ircUsers[nickname];
return 0;
}
-IrcUser *NetworkInfo::ircUser(const QByteArray &nickname) const {
+IrcUser *Network::ircUser(const QByteArray &nickname) const {
return ircUser(decodeString(nickname));
}
-QList<IrcUser *> NetworkInfo::ircUsers() const {
+QList<IrcUser *> Network::ircUsers() const {
return _ircUsers.values();
}
-IrcChannel *NetworkInfo::newIrcChannel(const QString &channelname) {
+IrcChannel *Network::newIrcChannel(const QString &channelname) {
if(!_ircChannels.contains(channelname.toLower())) {
IrcChannel *channel = new IrcChannel(channelname, this);
// mark IrcUser as already initialized to keep the SignalProxy from requesting initData
if(proxy())
proxy()->synchronize(channel);
else
- qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call NetworkInfo::setProxy(SignalProxy *)?";
+ qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call Network::setProxy(SignalProxy *)?";
connect(channel, SIGNAL(initDone()), this, SIGNAL(ircChannelInitDone()));
connect(channel, SIGNAL(destroyed()), this, SLOT(channelDestroyed()));
return _ircChannels[channelname.toLower()];
}
-IrcChannel *NetworkInfo::newIrcChannel(const QByteArray &channelname) {
+IrcChannel *Network::newIrcChannel(const QByteArray &channelname) {
return newIrcChannel(decodeString(channelname));
}
-IrcChannel *NetworkInfo::ircChannel(QString channelname) {
+IrcChannel *Network::ircChannel(QString channelname) {
channelname = channelname.toLower();
if(_ircChannels.contains(channelname))
return _ircChannels[channelname];
return 0;
}
-IrcChannel *NetworkInfo::ircChannel(const QByteArray &channelname) {
+IrcChannel *Network::ircChannel(const QByteArray &channelname) {
return ircChannel(decodeString(channelname));
}
-QList<IrcChannel *> NetworkInfo::ircChannels() const {
+QList<IrcChannel *> Network::ircChannels() const {
return _ircChannels.values();
}
-QTextCodec *NetworkInfo::codecForEncoding() const {
+QTextCodec *Network::codecForEncoding() const {
return _codecForEncoding;
}
-void NetworkInfo::setCodecForEncoding(const QString &name) {
+void Network::setCodecForEncoding(const QString &name) {
setCodecForEncoding(QTextCodec::codecForName(name.toAscii()));
}
-void NetworkInfo::setCodecForEncoding(QTextCodec *codec) {
+void Network::setCodecForEncoding(QTextCodec *codec) {
_codecForEncoding = codec;
}
-QTextCodec *NetworkInfo::codecForDecoding() const {
+QTextCodec *Network::codecForDecoding() const {
return _codecForDecoding;
}
-void NetworkInfo::setCodecForDecoding(const QString &name) {
+void Network::setCodecForDecoding(const QString &name) {
setCodecForDecoding(QTextCodec::codecForName(name.toAscii()));
}
-void NetworkInfo::setCodecForDecoding(QTextCodec *codec) {
+void Network::setCodecForDecoding(QTextCodec *codec) {
_codecForDecoding = codec;
}
-QString NetworkInfo::decodeString(const QByteArray &text) const {
+QString Network::decodeString(const QByteArray &text) const {
return ::decodeString(text, _codecForDecoding);
}
-QByteArray NetworkInfo::encodeString(const QString string) const {
+QByteArray Network::encodeString(const QString string) const {
if(_codecForEncoding) {
return _codecForEncoding->fromUnicode(string);
}
// ====================
// Public Slots:
// ====================
-void NetworkInfo::setNetworkName(const QString &networkName) {
+void Network::setNetworkName(const QString &networkName) {
_networkName = networkName;
emit networkNameSet(networkName);
}
-void NetworkInfo::setCurrentServer(const QString ¤tServer) {
+void Network::setCurrentServer(const QString ¤tServer) {
_currentServer = currentServer;
emit currentServerSet(currentServer);
}
-void NetworkInfo::setMyNick(const QString &nickname) {
+void Network::setMyNick(const QString &nickname) {
_myNick = nickname;
emit myNickSet(nickname);
}
-void NetworkInfo::addSupport(const QString ¶m, const QString &value) {
+void Network::addSupport(const QString ¶m, const QString &value) {
if(!_supports.contains(param)) {
_supports[param] = value;
emit supportAdded(param, value);
}
}
-void NetworkInfo::removeSupport(const QString ¶m) {
+void Network::removeSupport(const QString ¶m) {
if(_supports.contains(param)) {
_supports.remove(param);
emit supportRemoved(param);
}
}
-QVariantMap NetworkInfo::initSupports() const {
+QVariantMap Network::initSupports() const {
QVariantMap supports;
QHashIterator<QString, QString> iter(_supports);
while(iter.hasNext()) {
return supports;
}
-QStringList NetworkInfo::initIrcUsers() const {
+QStringList Network::initIrcUsers() const {
QStringList hostmasks;
foreach(IrcUser *ircuser, ircUsers()) {
hostmasks << ircuser->hostmask();
return hostmasks;
}
-QStringList NetworkInfo::initIrcChannels() const {
+QStringList Network::initIrcChannels() const {
return _ircChannels.keys();
}
-void NetworkInfo::initSetSupports(const QVariantMap &supports) {
+void Network::initSetSupports(const QVariantMap &supports) {
QMapIterator<QString, QVariant> iter(supports);
while(iter.hasNext()) {
iter.next();
}
}
-void NetworkInfo::initSetIrcUsers(const QStringList &hostmasks) {
+void Network::initSetIrcUsers(const QStringList &hostmasks) {
if(!_ircUsers.empty())
return;
foreach(QString hostmask, hostmasks) {
}
}
-void NetworkInfo::initSetChannels(const QStringList &channels) {
+void Network::initSetChannels(const QStringList &channels) {
if(!_ircChannels.empty())
return;
foreach(QString channel, channels)
newIrcChannel(channel);
}
-IrcUser *NetworkInfo::updateNickFromMask(const QString &mask) {
+IrcUser *Network::updateNickFromMask(const QString &mask) {
QString nick(nickFromMask(mask).toLower());
IrcUser *ircuser;
return ircuser;
}
-void NetworkInfo::ircUserNickChanged(QString newnick) {
+void Network::ircUserNickChanged(QString newnick) {
QString oldnick = _ircUsers.key(qobject_cast<IrcUser*>(sender()));
if(oldnick.isNull())
setMyNick(newnick);
}
-void NetworkInfo::ircUserDestroyed() {
+void Network::ircUserDestroyed() {
IrcUser *ircuser = static_cast<IrcUser *>(sender());
Q_ASSERT(ircuser);
removeIrcUser(ircuser);
}
-void NetworkInfo::channelDestroyed() {
+void Network::channelDestroyed() {
IrcChannel *channel = static_cast<IrcChannel *>(sender());
Q_ASSERT(channel);
_ircChannels.remove(_ircChannels.key(channel));
}
-void NetworkInfo::setInitialized() {
+void Network::setInitialized() {
_initialized = true;
emit initDone();
}
// ====================
// Private:
// ====================
-void NetworkInfo::determinePrefixes() {
+void Network::determinePrefixes() {
// seems like we have to construct them first
QString PREFIX = support("PREFIX");
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#ifndef _NETWORKINFO_H_
-#define _NETWORKINFO_H_
+#ifndef _NETWORK_H_
+#define _NETWORK_H_
#include <QString>
#include <QStringList>
class IrcChannel;
-class NetworkInfo : public SyncableObject {
+class Network : public SyncableObject {
Q_OBJECT
Q_PROPERTY(QString networkName READ networkName WRITE setNetworkName STORED false)
Q_PROPERTY(QString myNick READ myNick WRITE setMyNick STORED false)
public:
- NetworkInfo(const uint &networkid, QObject *parent = 0);
- //virtual ~NetworkInfo();
+ Network(const uint &networkid, QObject *parent = 0);
+ //virtual ~Network();
NetworkId networkId() const;
bool initialized() const;
#include <QMetaMethod>
-// TODO Use versions from NetworkInfo instead
+// TODO Use versions from Network instead
QString nickFromMask(QString mask);
QString userFromMask(QString mask);
QString hostFromMask(QString mask);
#include <QMetaMethod>
-#include "server.h"
+#include "networkconnection.h"
-BasicHandler::BasicHandler(Server *parent)
+BasicHandler::BasicHandler(NetworkConnection *parent)
: QObject(parent),
server(parent) {
// ====================
// protected:
// ====================
-NetworkInfo *BasicHandler::networkInfo() const {
- return server->networkInfo();
+Network *BasicHandler::network() const {
+ return server->network();
}
#include "message.h"
-class Server;
-class NetworkInfo;
+class NetworkConnection;
+class Network;
class BasicHandler : public QObject {
Q_OBJECT
public:
- BasicHandler(Server *parent = 0);
+ BasicHandler(NetworkConnection *parent = 0);
QStringList providesHandlers() const;
const QGenericArgument &val5 = QGenericArgument(), const QGenericArgument &val6 = QGenericArgument(),
const QGenericArgument &val7 = QGenericArgument(), const QGenericArgument &val8 = QGenericArgument());
- Server *server;
+ NetworkConnection *server;
protected:
- NetworkInfo *networkInfo() const;
+ Network *network() const;
};
#endif
DEPMOD = common
QT_MOD = core network sql script
-SRCS = core.cpp coresession.cpp coresettings.cpp server.cpp sqlitestorage.cpp abstractsqlstorage.cpp storage.cpp basichandler.cpp \
+SRCS = core.cpp coresession.cpp coresettings.cpp networkconnection.cpp sqlitestorage.cpp abstractsqlstorage.cpp storage.cpp basichandler.cpp \
ircserverhandler.cpp userinputhandler.cpp ctcphandler.cpp coreusersettings.cpp
-HDRS = core.h coresession.h coresettings.h server.h sqlitestorage.h abstractsqlstorage.h storage.h basichandler.h \
+HDRS = core.h coresession.h coresettings.h networkconnection.h sqlitestorage.h abstractsqlstorage.h storage.h basichandler.h \
ircserverhandler.h userinputhandler.h ctcphandler.h coreusersettings.h
***************************************************************************/
#include "coresession.h"
-#include "server.h"
+#include "networkconnection.h"
#include "signalproxy.h"
#include "storage.h"
-#include "networkinfo.h"
+#include "network.h"
#include "ircuser.h"
#include "ircchannel.h"
#include "identity.h"
createIdentity(i);
}
- p->attachSlot(SIGNAL(requestNetworkStates()), this, SLOT(serverStateRequested()));
+ p->attachSlot(SIGNAL(requestNetworkStates()), this, SLOT(networkStateRequested()));
p->attachSlot(SIGNAL(requestConnect(QString)), this, SLOT(connectToNetwork(QString)));
p->attachSlot(SIGNAL(sendInput(BufferInfo, QString)), this, SLOT(msgFromGui(BufferInfo, QString)));
p->attachSlot(SIGNAL(requestBacklog(BufferInfo, QVariant, QVariant)), this, SLOT(sendBacklog(BufferInfo, QVariant, QVariant)));
QVariant CoreSession::state() const {
QVariantMap res;
QList<QVariant> conn;
- foreach(Server *server, servers.values()) {
- if(server->isConnected()) {
+ foreach(NetworkConnection *net, connections.values()) {
+ if(net->isConnected()) {
QVariantMap m;
- m["Network"] = server->networkName();
- m["State"] = server->state();
+ m["Network"] = net->networkName();
+ m["State"] = net->state();
conn << m;
}
}
}
// FIXME switch to NetworkIDs
-void CoreSession::connectToNetwork(QString network, const QVariant &previousState) {
- uint networkid = getNetworkId(network);
+void CoreSession::connectToNetwork(QString networkname, const QVariant &previousState) {
+ uint networkid = getNetworkId(networkname);
if(networkid == 0) {
- qWarning() << "unable to connect to Network" << network << "(User:" << userId() << "): unable to determine NetworkId";
+ qWarning() << "unable to connect to Network" << networkname << "(User:" << userId() << "): unable to determine NetworkId";
return;
}
- if(!servers.contains(networkid)) {
- Server *server = new Server(userId(), networkid, network, previousState);
- servers[networkid] = server;
- attachServer(server);
- server->start();
+ if(!connections.contains(networkid)) {
+ NetworkConnection *connection = new NetworkConnection(userId(), networkid, networkname, previousState);
+ connections[networkid] = connection;
+ attachNetworkConnection(connection);
+ connection->start();
}
- emit connectToIrc(network);
+ emit connectToIrc(networkname);
}
-void CoreSession::attachServer(Server *server) {
- connect(this, SIGNAL(connectToIrc(QString)), server, SLOT(connectToIrc(QString)));
- connect(this, SIGNAL(disconnectFromIrc(QString)), server, SLOT(disconnectFromIrc(QString)));
- connect(this, SIGNAL(msgFromGui(uint, QString, QString)), server, SLOT(userInput(uint, QString, QString)));
+void CoreSession::attachNetworkConnection(NetworkConnection *network) {
+ connect(this, SIGNAL(connectToIrc(QString)), network, SLOT(connectToIrc(QString)));
+ connect(this, SIGNAL(disconnectFromIrc(QString)), network, SLOT(disconnectFromIrc(QString)));
+ connect(this, SIGNAL(msgFromGui(uint, QString, QString)), network, SLOT(userInput(uint, QString, QString)));
- connect(server, SIGNAL(connected(uint)), this, SLOT(serverConnected(uint)));
- connect(server, SIGNAL(disconnected(uint)), this, SLOT(serverDisconnected(uint)));
- connect(server, SIGNAL(displayMsg(Message::Type, QString, QString, QString, quint8)), this, SLOT(recvMessageFromServer(Message::Type, QString, QString, QString, quint8)));
- connect(server, SIGNAL(displayStatusMsg(QString)), this, SLOT(recvStatusMsgFromServer(QString)));
+ connect(network, SIGNAL(connected(uint)), this, SLOT(networkConnected(uint)));
+ connect(network, SIGNAL(disconnected(uint)), this, SLOT(networkDisconnected(uint)));
+ connect(network, SIGNAL(displayMsg(Message::Type, QString, QString, QString, quint8)), this, SLOT(recvMessageFromServer(Message::Type, QString, QString, QString, quint8)));
+ connect(network, SIGNAL(displayStatusMsg(QString)), this, SLOT(recvStatusMsgFromServer(QString)));
// connect serversignals to proxy
- signalProxy()->attachSignal(server, SIGNAL(serverState(QString, QVariantMap)), SIGNAL(networkState(QString, QVariantMap)));
- signalProxy()->attachSignal(server, SIGNAL(connected(uint)), SIGNAL(networkConnected(uint)));
- signalProxy()->attachSignal(server, SIGNAL(disconnected(uint)), SIGNAL(networkDisconnected(uint)));
+ signalProxy()->attachSignal(network, SIGNAL(networkState(QString, QVariantMap)), SIGNAL(networkState(QString, QVariantMap)));
+ signalProxy()->attachSignal(network, SIGNAL(connected(uint)), SIGNAL(networkConnected(uint)));
+ signalProxy()->attachSignal(network, SIGNAL(disconnected(uint)), SIGNAL(networkDisconnected(uint)));
// TODO add error handling
}
-void CoreSession::serverStateRequested() {
+void CoreSession::networkStateRequested() {
}
void CoreSession::addClient(QIODevice *device) {
return _signalProxy;
}
-void CoreSession::serverConnected(uint networkid) {
- storage->getBufferInfo(userId(), servers[networkid]->networkName()); // create status buffer
+void CoreSession::networkConnected(uint networkid) {
+ storage->getBufferInfo(userId(), connections[networkid]->networkName()); // create status buffer
}
-void CoreSession::serverDisconnected(uint networkid) {
- Q_ASSERT(servers.contains(networkid));
- servers.take(networkid)->deleteLater();
- Q_ASSERT(!servers.contains(networkid));
+void CoreSession::networkDisconnected(uint networkid) {
+ Q_ASSERT(connections.contains(networkid));
+ connections.take(networkid)->deleteLater();
+ Q_ASSERT(!connections.contains(networkid));
}
void CoreSession::msgFromGui(BufferInfo bufid, QString msg) {
// ALL messages coming pass through these functions before going to the GUI.
// So this is the perfect place for storing the backlog and log stuff.
void CoreSession::recvMessageFromServer(Message::Type type, QString target, QString text, QString sender, quint8 flags) {
- Server *s = qobject_cast<Server*>(this->sender());
+ NetworkConnection *s = qobject_cast<NetworkConnection*>(this->sender());
Q_ASSERT(s);
BufferInfo buf;
if((flags & Message::PrivMsg) && !(flags & Message::Self)) {
}
void CoreSession::recvStatusMsgFromServer(QString msg) {
- Server *s = qobject_cast<Server*>(sender());
+ NetworkConnection *s = qobject_cast<NetworkConnection*>(sender());
Q_ASSERT(s);
emit displayStatusMsg(s->networkName(), msg);
}
mutex.unlock();
QVariantList networks;
- foreach(NetworkId networkid, servers.keys())
+ foreach(NetworkId networkid, connections.keys())
networks.append(QVariant(networkid));
v["Networks"] = QVariant(networks);
#include "message.h"
class Identity;
-class Server;
+class NetworkConnection;
class SignalProxy;
class Storage;
SignalProxy *signalProxy() const;
- void attachServer(Server *server);
+ void attachNetworkConnection(NetworkConnection *conn);
//! Return necessary data for restoring the session after restarting the core
QVariant state() const;
//! Store a piece session-wide data and distribute it to connected clients.
void storeSessionData(const QString &key, const QVariant &data);
- void serverStateRequested();
+ void networkStateRequested();
void addClient(QIODevice *connection);
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 networkConnected(uint networkid);
+ void networkDisconnected(uint networkid);
void scriptRequest(QString script);
SignalProxy *_signalProxy;
Storage *storage;
- QHash<NetworkId, Server *> servers;
+ QHash<NetworkId, NetworkConnection *> connections;
QVariantMap sessionData;
QMutex mutex;
#include "util.h"
#include "message.h"
-CtcpHandler::CtcpHandler(Server *parent)
+CtcpHandler::CtcpHandler(NetworkConnection *parent)
: BasicHandler(parent) {
QString MQUOTE = QString('\020');
Q_OBJECT
public:
- CtcpHandler(Server *parent = 0);
+ CtcpHandler(NetworkConnection *parent = 0);
enum CtcpType {CtcpQuery, CtcpReply};
#include "util.h"
-#include "server.h"
-#include "networkinfo.h"
+#include "networkconnection.h"
+#include "network.h"
#include "ctcphandler.h"
#include "ircuser.h"
#include <QDebug>
-IrcServerHandler::IrcServerHandler(Server *parent)
+IrcServerHandler::IrcServerHandler(NetworkConnection *parent)
: BasicHandler(parent), server(parent) {
}
void IrcServerHandler::handleJoin(QString prefix, QList<QByteArray> params) {
Q_ASSERT(params.count() == 1);
QString channel = serverDecode(params[0]);
- IrcUser *ircuser = networkInfo()->updateNickFromMask(prefix);
+ IrcUser *ircuser = network()->updateNickFromMask(prefix);
emit displayMsg(Message::Join, channel, channel, prefix);
//qDebug() << "IrcServerHandler::handleJoin()" << prefix << params;
ircuser->joinChannel(channel);
}
void IrcServerHandler::handleKick(QString prefix, QList<QByteArray> params) {
- networkInfo()->updateNickFromMask(prefix);
- IrcUser *victim = networkInfo()->ircUser(serverDecode(params[1]));
+ network()->updateNickFromMask(prefix);
+ IrcUser *victim = network()->ircUser(serverDecode(params[1]));
QString channel = serverDecode(params[0]);
Q_ASSERT(victim);
return;
}
- if(networkInfo()->isChannelName(params[0])) {
+ if(network()->isChannelName(params[0])) {
// Channel Modes
emit displayMsg(Message::Mode, serverDecode(params[0]), serverDecode(params).join(" "), prefix);
- IrcChannel *channel = networkInfo()->ircChannel(params.takeFirst());
+ IrcChannel *channel = network()->ircChannel(params.takeFirst());
// FIXME: currently the IrcChannels only support PREFIX-Modes for users
// This cannot be fixed unless the SignalProxy() doesn't rely on methodIds anymore
QString modes = params.takeFirst();
}
// this is the part where we restrict the mode changes to PREFIXES:
- if(networkInfo()->prefixModes().contains(modes[c]) && modeIndex < params.count()) {
- IrcUser *ircUser = networkInfo()->ircUser(params[modeIndex]);
+ if(network()->prefixModes().contains(modes[c]) && modeIndex < params.count()) {
+ IrcUser *ircUser = network()->ircUser(params[modeIndex]);
if(add)
channel->addUserMode(ircUser, QString(modes[c]));
else
}
void IrcServerHandler::handleNick(QString prefix, QList<QByteArray> params) {
- IrcUser *ircuser = networkInfo()->updateNickFromMask(prefix);
+ IrcUser *ircuser = network()->updateNickFromMask(prefix);
Q_ASSERT(ircuser);
QString newnick = serverDecode(params[0]);
QString oldnick = ircuser->nick();
foreach(QString channel, ircuser->channels()) {
- if(networkInfo()->isMyNick(oldnick)) {
+ if(network()->isMyNick(oldnick)) {
emit displayMsg(Message::Nick, channel, newnick, newnick);
} else {
emit displayMsg(Message::Nick, channel, newnick, prefix);
}
void IrcServerHandler::handleNotice(QString prefix, QList<QByteArray> params) {
- if(networkInfo()->currentServer().isEmpty() || networkInfo()->currentServer() == prefix)
+ if(network()->currentServer().isEmpty() || network()->currentServer() == prefix)
emit displayMsg(Message::Server, "", serverDecode(params[1]), prefix);
else
emit displayMsg(Message::Notice, "", userDecode(prefix, params[1]), prefix);
}
void IrcServerHandler::handlePart(QString prefix, QList<QByteArray> params) {
- IrcUser *ircuser = networkInfo()->updateNickFromMask(prefix);
+ IrcUser *ircuser = network()->updateNickFromMask(prefix);
QString channel = serverDecode(params[0]);
Q_ASSERT(ircuser);
}
void IrcServerHandler::handlePrivmsg(QString prefix, QList<QByteArray> params) {
- IrcUser *ircuser = networkInfo()->updateNickFromMask(prefix);
+ IrcUser *ircuser = network()->updateNickFromMask(prefix);
Q_ASSERT(ircuser);
if(params.count() < 2)
params << QByteArray("");
QString target = serverDecode(params[0]);
// are we the target or is it a channel?
- if(networkInfo()->isMyNick(target)) {
+ if(network()->isMyNick(target)) {
// it's possible to pack multiple privmsgs into one param using ctcp
QStringList messages = server->ctcpHandler()->parse(CtcpHandler::CtcpQuery, prefix, target, userDecode(ircuser->nick(), params[1]));
foreach(QString message, messages) {
}
void IrcServerHandler::handleQuit(QString prefix, QList<QByteArray> params) {
- IrcUser *ircuser = networkInfo()->updateNickFromMask(prefix);
+ IrcUser *ircuser = network()->updateNickFromMask(prefix);
Q_ASSERT(ircuser);
QString msg;
foreach(QString channel, ircuser->channels())
emit displayMsg(Message::Quit, channel, msg, prefix);
- networkInfo()->removeIrcUser(nickFromMask(prefix));
+ network()->removeIrcUser(nickFromMask(prefix));
}
void IrcServerHandler::handleTopic(QString prefix, QList<QByteArray> params) {
- IrcUser *ircuser = networkInfo()->updateNickFromMask(prefix);
+ IrcUser *ircuser = network()->updateNickFromMask(prefix);
QString channel = serverDecode(params[0]);
QString topic = bufferDecode(channel, params[1]);
Q_ASSERT(ircuser);
- networkInfo()->ircChannel(channel)->setTopic(topic);
+ network()->ircChannel(channel)->setTopic(topic);
emit displayMsg(Message::Server, channel, tr("%1 has changed topic for %2 to: \"%3\"").arg(ircuser->nick()).arg(channel).arg(topic));
}
// there should be only one param: "Welcome to the Internet Relay Network <nick>!<user>@<host>"
QString param = serverDecode(params[0]);
QString myhostmask = param.section(' ', -1, -1);
- networkInfo()->setCurrentServer(prefix);
- networkInfo()->setMyNick(nickFromMask(myhostmask));
+ network()->setCurrentServer(prefix);
+ network()->setMyNick(nickFromMask(myhostmask));
emit displayMsg(Message::Server, "", param, prefix);
}
foreach(QString param, serverDecode(params)) {
QString key = param.section("=", 0, 0);
QString value = param.section("=", 1);
- networkInfo()->addSupport(key, value);
+ network()->addSupport(key, value);
}
}
void IrcServerHandler::handle331(QString prefix, QList<QByteArray> params) {
Q_UNUSED(prefix);
QString channel = serverDecode(params[0]);
- networkInfo()->ircChannel(channel)->setTopic(QString());
+ network()->ircChannel(channel)->setTopic(QString());
emit displayMsg(Message::Server, channel, tr("No topic is set for %1.").arg(channel));
}
Q_UNUSED(prefix);
QString channel = serverDecode(params[0]);
QString topic = bufferDecode(channel, params[1]);
- networkInfo()->ircChannel(channel)->setTopic(topic);
+ network()->ircChannel(channel)->setTopic(topic);
emit displayMsg(Message::Server, channel, tr("Topic for %1 is \"%2\"").arg(channel, topic));
}
foreach(QString nick, serverDecode(params.takeFirst()).split(' ')) {
QString mode = QString();
- if(networkInfo()->prefixes().contains(nick[0])) {
- mode = networkInfo()->prefixToMode(nick[0]);
+ if(network()->prefixes().contains(nick[0])) {
+ mode = network()->prefixToMode(nick[0]);
nick = nick.mid(1);
}
- IrcUser *ircuser = networkInfo()->newIrcUser(nick);
+ IrcUser *ircuser = network()->newIrcUser(nick);
ircuser->joinChannel(channelname);
if(!mode.isNull())
- networkInfo()->ircChannel(channelname)->addUserMode(ircuser, mode);
+ network()->ircChannel(channelname)->addUserMode(ircuser, mode);
}
}
Q_OBJECT
public:
- IrcServerHandler(Server *parent = 0);
+ IrcServerHandler(NetworkConnection *parent = 0);
~IrcServerHandler();
void handleServerMsg(QByteArray rawMsg);
void defaultHandler(QString cmd, QString prefix, QList<QByteArray> params);
private:
- Server *server;
+ NetworkConnection *server;
};
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include "server.h"
+#include "networkconnection.h"
#include <QMetaObject>
#include <QMetaMethod>
#include "coresession.h"
#include "ircuser.h"
-#include "networkinfo.h"
+#include "network.h"
#include "ircserverhandler.h"
#include "userinputhandler.h"
#include "ctcphandler.h"
-Server::Server(UserId uid, NetworkId networkId, QString net, const QVariant &state)
+NetworkConnection::NetworkConnection(UserId uid, NetworkId networkId, QString net, const QVariant &state)
: _userId(uid),
_networkId(networkId),
_ircServerHandler(new IrcServerHandler(this)),
_userInputHandler(new UserInputHandler(this)),
_ctcpHandler(new CtcpHandler(this)),
- _networkInfo(new NetworkInfo(networkId, this)),
+ _network(new Network(networkId, this)),
_previousState(state)
{
- connect(networkInfo(), SIGNAL(currentServerSet(const QString &)), this, SLOT(sendPerform()));
- networkInfo()->setCodecForEncoding("ISO-8859-15"); // FIXME
- networkInfo()->setCodecForDecoding("ISO-8859-15"); // FIXME
- networkInfo()->setNetworkName(net);
- networkInfo()->setProxy(coreSession()->signalProxy());
+ connect(network(), SIGNAL(currentServerSet(const QString &)), this, SLOT(sendPerform()));
+ network()->setCodecForEncoding("ISO-8859-15"); // FIXME
+ network()->setCodecForDecoding("ISO-8859-15"); // FIXME
+ network()->setNetworkName(net);
+ network()->setProxy(coreSession()->signalProxy());
}
-Server::~Server() {
+NetworkConnection::~NetworkConnection() {
delete _ircServerHandler;
delete _userInputHandler;
delete _ctcpHandler;
}
-void Server::run() {
+void NetworkConnection::run() {
connect(&socket, SIGNAL(connected()), this, SLOT(socketConnected()));
connect(&socket, SIGNAL(disconnected()), this, SLOT(quit()));
connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError)));
exec();
}
-QString Server::serverDecode(const QByteArray &string) const {
- return networkInfo()->decodeString(string);
+QString NetworkConnection::serverDecode(const QByteArray &string) const {
+ return network()->decodeString(string);
}
-QString Server::bufferDecode(const QString &bufferName, const QByteArray &string) const {
+QString NetworkConnection::bufferDecode(const QString &bufferName, const QByteArray &string) const {
Q_UNUSED(bufferName);
// TODO: Implement buffer-specific encodings
- return networkInfo()->decodeString(string);
+ return network()->decodeString(string);
}
-QString Server::userDecode(const QString &userNick, const QByteArray &string) const {
- IrcUser *user = networkInfo()->ircUser(userNick);
+QString NetworkConnection::userDecode(const QString &userNick, const QByteArray &string) const {
+ IrcUser *user = network()->ircUser(userNick);
if(user) return user->decodeString(string);
- return networkInfo()->decodeString(string);
+ return network()->decodeString(string);
}
-QByteArray Server::serverEncode(const QString &string) const {
- return networkInfo()->encodeString(string);
+QByteArray NetworkConnection::serverEncode(const QString &string) const {
+ return network()->encodeString(string);
}
-QByteArray Server::bufferEncode(const QString &bufferName, const QString &string) const {
+QByteArray NetworkConnection::bufferEncode(const QString &bufferName, const QString &string) const {
Q_UNUSED(bufferName);
// TODO: Implement buffer-specific encodings
- return networkInfo()->encodeString(string);
+ return network()->encodeString(string);
}
-QByteArray Server::userEncode(const QString &userNick, const QString &string) const {
- IrcUser *user = networkInfo()->ircUser(userNick);
+QByteArray NetworkConnection::userEncode(const QString &userNick, const QString &string) const {
+ IrcUser *user = network()->ircUser(userNick);
if(user) return user->encodeString(string);
- return networkInfo()->encodeString(string);
+ return network()->encodeString(string);
}
-void Server::connectToIrc(QString net) {
+void NetworkConnection::connectToIrc(QString net) {
if(net != networkName())
return; // not me!
socket.connectToHost(host, port);
}
-void Server::sendPerform() {
+void NetworkConnection::sendPerform() {
// TODO: reimplement perform List!
//// send performlist
//QStringList performList = networkSettings["Perform"].toString().split( "\n" );
_previousState = QVariant();
}
-QVariant Server::state() {
- IrcUser *me = networkInfo()->ircUser(networkInfo()->myNick());
+QVariant NetworkConnection::state() {
+ IrcUser *me = network()->ircUser(network()->myNick());
if(!me) return QVariant(); // this shouldn't really happen, I guess
return me->channels();
}
-void Server::disconnectFromIrc(QString net) {
+void NetworkConnection::disconnectFromIrc(QString net) {
if(net != networkName())
return; // not me!
socket.disconnectFromHost();
}
-void Server::socketHasData() {
+void NetworkConnection::socketHasData() {
while(socket.canReadLine()) {
QByteArray s = socket.readLine().trimmed();
ircServerHandler()->handleServerMsg(s);
}
}
-void Server::socketError( QAbstractSocket::SocketError err ) {
+void NetworkConnection::socketError( QAbstractSocket::SocketError err ) {
//qDebug() << "Socket Error!";
}
-void Server::socketConnected() {
+void NetworkConnection::socketConnected() {
emit connected(networkId());
putRawLine(QString("NICK :%1").arg(identity["NickList"].toStringList()[0])); // FIXME: try more nicks if error occurs
putRawLine(QString("USER %1 8 * :%2").arg(identity["Ident"].toString()).arg(identity["RealName"].toString()));
}
-void Server::threadFinished() {
+void NetworkConnection::threadFinished() {
// the Socket::disconnected() is connect to this::quit()
// so after the event loop is finished we're beeing called
// and propagate the disconnect
emit disconnected(networkId());
}
-void Server::socketStateChanged(QAbstractSocket::SocketState state) {
+void NetworkConnection::socketStateChanged(QAbstractSocket::SocketState state) {
//qDebug() << "Socket state changed: " << state;
}
-void Server::userInput(uint netid, QString buf, QString msg) {
+void NetworkConnection::userInput(uint netid, QString buf, QString msg) {
if(netid != networkId())
return; // not me!
userInputHandler()->handleUserInput(buf, msg);
}
-void Server::putRawLine(QString s) {
+void NetworkConnection::putRawLine(QString s) {
s += "\r\n";
socket.write(s.toAscii());
}
-void Server::putCmd(QString cmd, QStringList params, QString prefix) {
+void NetworkConnection::putCmd(QString cmd, QStringList params, QString prefix) {
QString msg;
if(!prefix.isEmpty())
msg += ":" + prefix + " ";
}
-uint Server::networkId() const {
+uint NetworkConnection::networkId() const {
return _networkId;
}
-QString Server::networkName() const {
- return networkInfo()->networkName();
+QString NetworkConnection::networkName() const {
+ return network()->networkName();
}
-CoreSession *Server::coreSession() const {
+CoreSession *NetworkConnection::coreSession() const {
return Core::session(userId());
}
/* Exception classes for message handling */
-Server::ParseError::ParseError(QString cmd, QString prefix, QStringList params) {
+NetworkConnection::ParseError::ParseError(QString cmd, QString prefix, QStringList params) {
Q_UNUSED(prefix);
_msg = QString("Command Parse Error: ") + cmd + params.join(" ");
}
-Server::UnknownCmdError::UnknownCmdError(QString cmd, QString prefix, QStringList params) {
+NetworkConnection::UnknownCmdError::UnknownCmdError(QString cmd, QString prefix, QStringList params) {
Q_UNUSED(prefix);
_msg = QString("Unknown Command: ") + cmd + params.join(" ");
}
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#ifndef _SERVER_H_
-#define _SERVER_H_
+#ifndef _NETWORKCONNECTION_H_
+#define _NETWORKCONNECTION_H_
#include <QAbstractSocket>
#include <QString>
#include "message.h"
#include "signalproxy.h"
-class NetworkInfo;
+class Network;
class IrcServerHandler;
class UserInputHandler;
* e.g. if some scripts starts running wild...
*/
-class Server : public QThread {
+class NetworkConnection : public QThread {
Q_OBJECT
public:
- Server(UserId uid, NetworkId networkId, QString network, const QVariant &previousState = QVariant());
- ~Server();
+ NetworkConnection(UserId uid, NetworkId networkId, QString network, const QVariant &previousState = QVariant());
+ ~NetworkConnection();
UserId userId() const { return _userId; }
- // serverState state();
+ // networkState state();
bool isConnected() const { return socket.state() == QAbstractSocket::ConnectedState; }
NetworkId networkId() const;
QString networkName() const; // hasbeen getNetwork()
- NetworkInfo *networkInfo() const { return _networkInfo; }
+ Network *network() const { return _network; }
IrcServerHandler *ircServerHandler() const { return _ircServerHandler; }
UserInputHandler *userInputHandler() const { return _userInputHandler; }
CtcpHandler *ctcpHandler() const { return _ctcpHandler; }
void sendPerform();
signals:
- void serverState(QString net, QVariantMap data);
+ void networkState(QString net, QVariantMap data);
void recvRawServerMsg(QString);
void displayStatusMsg(QString);
//void displayMsg(Message msg);
UserInputHandler *_userInputHandler;
CtcpHandler *_ctcpHandler;
- NetworkInfo *_networkInfo;
+ Network *_network;
QVariantMap networkSettings;
QVariantMap identity;
#include "util.h"
-#include "server.h"
-#include "networkinfo.h"
+#include "networkconnection.h"
+#include "network.h"
#include "ctcphandler.h"
#include <QDebug>
-UserInputHandler::UserInputHandler(Server *parent)
+UserInputHandler::UserInputHandler(NetworkConnection *parent)
: BasicHandler(parent) {
}
params << bufname << msg;
emit putCmd("PRIVMSG", params);
if(isChannelName(bufname)) {
- emit displayMsg(Message::Plain, params[0], msg, networkInfo()->myNick(), Message::Self);
+ emit displayMsg(Message::Plain, params[0], msg, network()->myNick(), Message::Self);
} else {
- emit displayMsg(Message::Plain, params[0], msg, networkInfo()->myNick(), Message::Self|Message::PrivMsg);
+ emit displayMsg(Message::Plain, params[0], msg, network()->myNick(), Message::Self|Message::PrivMsg);
}
}
void UserInputHandler::handleMe(QString bufname, QString msg) {
if(bufname.isEmpty()) return; // server buffer
server->ctcpHandler()->query(bufname, "ACTION", msg);
- emit displayMsg(Message::Action, bufname, msg, networkInfo()->myNick());
+ emit displayMsg(Message::Action, bufname, msg, network()->myNick());
}
void UserInputHandler::handleTopic(QString bufname, QString msg) {
Q_OBJECT
public:
- UserInputHandler(Server *parent = 0);
+ UserInputHandler(NetworkConnection *parent = 0);
void handleUserInput(QString buffer, QString msg);
projects / quassel.git / commitdiff