~ubuntu-branches/ubuntu/trusty/jreen/trusty

« back to all changes in this revision

Viewing changes to src/mucroom.cpp

Committer: Package Import Robot
Author(s): Prasad Murthy
Date: 2013-03-08 00:00:33 UTC
Revision ID: package-import@ubuntu.com-20130308000033-x8thp6syo1kkh63s

Tags: upstream-1.1.1

Import upstream version 1.1.1

files added:

3rdparty

3rdparty/icesupport

3rdparty/icesupport/bsocket.cpp

3rdparty/icesupport/bsocket.h

3rdparty/icesupport/bytestream.cpp

3rdparty/icesupport/bytestream.h

3rdparty/icesupport/httpconnect.cpp

3rdparty/icesupport/httpconnect.h

3rdparty/icesupport/ice176.cpp

3rdparty/icesupport/ice176.h

3rdparty/icesupport/icecomponent.cpp

3rdparty/icesupport/icecomponent.h

3rdparty/icesupport/icecomponent_p.h

3rdparty/icesupport/icelocaltransport.cpp

3rdparty/icesupport/icelocaltransport.h

3rdparty/icesupport/icetransport.cpp

3rdparty/icesupport/icetransport.h

3rdparty/icesupport/iceturntransport.cpp

3rdparty/icesupport/iceturntransport.h

3rdparty/icesupport/objectsession.cpp

3rdparty/icesupport/objectsession.h

3rdparty/icesupport/servsock.cpp

3rdparty/icesupport/servsock.h

3rdparty/icesupport/socks.cpp

3rdparty/icesupport/socks.h

3rdparty/icesupport/stunallocate.cpp

3rdparty/icesupport/stunallocate.h

3rdparty/icesupport/stunbinding.cpp

3rdparty/icesupport/stunbinding.h

3rdparty/icesupport/stunmessage.cpp

3rdparty/icesupport/stunmessage.h

3rdparty/icesupport/stuntransaction.cpp

3rdparty/icesupport/stuntransaction.h

3rdparty/icesupport/stuntypes.cpp

3rdparty/icesupport/stuntypes.h

3rdparty/icesupport/stunutil.cpp

3rdparty/icesupport/stunutil.h

3rdparty/icesupport/turnclient.cpp

3rdparty/icesupport/turnclient.h

3rdparty/icesupport/udpportreserver.cpp

3rdparty/icesupport/udpportreserver.h

3rdparty/jdns

3rdparty/jdns/CMakeLists.txt

3rdparty/jdns/README

3rdparty/jdns/TODO

3rdparty/jdns/jdns.c

3rdparty/jdns/jdns.h

3rdparty/jdns/jdns.pri

3rdparty/jdns/jdns.pro

3rdparty/jdns/jdns_mdnsd.c

3rdparty/jdns/jdns_mdnsd.h

3rdparty/jdns/jdns_p.h

3rdparty/jdns/jdns_packet.c

3rdparty/jdns/jdns_packet.h

3rdparty/jdns/jdns_sys.c

3rdparty/jdns/jdns_util.c

3rdparty/jdns/qjdns.cpp

3rdparty/jdns/qjdns.h

3rdparty/jdns/qjdns_p.h

3rdparty/jdns/qjdns_sock.cpp

3rdparty/jdns/qjdns_sock.h

3rdparty/simplesasl

3rdparty/simplesasl/COPYING

3rdparty/simplesasl/digestmd5proplist.cpp

3rdparty/simplesasl/digestmd5proplist.h

3rdparty/simplesasl/digestmd5response.cpp

3rdparty/simplesasl/digestmd5response.h

3rdparty/simplesasl/plainmessage.cpp

3rdparty/simplesasl/plainmessage.h

3rdparty/simplesasl/simplesasl.cpp

3rdparty/simplesasl/simplesasl.h

AUTHORS

CMakeLists.txt

COPYING

ChangeLog

README

cmake

cmake/FindLibIDN.cmake

cmake/FindLibraryWithDebug.cmake

cmake/FindQCA2.cmake

cmake/jreenMacros.cmake

deffered

deffered/gui

deffered/gui/jidedit.cpp

deffered/gui/jidedit.h

deffered/gui/jidedit_p.h

deffered/gui/xmlconsole.cpp

deffered/gui/xmlconsole.h

deffered/gui/xmlconsole.ui

jreen.qbs

src/abstractroster.cpp

src/abstractroster.h

src/abstractroster_p.h

src/action.cpp

src/action_p.h

src/activity.cpp

src/activity.h

src/activityfactory.cpp

src/activityfactory_p.h

src/attention.cpp

src/attention.h

src/attentionfactory.cpp

src/attentionfactory_p.h

src/bindfeature.cpp

src/bindfeature_p.h

src/bitsofbinary.cpp

src/bitsofbinary.h

src/bitsofbinaryfactory.cpp

src/bitsofbinaryfactory_p.h

src/bookmark.cpp

src/bookmark.h

src/bookmarkfactory.cpp

src/bookmarkfactory_p.h

src/bookmarkstorage.cpp

src/bookmarkstorage.h

src/buffereddatastream.cpp

src/buffereddatastream.h

src/capabilities.cpp

src/capabilities.h

src/capabilitiesfactory.cpp

src/capabilitiesfactory_p.h

src/captcha.cpp

src/captcha.h

src/captchafactory.cpp

src/captchafactory_p.h

src/chatstate.cpp

src/chatstate.h

src/chatstatefactory.cpp

src/chatstatefactory_p.h

src/client.cpp

src/client.h

src/client_p.h

src/connection.h

src/connectionbosh.cpp

src/connectionbosh.h

src/dataform.cpp

src/dataform.h

src/dataform_p.h

src/dataformfactory.cpp

src/dataformfactory_p.h

src/datastream.cpp

src/datastream.h

src/delayeddelivery.cpp

src/delayeddelivery.h

src/delayeddeliveryfactory.cpp

src/delayeddeliveryfactory_p.h

src/directconnection.cpp

src/directconnection.h

src/directconnection_p.h

src/disco.cpp

src/disco.h

src/disco_p.h

src/entitytime.cpp

src/entitytime.h

src/entitytimefactory.cpp

src/entitytimefactory_p.h

src/error.cpp

src/error.h

src/errorfactory.cpp

src/errorfactory_p.h

src/experimental

src/experimental/iristransport.cpp

src/experimental/iristransport.h

src/experimental/jingle.cpp

src/experimental/jingle_p.h

src/experimental/jingleaudiocontent.cpp

src/experimental/jingleaudiocontent.h

src/experimental/jingleaudiocontent_p.h

src/experimental/jingleaudiocontentfactory.cpp

src/experimental/jingleaudiocontentfactory_p.h

src/experimental/jingleaudiopayload.cpp

src/experimental/jingleaudiopayload.h

src/experimental/jingleaudiopayload_p.h

src/experimental/jinglecontent.cpp

src/experimental/jinglecontent.h

src/experimental/jinglecontent_p.h

src/experimental/jinglefactory.cpp

src/experimental/jinglefactory_p.h

src/experimental/jinglemanager.cpp

src/experimental/jinglemanager.h

src/experimental/jinglemanager_p.h

src/experimental/jinglesession.cpp

src/experimental/jinglesession.h

src/experimental/jinglesession_p.h

src/experimental/jinglespeexcodec.cpp

src/experimental/jinglespeexcodec_p.h

src/experimental/jingletransport.cpp

src/experimental/jingletransport.h

src/experimental/jingletransportice.cpp

src/experimental/jingletransportice_p.h

src/forwarded.cpp

src/forwarded.h

src/forwardedfactory.cpp

src/forwardedfactory_p.h

src/iq.cpp

src/iq.h

src/iq_p.h

src/iqfactory.cpp

src/iqfactory_p.h

src/iqreply.cpp

src/iqreply.h

src/jid.cpp

src/jid.h

src/jreen.h

src/jstrings.h

src/langmap.cpp

src/langmap.h

src/libjreen.pc.cmake

src/logger.cpp

src/logger.h

src/message.cpp

src/message.h

src/message_p.h

src/messagefactory.cpp

src/messagefactory_p.h

src/messagesession.cpp

src/messagesession.h

src/metacontacts.cpp

src/metacontacts_p.h

src/metacontactsfactory.cpp

src/metacontactsfactory_p.h

src/metacontactstorage.cpp

src/metacontactstorage.h

src/mood.cpp

src/mood.h

src/moodfactory.cpp

src/moodfactory_p.h

src/mucmessagesession.cpp

src/mucmessagesession_p.h

src/mucroom.cpp

src/mucroom.h

src/mucroom_p.h

src/mucroomfactory.cpp

src/mucroomfactory_p.h

src/nickname.cpp

src/nickname.h

src/nicknamefactory.cpp

src/nicknamefactory_p.h

src/nonsaslauth.cpp

src/nonsaslauth_p.h

src/parser.cpp

src/parser.h

src/parser_p.h

src/pgpencrypted.cpp

src/pgpencrypted.h

src/pgpfactory.cpp

src/pgpfactory_p.h

src/pgpsigned.cpp

src/pgpsigned.h

src/ping.cpp

src/ping.h

src/pingfactory.cpp

src/pingfactory_p.h

src/prep.cpp

src/prep_p.h

src/presence.cpp

src/presence.h

src/presence_p.h

src/presencefactory.cpp

src/presencefactory_p.h

src/privacymanager.cpp

src/privacymanager.h

src/privacymanager_p.h

src/privacyqueryfactory.cpp

src/privacyqueryfactory_p.h

src/privatexml.cpp

src/privatexml.h

src/privatexml_p.h

src/pubsubevent.cpp

src/pubsubevent.h

src/pubsubeventfactory.cpp

src/pubsubeventfactory_p.h

src/pubsubmanager.cpp

src/pubsubmanager.h

src/pubsubmanager_p.h

src/pubsubpublishfactory.cpp

src/pubsubpublishfactory_p.h

src/receipt.cpp

src/receipt.h

src/receiptfactory.cpp

src/receiptfactory_p.h

src/registrationfeature.cpp

src/registrationfeature_p.h

src/registrationmanager.cpp

src/registrationmanager.h

src/registrationmanager_p.h

src/registrationquery.cpp

src/registrationquery_p.h

src/registrationqueryfactory.cpp

src/registrationqueryfactory_p.h

src/saslfeature.cpp

src/saslfeature_p.h

src/sessionfeature.cpp

src/sessionfeature_p.h

src/sjdns.cpp

src/sjdns_p.h

src/softwareversion.cpp

src/softwareversion.h

src/softwareversionfactory.cpp

src/softwareversionfactory_p.h

src/src.qbs

src/stanza.cpp

src/stanza.h

src/stanza_p.h

src/stanzaextension.cpp

src/stanzaextension.h

src/stanzafactory.cpp

src/stanzafactory_p.h

src/streamfeature.cpp

src/streamfeature_p.h

src/streamprocessor.cpp

src/streamprocessor.h

src/subscription.cpp

src/subscription.h

src/tcpconnection.cpp

src/tcpconnection.h

src/tlsdatastream.cpp

src/tlsdatastream_p.h

src/tlsfeature.cpp

src/tlsfeature_p.h

src/tune.cpp

src/tune.h

src/tunefactory.cpp

src/tunefactory_p.h

src/udpconnection.cpp

src/udpconnection.h

src/util.cpp

src/util.h

src/vcard.cpp

src/vcard.h

src/vcard_p.h

src/vcardfactory.cpp

src/vcardfactory_p.h

src/vcardmanager.cpp

src/vcardmanager.h

src/vcardupdate.cpp

src/vcardupdate.h

src/vcardupdatefactory.cpp

src/vcardupdatefactory_p.h

src/xmlentity.cpp

src/xmlentity_p.h

src/zlibcompressionfeature.cpp

src/zlibcompressionfeature_p.h

src/zlibdatastream.cpp

src/zlibdatastream_p.h

Show diffs side-by-side

added added

removed removed

src/mucroom.cpp

/****************************************************************************

** Jreen

*****************************************************************************

** $JREEN_BEGIN_LICENSE$

** 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) any later version.

** 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, see http://www.gnu.org/licenses/.

** $JREEN_END_LICENSE$

****************************************************************************/

#include "mucroom_p.h"

namespace Jreen

{

enum MUCRolePrivilege

{

SendMessage,

ModifySubject,

KickParticipantsAndVisitors,

GrantVoice,

RevokeVoice,

RolePrivelegesCount

};

static char mucPrivelegesByRole[RolePrivelegesCount][4] = {

{ 0, 1, 1 },

{ 0, 0, 1 },

{ 0, 0, 1 }

};

bool checkParticipantPrivelege(MUCRolePrivilege priv, MUCRoom::Role role)

{

return role != MUCRoom::RoleNone && mucPrivelegesByRole[priv][role - 1];

}

// enum MUCAffiliationPrivilege

// {

// SendMessage,

// ModifySubject,

// KickParticipantsAndVisitors,

// GrantVoice,

// RevokeVoice,

// RolePrivelegesCount

// };

// char mucPrivelegesByAffiliation[RolePrivelegesCount][4] = {

// { 0, 1, 1 },

// { 0, 0, 1 },

// { 0, 0, 1 }

// };

// bool checkParticipantPrivelege(MUCAffiliationPrivilege priv, MUCRoom::Affiliation aff)

// {

// return aff != MUCRoom::AffiliationOutcast && mucPrivelegesByAffiliation[priv][aff - 1];

// }

class MUCRoom::ParticipantPrivate

{

public:

ParticipantPrivate() : joined(false) {}

void init(const Presence &pres)

{

query = pres.payload<MUCRoomUserQuery>();

}

MUCRoomUserQuery::Ptr query;

bool joined;

};

MUCRoom::Participant::Participant() : d_ptr(new ParticipantPrivate)

{

}

MUCRoom::Participant::~Participant()

{

}

MUCRoom::Affiliation MUCRoom::Participant::affiliation() const

{

100

return d_func()->query->item.affiliation;

101

}

102

103

MUCRoom::Role MUCRoom::Participant::role() const

104

{

105

return d_func()->query->item.role;

106

}

107

108

bool MUCRoom::Participant::isSelf() const

109

{

110

return d_func()->query->flags & MUCRoomUserQuery::Self;

111

}

112

113

bool MUCRoom::Participant::isNickChanged() const

114

{

115

return d_func()->query->flags & MUCRoomUserQuery::NickChanged;

116

}

117

118

bool MUCRoom::Participant::isBanned() const

119

{

120

return d_func()->query->flags & MUCRoomUserQuery::Banned;

121

}

122

123

bool MUCRoom::Participant::isKicked() const

124

{

125

return d_func()->query->flags & MUCRoomUserQuery::Kicked;

126

}

127

128

bool MUCRoom::Participant::isJoined() const

129

{

130

return d_func()->joined;

131

}

132

133

QString MUCRoom::Participant::newNick() const

134

{

135

return d_func()->query->item.nick;

136

}

137

138

QString MUCRoom::Participant::reason() const

139

{

140

return d_func()->query->item.reason;

141

}

142

143

JID MUCRoom::Participant::realJID() const

144

{

145

return d_func()->query->item.jid;

146

}

147

148

class MUCRoom::ItemPrivate : public QSharedData

149

{

150

public:

151

ItemPrivate() {}

152

ItemPrivate(const ItemPrivate &o) : QSharedData(o), jid(o.jid), reason(o.reason) {}

153

JID jid;

154

QString reason;

155

};

156

157

MUCRoom::Item::Item(const JID &jid, const QString &reason) : d_ptr(new MUCRoom::ItemPrivate)

158

{

159

d_ptr->jid = jid;

160

d_ptr->reason = reason;

161

}

162

163

MUCRoom::Item::Item(const MUCRoom::Item &o) : d_ptr(o.d_ptr)

164

{

165

}

166

167

MUCRoom::Item &MUCRoom::Item::operator =(const MUCRoom::Item &o)

168

{

169

d_ptr = o.d_ptr;

170

return *this;

171

}

172

173

MUCRoom::Item::~Item()

174

{

175

}

176

177

JID MUCRoom::Item::jid() const

178

{

179

return d_ptr->jid;

180

}

181

182

void MUCRoom::Item::setJID(const JID &jid)

183

{

184

d_ptr->jid = jid;

185

}

186

187

QString MUCRoom::Item::reason() const

188

{

189

return d_ptr->reason;

190

}

191

192

void MUCRoom::Item::setReason(const QString &reason)

193

{

194

d_ptr->reason = reason;

195

}

196

197

void MUCRoomPrivate::handlePresence(const Presence &pres)

198

{

199

Q_Q(MUCRoom);

200

Logger::debug() << "handle presence" << pres.from();

201

if (Error::Ptr e = pres.payload<Error>()) {

202

startedJoining = false;

203

emit q->error(e);

204

return;

205

}

206

MUCRoom::Participant part;

207

part.d_func()->query = pres.payload<MUCRoomUserQuery>();

208

if (!part.d_func()->query)

209

return;

210

if (pres.subtype() == Presence::Unavailable) {

211

participantsHash.remove(pres.from().resource());

212

} else {

213

if (startedJoining) {

214

startedJoining = false;

215

QHashIterator<QString,MUCRoomUserQuery::Ptr> it(participantsHash);

216

MUCRoom::Participant tmp;

217

tmp.d_func()->query = MUCRoomUserQuery::Ptr::create();

218

Presence hookPres(Presence::Unavailable, client->jid());

219

JID bareJid = jid.bareJID();

220

while (it.hasNext()) {

221

QString nick = it.next().key();

222

hookPres.setFrom(bareJid.withResource(nick));

223

emit q->presenceReceived(hookPres, &tmp);

224

}

225

}

226

if (!participantsHash.contains(pres.from().resource()))

227

part.d_func()->joined = true;

228

participantsHash.insert(pres.from().resource(), part.d_func()->query);

229

}

230

if (part.isNickChanged() && pres.from().resource() == jid.resource())

231

jid.setResource(part.newNick());

232

emit q->presenceReceived(pres, &part);

233

if (pres.from().resource() == jid.resource()) {

234

role = part.role();

235

affiliation = part.affiliation();

236

if(pres.subtype() == Presence::Unavailable) {

237

participantsHash.clear();

238

isJoined = false;

239

emit q->leaved();

240

} else if (!isJoined) {

241

isJoined = true;

242

emit q->joined();

243

}

244

}

245

}

246

247

void MUCRoomPrivate::handleMessage(const Message &msg)

248

{

249

Q_Q(MUCRoom);

250

bool nice = false;

251

bool isPrivate = (msg.subtype() != Message::Groupchat);

252

if (msg.from() == jid.bare()) {

253

emit q->serviceMessageReceived(msg);

254

nice = true;

255

}

256

if (!msg.subject().isEmpty()) {

257

subject = msg.subject();

258

emit q->subjectChanged(subject, msg.from().resource());

259

nice = true;

260

}

261

// We want to receive "service" messages like chat states for private sessions

262

if (!nice && (isPrivate || !msg.body().isEmpty())) {

263

emit q->messageReceived(msg, isPrivate);

264

}

265

}

266

267

MUCRoom::MUCRoom(Client *client, const JID &jid) :

268

QObject(client),

269

d_ptr(new MUCRoomPrivate(this))

270

{

271

Q_D(MUCRoom);

272

d->client = client;

273

d->jid = jid;

274

d->session = new MUCMessageSession(this);

275

ClientPrivate::get(d->client)->rooms.insert(d->jid.bare(), d);

276

connect(client, SIGNAL(connected()), this, SLOT(onConnected()));

277

connect(client, SIGNAL(disconnected(Jreen::Client::DisconnectReason)), this, SLOT(onDisconnected()));

278

}

279

280

MUCRoom::~MUCRoom()

281

{

282

Q_D(MUCRoom);

283

if (!d->client)

284

return;

285

ClientPrivate::get(d->client)->rooms.remove(d->jid.bare());

286

}

287

288

QString MUCRoom::id() const

289

{

290

return d_func()->jid.bare();

291

}

292

293

QString MUCRoom::service() const

294

{

295

return d_func()->jid.domain();

296

}

297

298

void MUCRoom::setPassword(const QString &password)

299

{

300

d_func()->password = password;

301

}

302

303

bool MUCRoom::isJoined() const

304

{

305

return d_func()->isJoined;

306

}

307

308

Presence::Type MUCRoom::presence() const

309

{

310

return d_func()->currentPresence.subtype();

311

}

312

313

void MUCRoom::join(Presence::Type type, const QString &message, int priority)

314

{

315

Q_D(MUCRoom);

316

if (d->startedJoining)

317

return;

318

d->startedJoining = true;

319

Presence pres(type, d->jid, message, priority);

320

MUCRoomQuery *query = new MUCRoomQuery(d->password);

321

query->setMaxChars(d->maxChars);

322

query->setMaxStanzas(d->maxStanzas);

323

query->setSeconds(d->seconds);

324

query->setSince(d->since);

325

pres.addExtension(query);

326

d->currentPresence = pres;

327

d->client->send(pres);

328

}

329

330

void MUCRoom::join()

331

{

332

Q_D(MUCRoom);

333

Presence pres = d->client->presence();

334

join(pres.subtype(), pres.status(), pres.priority());

335

}

336

337

enum MUCRoomRequestContext

338

{

339

MUCRoomRequestConfig = 100,

340

MUCRoomSubmitConfig,

341

MUCRoomRequestList,

342

MUCRoomEndRequestList = MUCRoomRequestList + 20,

343

MUCRoomSetList

344

};

345

346

void MUCRoom::requestRoomConfig()

347

{

348

Q_D(MUCRoom);

349

IQ iq(IQ::Get, d->jid.bareJID());

350

iq.addExtension(new MUCRoomOwnerQuery);

351

d->client->send(iq, this, SLOT(handleIQ(Jreen::IQ,int)), MUCRoomRequestConfig);

352

}

353

354

void MUCRoom::requestList(Jreen::MUCRoom::Affiliation affiliation)

355

{

356

Q_D(MUCRoom);

357

IQ iq(IQ::Get, d->jid.bareJID());

358

iq.addExtension(new MUCRoomAdminQuery(affiliation));

359

d->client->send(iq, this, SLOT(handleIQ(Jreen::IQ,int)), MUCRoomRequestList + affiliation);

360

}

361

362

void MUCRoom::setList(Jreen::MUCRoom::Affiliation affiliation, const Jreen::MUCRoom::ItemList &items)

363

{

364

Q_D(MUCRoom);

365

IQ iq(IQ::Set, d->jid.bareJID());

366

MUCRoomAdminQuery *query = new MUCRoomAdminQuery;

367

if (items.isEmpty())

368

return;

369

foreach (const Item &item, items) {

370

MUCRoomItem tmp;

371

tmp.affiliation = affiliation;

372

tmp.jid = item.jid();

373

tmp.reason = item.reason();

374

query->items << tmp;

375

}

376

iq.addExtension(query);

377

d->client->send(iq, this, SLOT(handleIQ(Jreen::IQ,int)), MUCRoomSetList);

378

}

379

380

void MUCRoom::setRoomConfig(const Jreen::DataForm::Ptr &form)

381

{

382

Q_D(MUCRoom);

383

IQ iq(IQ::Set, d->jid.bareJID());

384

iq.addExtension(new MUCRoomOwnerQuery(form));

385

d->client->send(iq, this, SLOT(handleIQ(Jreen::IQ,int)), MUCRoomSubmitConfig);

386

}

387

388

void MUCRoom::leave(const QString &message)

389

{

390

Q_D(MUCRoom);

391

if (d->currentPresence.subtype() == Presence::Unavailable)

392

return;

393

d->isJoined = false;

394

Presence pres(Presence::Unavailable, d->jid, message);

395

d->currentPresence = pres;

396

d->client->send(pres);

397

}

398

399

QString MUCRoom::nick() const

400

{

401

return d_func()->jid.resource();

402

}

403

404

JID MUCRoom::realJid(const QString &nick)

405

{

406

MUCRoomUserQuery::Ptr query = d_func()->participantsHash.value(nick);

407

return query ? query->item.jid : JID();

408

}

409

410

void MUCRoom::setNick(const QString &nick)

411

{

412

Q_D(MUCRoom);

413

if (d->isJoined) {

414

JID newJid = d->jid;

415

newJid.setResource(nick);

416

Presence pres(d->currentPresence.subtype(), newJid,

417

d->currentPresence.status(), d->currentPresence.priority());

418

d->client->send(pres);

419

} else {

420

d->jid.setResource(nick);

421

}

422

}

423

424

void MUCRoom::setHistoryMaxChars(int maxChars)

425

{

426

d_func()->maxChars = maxChars;

427

}

428

429

void MUCRoom::setHistoryMaxStanzas(int maxStanzas)

430

{

431

d_func()->maxStanzas = maxStanzas;

432

}

433

434

void MUCRoom::setHistorySeconds(int seconds)

435

{

436

d_func()->seconds = seconds;

437

}

438

439

void MUCRoom::setHistorySince(const QDateTime &since)

440

{

441

d_func()->since = since;

442

}

443

444

void MUCRoom::setPresence(Presence::Type type, const QString &message, int priority)

445

{

446

Q_D(MUCRoom);

447

Presence pres(type, d->jid, message, priority);

448

d->client->send(pres);

449

}

450

451

void MUCRoom::invite(const JID &jid, const QString &reason, const QString &thread)

452

{

453

Q_D(MUCRoom);

454

if (!d->isJoined || !d->client)

455

return;

456

Message message(Message::Normal, jid);

457

message.addExtension(new MUCRoomUserQuery(MUCRoomUserQuery::Invite, jid, reason, thread));

458

d_func()->client->send(message);

459

}

460

461

void MUCRoom::kick(const QString &nick, const QString &reason)

462

{

463

setRole(nick, RoleNone, reason);

464

}

465

466

void MUCRoom::ban(const QString &nick, const QString &reason)

467

{

468

Q_D(MUCRoom);

469

MUCRoomUserQuery::Ptr query = d->participantsHash.value(nick);

470

JID victim;

471

if (!query) {

472

// May be it's already full jid, who knows?

473

victim = nick;

474

if (victim.node().isEmpty() || victim.domain().isEmpty())

475

return;

476

} else {

477

victim = query->item.jid.bareJID();

478

}

479

setAffiliation(victim, AffiliationOutcast, reason);

480

}

481

482

void MUCRoom::setRole(const QString &nick, Role role, const QString &reason)

483

{

484

Q_D(MUCRoom);

485

IQ iq(IQ::Set, d->jid.bareJID());

486

iq.addExtension(new MUCRoomAdminQuery(nick, role, reason));

487

d->client->send(iq);

488

}

489

490

void MUCRoom::setAffiliation(const JID &jid, Affiliation affiliation, const QString &reason)

491

{

492

Q_D(MUCRoom);

493

IQ iq(IQ::Set, d->jid.bareJID());

494

iq.addExtension(new MUCRoomAdminQuery(jid, affiliation, reason));

495

d->client->send(iq);

496

}

497

498

void MUCRoom::setAffiliation(const QString &nick, Affiliation affiliation, const QString &reason)

499

{

500

Q_D(MUCRoom);

501

IQ iq(IQ::Set, d->jid.bareJID());

502

iq.addExtension(new MUCRoomAdminQuery(nick, affiliation, reason));

503

d->client->send(iq);

504

}

505

506

void MUCRoom::send(const QString &message)

507

{

508

Q_D(MUCRoom);

509

d->session->sendMessage(message);

510

}

511

512

QString MUCRoom::subject() const

513

{

514

return d_func()->subject;

515

}

516

517

void MUCRoom::setSubject(const QString &subject)

518

{

519

Q_D(MUCRoom);

520

d->session->setSubject(subject);

521

}

522

523

MUCRoom::Affiliation MUCRoom::affiliation() const

524

{

525

return d_func()->affiliation;

526

}

527

528

MUCRoom::Role MUCRoom::role() const

529

{

530

return d_func()->role;

531

}

532

533

bool MUCRoom::canKick(const QString &nick)

534

{

535

Q_D(MUCRoom);

536

MUCRoomUserQuery::Ptr query = d->participantsHash.value(nick);

537

if (!query)

538

return false;

539

if (query->item.role == MUCRoom::RoleVisitor || query->item.role == MUCRoom::RoleParticipant)

540

return checkParticipantPrivelege(KickParticipantsAndVisitors, d->role);

541

return false;

542

}

543

544

bool MUCRoom::canBan(const QString &nick)

545

{

546

Q_D(MUCRoom);

547

MUCRoomUserQuery::Ptr query = d->participantsHash.value(nick);

548

if (!query)

549

return false;

550

if (d->affiliation != MUCRoom::AffiliationAdmin && d->affiliation != MUCRoom::AffiliationOwner)

551

return false;

552

return query->item.affiliation <= MUCRoom::AffiliationMember;

553

}

554

555

void MUCRoom::handleIQ(const Jreen::IQ &iq, int context)

556

{

557

if (Error::Ptr e = iq.payload<Error>()) {

558

emit error(e);

559

return;

560

}

561

if (context == MUCRoomRequestConfig) {

562

MUCRoomOwnerQuery::Ptr query = iq.payload<MUCRoomOwnerQuery>();

563

if (!query)

564

return;

565

emit configurationReceived(query->form);

566

} else if (context >= MUCRoomRequestList && context < MUCRoomEndRequestList) {

567

ItemList items;

568

MUCRoomAdminQuery::Ptr query = iq.payload<MUCRoomAdminQuery>();

569

if (!query)

570

return;

571

foreach (const MUCRoomItem &item, query->items) {

572

if (!item.jid.isValid())

573

continue;

574

items << Item(item.jid, item.reason);

575

}

576

Affiliation affiliation = static_cast<Affiliation>(context - MUCRoomRequestList);

577

emit listReceived(affiliation, items);

578

}

579

}

580

581

void MUCRoom::onConnected()

582

{

583

Q_D(MUCRoom);

584

if (d->currentPresence.subtype() != Presence::Unavailable)

585

join(d->currentPresence.subtype(), d->currentPresence.status(), d->currentPresence.priority());

586

}

587

588

void MUCRoom::onDisconnected()

589

{

590

Q_D(MUCRoom);

591

d->startedJoining = false;

592

if (d->currentPresence.subtype() != Presence::Unavailable) {

593

d->participantsHash.clear();

594

d->isJoined = false;

595

emit leaved();

596

}

597

}

598

}

Older »