← Back to branch summary

~ubuntu-branches/ubuntu/trusty/quassel/trusty-proposed

« back to all changes in this revision

Viewing changes to src/common/signalproxy.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman
  • Date: 2014-02-18 23:18:25 UTC
  • mfrom: (1.1.54)
  • Revision ID: package-import@ubuntu.com-20140218231825-6vvoh451otn95pkn
Tags: 0.10~beta1-0ubuntu1
* New upstream beta relase
  - Drop debian/patches/upstream_fix_fullscreen_mode.diff which had been
    cherrypicked from upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/signalproxy.cpp
1
1
/***************************************************************************
2
 
 *   Copyright (C) 2005-2013 by the Quassel Project                        *
 
2
 *   Copyright (C) 2005-2014 by the Quassel Project                        *
3
3
 *   devel@quassel-irc.org                                                 *
4
4
 *                                                                         *
5
5
 *   This program is free software; you can redistribute it and/or modify  *
34
34
#include "protocol.h"
35
35
#include "syncableobject.h"
36
36
#include "util.h"
 
37
#include "types.h"
37
38
 
38
39
using namespace Protocol;
39
40
 
147
148
                params << QVariant(argTypes[i], _a[i+1]);
148
149
            }
149
150
 
150
 
            proxy()->dispatch(RpcCall(signal.signature, params));
 
151
            if (argTypes.size() >= 1 && argTypes[0] == qMetaTypeId<PeerPtr>() && proxy()->proxyMode() == SignalProxy::Server) {
 
152
                Peer *peer = params[0].value<PeerPtr>();
 
153
                proxy()->dispatch(peer, RpcCall(signal.signature, params));
 
154
            } else
 
155
                proxy()->dispatch(RpcCall(signal.signature, params));
151
156
        }
152
157
        _id -= _slots.count();
153
158
    }
502
507
}
503
508
 
504
509
 
 
510
template<class T>
 
511
void SignalProxy::dispatch(Peer *peer, const T &protoMessage)
 
512
{
 
513
    if (peer && peer->isOpen())
 
514
        peer->dispatch(protoMessage);
 
515
    else
 
516
        QCoreApplication::postEvent(this, new ::RemovePeerEvent(peer));
 
517
}
 
518
 
 
519
 
505
520
void SignalProxy::handle(Peer *peer, const SyncMessage &syncMessage)
506
521
{
507
 
    if (!_syncSlave.contains(syncMessage.className()) || !_syncSlave[syncMessage.className()].contains(syncMessage.objectName())) {
508
 
        qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className(), syncMessage.slotName(), syncMessage.objectName())
509
 
                   << syncMessage.params();
 
522
    if (!_syncSlave.contains(syncMessage.className) || !_syncSlave[syncMessage.className].contains(syncMessage.objectName)) {
 
523
        qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className, syncMessage.slotName, syncMessage.objectName)
 
524
                   << syncMessage.params;
510
525
        return;
511
526
    }
512
527
 
513
 
    SyncableObject *receiver = _syncSlave[syncMessage.className()][syncMessage.objectName()];
 
528
    SyncableObject *receiver = _syncSlave[syncMessage.className][syncMessage.objectName];
514
529
    ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
515
 
    if (!eMeta->slotMap().contains(syncMessage.slotName())) {
516
 
        qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className(), syncMessage.slotName(), syncMessage.objectName())
517
 
                   << syncMessage.params();
 
530
    if (!eMeta->slotMap().contains(syncMessage.slotName)) {
 
531
        qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className, syncMessage.slotName, syncMessage.objectName)
 
532
                   << syncMessage.params;
518
533
        return;
519
534
    }
520
535
 
521
 
    int slotId = eMeta->slotMap()[syncMessage.slotName()];
 
536
    int slotId = eMeta->slotMap()[syncMessage.slotName];
522
537
    if (proxyMode() != eMeta->receiverMode(slotId)) {
523
538
        qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed. Wrong ProxyMode!", eMeta->methodName(slotId).constData());
524
539
        return;
525
540
    }
526
541
 
527
542
    QVariant returnValue((QVariant::Type)eMeta->returnType(slotId));
528
 
    if (!invokeSlot(receiver, slotId, syncMessage.params(), returnValue)) {
 
543
    if (!invokeSlot(receiver, slotId, syncMessage.params, returnValue, peer)) {
529
544
        qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", eMeta->methodName(slotId).constData());
530
545
        return;
531
546
    }
534
549
        int receiverId = eMeta->receiveMap()[slotId];
535
550
        QVariantList returnParams;
536
551
        if (eMeta->argTypes(receiverId).count() > 1)
537
 
            returnParams << syncMessage.params();
 
552
            returnParams << syncMessage.params;
538
553
        returnParams << returnValue;
539
 
        peer->dispatch(SyncMessage(syncMessage.className(), syncMessage.objectName(), eMeta->methodName(receiverId), returnParams));
 
554
        peer->dispatch(SyncMessage(syncMessage.className, syncMessage.objectName, eMeta->methodName(receiverId), returnParams));
540
555
    }
541
556
 
542
557
    // send emit update signal
546
561
 
547
562
void SignalProxy::handle(Peer *peer, const InitRequest &initRequest)
548
563
{
549
 
   if (!_syncSlave.contains(initRequest.className())) {
 
564
   if (!_syncSlave.contains(initRequest.className)) {
550
565
        qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
551
 
                   << initRequest.className();
 
566
                   << initRequest.className;
552
567
        return;
553
568
    }
554
569
 
555
 
    if (!_syncSlave[initRequest.className()].contains(initRequest.objectName())) {
 
570
    if (!_syncSlave[initRequest.className].contains(initRequest.objectName)) {
556
571
        qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
557
 
                   << initRequest.className() << initRequest.objectName();
 
572
                   << initRequest.className << initRequest.objectName;
558
573
        return;
559
574
    }
560
575
 
561
 
    SyncableObject *obj = _syncSlave[initRequest.className()][initRequest.objectName()];
562
 
    peer->dispatch(InitData(initRequest.className(), initRequest.objectName(), initData(obj)));
 
576
    SyncableObject *obj = _syncSlave[initRequest.className][initRequest.objectName];
 
577
    peer->dispatch(InitData(initRequest.className, initRequest.objectName, initData(obj)));
563
578
}
564
579
 
565
580
 
567
582
{
568
583
    Q_UNUSED(peer)
569
584
 
570
 
    if (!_syncSlave.contains(initData.className())) {
 
585
    if (!_syncSlave.contains(initData.className)) {
571
586
        qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:"
572
 
                   << initData.className();
 
587
                   << initData.className;
573
588
        return;
574
589
    }
575
590
 
576
 
    if (!_syncSlave[initData.className()].contains(initData.objectName())) {
 
591
    if (!_syncSlave[initData.className].contains(initData.objectName)) {
577
592
        qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:"
578
 
                   << initData.className() << initData.objectName();
 
593
                   << initData.className << initData.objectName;
579
594
        return;
580
595
    }
581
596
 
582
 
    SyncableObject *obj = _syncSlave[initData.className()][initData.objectName()];
583
 
    setInitData(obj, initData.initData());
 
597
    SyncableObject *obj = _syncSlave[initData.className][initData.objectName];
 
598
    setInitData(obj, initData.initData);
584
599
}
585
600
 
586
601
 
587
602
void SignalProxy::handle(Peer *peer, const RpcCall &rpcCall)
588
603
{
589
 
    Q_UNUSED(peer)
590
 
 
591
604
    QObject *receiver;
592
605
    int methodId;
593
 
    SlotHash::const_iterator slot = _attachedSlots.constFind(rpcCall.slotName());
594
 
    while (slot != _attachedSlots.constEnd() && slot.key() == rpcCall.slotName()) {
 
606
    SlotHash::const_iterator slot = _attachedSlots.constFind(rpcCall.slotName);
 
607
    while (slot != _attachedSlots.constEnd() && slot.key() == rpcCall.slotName) {
595
608
        receiver = (*slot).first;
596
609
        methodId = (*slot).second;
597
 
        if (!invokeSlot(receiver, methodId, rpcCall.params())) {
 
610
        if (!invokeSlot(receiver, methodId, rpcCall.params, peer)) {
598
611
            ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
599
612
            qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", eMeta->methodName(methodId).constData());
600
613
        }
603
616
}
604
617
 
605
618
 
606
 
bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue)
 
619
bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue, Peer *peer)
607
620
{
608
621
    ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
609
622
    const QList<int> args = eMeta->argTypes(methodId);
631
644
            qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId);
632
645
            return false;
633
646
        }
634
 
        _a[i+1] = const_cast<void *>(params[i].constData());
 
647
        // if first arg is a PeerPtr, replace it by the address of the peer originally receiving the RpcCall
 
648
        if (peer && i == 0 && args[0] == qMetaTypeId<PeerPtr>()) {
 
649
            QVariant v = QVariant::fromValue<PeerPtr>(peer);
 
650
            _a[1] = const_cast<void*>(v.constData());
 
651
        } else
 
652
            _a[i+1] = const_cast<void *>(params[i].constData());
635
653
    }
636
654
 
637
655
    if (returnValue.type() != QVariant::Invalid)
652
670
}
653
671
 
654
672
 
655
 
bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params)
 
673
bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, Peer *peer)
656
674
{
657
675
    QVariant ret;
658
 
    return invokeSlot(receiver, methodId, params, ret);
 
676
    return invokeSlot(receiver, methodId, params, ret, peer);
659
677
}
660
678
 
661
679
 
723
741
        params << QVariant(argTypes[i], va_arg(ap, void *));
724
742
    }
725
743
 
726
 
    dispatch(SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params));
 
744
    if (argTypes.size() >= 1 && argTypes[0] == qMetaTypeId<PeerPtr>() && proxyMode() == SignalProxy::Server) {
 
745
        Peer *peer = params[0].value<PeerPtr>();
 
746
        dispatch(peer, SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params));
 
747
    } else
 
748
        dispatch(SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params));
727
749
}
728
750
 
729
751