TQT_DBusConnectionPrivate Class Reference

#include <tqdbusconnection_p.h>

Inheritance diagram for TQT_DBusConnectionPrivate:

Collaboration diagram for TQT_DBusConnectionPrivate:

Classes
struct	Watcher
struct	TQT_DBusPendingCall

Public Types
enum	ConnectionMode { InvalidMode , ServerMode , ClientMode }
typedef TQValueList< Watcher >	WatcherList
typedef TQMap< int, WatcherList >	WatcherHash
typedef TQMap< int, DBusTimeout * >	TimeoutHash
typedef TQMap< TQString, TQT_DBusObjectBase * >	ObjectMap
typedef TQMap< DBusPendingCall *, TQT_DBusPendingCall * >	PendingCallMap
typedef TQValueList< TQT_DBusMessage >	PendingMessagesForEmit

Public Slots
void	socketRead (int)
void	socketWrite (int)
void	objectDestroyed (TQObject *object)
void	purgeRemovedWatches ()
void	scheduleDispatch ()
void	dispatch ()

Signals
void	dbusSignal (const TQT_DBusMessage &message)
void	dbusPendingCallReply (const TQT_DBusMessage &message)

Public Member Functions
	TQT_DBusConnectionPrivate (TQObject *parent=0)
	~TQT_DBusConnectionPrivate ()
void	bindToApplication ()
void	setConnection (DBusConnection *connection)
void	setServer (DBusServer *server)
void	closeConnection ()
void	timerEvent (TQTimerEvent *e)
bool	handleSignal (DBusMessage *msg)
bool	handleObjectCall (DBusMessage *message)
bool	handleError ()
bool	handleUnreadMessages ()
void	emitPendingCallReply (const TQT_DBusMessage &message)
int	sendWithReplyAsync (const TQT_DBusMessage &message, TQObject *receiver, const char *method)
void	flush ()
void	newMethodInResultEmissionQueue ()

Static Public Member Functions
static int	registerMessageMetaType ()

Public Attributes
DBusError	error
TQT_DBusError	lastError
Atomic	ref
ConnectionMode	mode
DBusConnection *	connection
DBusServer *	server
TQTimer *	dispatcher
WatcherList	removedWatches
WatcherHash	watchers
TimeoutHash	timeouts
ObjectMap	registeredObjects
TQValueList< DBusTimeout * >	pendingTimeouts
PendingCallMap	pendingCalls
PendingMessagesForEmit	pendingMessages
bool	inDispatch
TQT_DBusResultInfoList	m_resultEmissionQueue

Static Public Attributes
static int	messageMetaType = 0

Private Slots
void	transmitResultEmissionQueue ()
void	transmitMessageEmissionQueue ()

Private Attributes
TQTimer *	m_resultEmissionQueueTimer
TQTimer *	m_messageEmissionQueueTimer

Detailed Description

Definition at line 69 of file tqdbusconnection_p.h.

Member Typedef Documentation

ObjectMap

typedef TQMap<TQString, TQT_DBusObjectBase*> TQT_DBusConnectionPrivate::ObjectMap

Definition at line 145 of file tqdbusconnection_p.h.

PendingCallMap

typedef TQMap<DBusPendingCall*, TQT_DBusPendingCall*> TQT_DBusConnectionPrivate::PendingCallMap

Definition at line 156 of file tqdbusconnection_p.h.

PendingMessagesForEmit

typedef TQValueList<TQT_DBusMessage> TQT_DBusConnectionPrivate::PendingMessagesForEmit

Definition at line 159 of file tqdbusconnection_p.h.

TimeoutHash

typedef TQMap<int, DBusTimeout*> TQT_DBusConnectionPrivate::TimeoutHash

Definition at line 142 of file tqdbusconnection_p.h.

WatcherHash

typedef TQMap<int, WatcherList> TQT_DBusConnectionPrivate::WatcherHash

Definition at line 138 of file tqdbusconnection_p.h.

WatcherList

typedef TQValueList<Watcher> TQT_DBusConnectionPrivate::WatcherList

Definition at line 136 of file tqdbusconnection_p.h.

Member Enumeration Documentation

ConnectionMode

enum TQT_DBusConnectionPrivate::ConnectionMode

Enumerator
InvalidMode
ServerMode
ClientMode

Definition at line 112 of file tqdbusconnection_p.h.

{ InvalidMode, ServerMode, ClientMode };

Constructor & Destructor Documentation

TQT_DBusConnectionPrivate()

TQT_DBusConnectionPrivate::TQT_DBusConnectionPrivate

(

TQObject *

parent = 0

)

Definition at line 274 of file tqdbusintegrator.cpp.

    : TQObject(parent), ref(1), mode(InvalidMode), connection(0), server(0),
      dispatcher(0), inDispatch(false)
{
    static const int msgType = registerMessageMetaType();
    Q_UNUSED(msgType);
 
    dbus_error_init(&error);
 
    dispatcher = new TQTimer(this);
    TQObject::connect(dispatcher, TQ_SIGNAL(timeout()), this, TQ_SLOT(dispatch()));
 
    m_resultEmissionQueueTimer = new TQTimer(this);
    TQObject::connect(m_resultEmissionQueueTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(transmitResultEmissionQueue()));
    m_messageEmissionQueueTimer = new TQTimer(this);
    TQObject::connect(m_messageEmissionQueueTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(transmitMessageEmissionQueue()));
}

References connection, dispatch(), dispatcher, error, inDispatch, InvalidMode, m_messageEmissionQueueTimer, m_resultEmissionQueueTimer, mode, ref, registerMessageMetaType(), server, transmitMessageEmissionQueue(), and transmitResultEmissionQueue().

Here is the call graph for this function:

~TQT_DBusConnectionPrivate()

TQT_DBusConnectionPrivate::~TQT_DBusConnectionPrivate

(

)

Definition at line 292 of file tqdbusintegrator.cpp.

{
    for (PendingCallMap::iterator it = pendingCalls.begin(); it != pendingCalls.end();)
    {
        PendingCallMap::iterator copyIt = it;
        ++it;
        dbus_pending_call_cancel(copyIt.key());
        dbus_pending_call_unref(copyIt.key());
        delete copyIt.data();
        pendingCalls.erase(copyIt);
    }
 
    if (dbus_error_is_set(&error))
        dbus_error_free(&error);
 
    closeConnection();
}

References closeConnection(), error, and pendingCalls.

Here is the call graph for this function:

Member Function Documentation

bindToApplication()

void TQT_DBusConnectionPrivate::bindToApplication

(

)

Definition at line 370 of file tqdbusintegrator.cpp.

{
    // Yay, now that we have an application we are in business
    // Re-add all watchers
    WatcherHash oldWatchers = watchers;
    watchers.clear();
    // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(oldWatchers);
    for (WatcherHash::const_iterator it = oldWatchers.begin(); it != oldWatchers.end(); ++it)
    {
        const WatcherList& list = *it;
        for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit)
        {
            if (!(*wit).read && !(*wit).write) {
                qDBusAddWatch((*wit).watch, this);
            }
        }
    }
 
    // Re-add all timeouts
    while (!pendingTimeouts.isEmpty()) {
       qDBusAddTimeout(pendingTimeouts.first(), this);
       pendingTimeouts.pop_front();
    }
}

References pendingTimeouts, qDBusAddTimeout(), qDBusAddWatch(), and watchers.

Here is the call graph for this function:

closeConnection()

void TQT_DBusConnectionPrivate::closeConnection

(

)

Definition at line 310 of file tqdbusintegrator.cpp.

{
    ConnectionMode oldMode = mode;
    mode = InvalidMode; // prevent reentrancy
    if (oldMode == ServerMode) {
        if (server) {
            dbus_server_disconnect(server);
            dbus_server_unref(server);
            server = 0;
        }
    } else if (oldMode == ClientMode) {
        if (connection) {
            // closing shared connections is forbidden
#if 0
            dbus_connection_close(connection);
            // send the "close" message
            while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS);
#endif
            dbus_connection_unref(connection);
            connection = 0;
        }
    }
}

References ClientMode, connection, InvalidMode, mode, server, and ServerMode.

Here is the caller graph for this function:

dbusPendingCallReply

void TQT_DBusConnectionPrivate::dbusPendingCallReply ( const TQT_DBusMessage & message )

signal

Here is the caller graph for this function:

dbusSignal

void TQT_DBusConnectionPrivate::dbusSignal ( const TQT_DBusMessage & message )

signal

Here is the caller graph for this function:

dispatch

void TQT_DBusConnectionPrivate::dispatch ( )

slot

Definition at line 491 of file tqdbusintegrator.cpp.

{
    // dbus_connection_dispatch will hang if called recursively
    if (inDispatch) {
        printf("[dbus-1-tqt] WARNING: Attempt to call dispatch() recursively was silently ignored to prevent lockup!\n\r"); fflush(stdout);
        return;
    }
    inDispatch = true;
 
    if (mode == ClientMode)
    {
        if (dbus_connection_dispatch(connection) != DBUS_DISPATCH_DATA_REMAINS)
        {
            // stop dispatch timer
            dispatcher->stop();
        }
    }
 
    inDispatch = false;
}

References ClientMode, connection, dispatcher, inDispatch, and mode.

Here is the caller graph for this function:

emitPendingCallReply()

void TQT_DBusConnectionPrivate::emitPendingCallReply

(

const TQT_DBusMessage &

message

)

Definition at line 365 of file tqdbusintegrator.cpp.

{
    emit dbusPendingCallReply(message);
}

References dbusPendingCallReply().

Here is the call graph for this function:

Here is the caller graph for this function:

flush()

void TQT_DBusConnectionPrivate::flush

(

)

Definition at line 681 of file tqdbusintegrator.cpp.

{
    if (!connection) return;
 
    dbus_connection_flush(connection);
}

References connection.

handleError()

bool TQT_DBusConnectionPrivate::handleError

(

)

Definition at line 334 of file tqdbusintegrator.cpp.

{
    lastError = TQT_DBusError(&error);
    if (dbus_error_is_set(&error))
        dbus_error_free(&error);
    return lastError.isValid();
}

References error, and lastError.

Here is the caller graph for this function:

handleObjectCall()

bool TQT_DBusConnectionPrivate::handleObjectCall

(

DBusMessage *

message

)

Definition at line 523 of file tqdbusintegrator.cpp.

{
    TQT_DBusMessage msg = TQT_DBusMessage::fromDBusMessage(message);
 
    ObjectMap::iterator it = registeredObjects.find(msg.path());
    if (it == registeredObjects.end())
        return false;
 
    return it.data()->handleMethodCall(msg);
}

References TQT_DBusMessage::fromDBusMessage(), TQT_DBusMessage::path(), and registeredObjects.

Here is the call graph for this function:

Here is the caller graph for this function:

handleSignal()

bool TQT_DBusConnectionPrivate::handleSignal

(

DBusMessage *

msg

)

Definition at line 534 of file tqdbusintegrator.cpp.

{
    TQT_DBusMessage msg = TQT_DBusMessage::fromDBusMessage(message);
 
    // yes, it is a single "|" below...
    // FIXME-QT4
    //return handleSignal(TQString(), msg) | handleSignal(msg.path(), msg);
 
    // If dbusSignal(msg) were called here, it could easily cause a lockup as it would enter the TQt3 event loop,
    // which could result in arbitrary methods being called while still inside dbus_connection_dispatch.
    // Instead, I enqueue the messages here for TQt3 event loop transmission after dbus_connection_dispatch is finished.
    pendingMessages.append(msg);
    if (!m_messageEmissionQueueTimer->isActive()) m_messageEmissionQueueTimer->start(0, true);
 
    return true;
}

References TQT_DBusMessage::fromDBusMessage(), m_messageEmissionQueueTimer, and pendingMessages.

Here is the call graph for this function:

Here is the caller graph for this function:

handleUnreadMessages()

bool TQT_DBusConnectionPrivate::handleUnreadMessages

(

)

Definition at line 342 of file tqdbusintegrator.cpp.

{
  bool res = true;
  WatcherHash::iterator it = watchers.begin();
  while (it != watchers.end())
  {
    WatcherList &list = *it;
    WatcherList::iterator listIt = list.begin();
    while (listIt != list.end())
    {
      Watcher watcher = *listIt;
      if (watcher.read)
      {
        socketRead(watcher.read->socket());
        res &= (!handleError());
      }
      ++listIt;
    }
    ++it;
  }
  return res;
}

References handleError(), TQT_DBusConnectionPrivate::Watcher::read, socketRead(), and watchers.

Here is the call graph for this function:

newMethodInResultEmissionQueue()

void TQT_DBusConnectionPrivate::newMethodInResultEmissionQueue

(

)

Definition at line 688 of file tqdbusintegrator.cpp.

{
    if (!m_resultEmissionQueueTimer->isActive()) m_resultEmissionQueueTimer->start(0, true);
}

References m_resultEmissionQueueTimer.

Here is the caller graph for this function:

objectDestroyed

void TQT_DBusConnectionPrivate::objectDestroyed ( TQObject * object )

slot

Definition at line 427 of file tqdbusintegrator.cpp.

{
    //tqDebug("Object destroyed");
    for (PendingCallMap::iterator it = pendingCalls.begin(); it != pendingCalls.end();)
    {
        TQObject* receiver = (TQObject*) it.data()->receiver;
        if (receiver == object || receiver == 0)
        {
            PendingCallMap::iterator copyIt = it;
            ++it;
 
            dbus_pending_call_cancel(copyIt.key());
            dbus_pending_call_unref(copyIt.key());
            delete copyIt.data();
            pendingCalls.erase(copyIt);
        }
        else
            ++it;
    }
}

References pendingCalls.

Here is the caller graph for this function:

purgeRemovedWatches

void TQT_DBusConnectionPrivate::purgeRemovedWatches ( )

slot

Definition at line 448 of file tqdbusintegrator.cpp.

{
    if (removedWatches.isEmpty()) return;
 
    WatcherList::iterator listIt = removedWatches.begin();
    for (; listIt != removedWatches.end(); ++listIt)
    {
        delete (*listIt).read;
        delete (*listIt).write;
    }
    removedWatches.clear();
 
    uint count = 0;
    WatcherHash::iterator it = watchers.begin();
    while (it != watchers.end())
    {
        WatcherList& list = *it;
        listIt = list.begin();
        while (listIt != list.end())
        {
            if (!((*listIt).read) && !((*listIt).write))
            {
                listIt = list.erase(listIt);
                ++count;
            }
        }
 
        if (list.isEmpty())
        {
            WatcherHash::iterator copyIt = it;
            ++it;
            watchers.erase(copyIt);
        }
        else
            ++it;
    }
}

References removedWatches, and watchers.

registerMessageMetaType()

int TQT_DBusConnectionPrivate::registerMessageMetaType ( )

static

Definition at line 267 of file tqdbusintegrator.cpp.

{
    // FIXME-QT4 int tp = messageMetaType = qRegisterMetaType<TQT_DBusMessage>("TQT_DBusMessage");
    int tp = 0;
    return tp;
}

Here is the caller graph for this function:

scheduleDispatch

void TQT_DBusConnectionPrivate::scheduleDispatch ( )

slot

Definition at line 486 of file tqdbusintegrator.cpp.

{
    dispatcher->start(0);
}

References dispatcher.

Here is the caller graph for this function:

sendWithReplyAsync()

int TQT_DBusConnectionPrivate::sendWithReplyAsync	(	const TQT_DBusMessage &	message,
		TQObject *	receiver,
		const char *	method )

Definition at line 649 of file tqdbusintegrator.cpp.

{
    if (!receiver || !method)
        return 0;
 
    if (!TQObject::connect(receiver, TQ_SIGNAL(destroyed(TQObject*)),
                          this, TQ_SLOT(objectDestroyed(TQObject*))))
        return false;
 
    DBusMessage *msg = message.toDBusMessage();
    if (!msg)
        return 0;
 
    int msg_serial = 0;
    DBusPendingCall *pending = 0;
    if (dbus_connection_send_with_reply(connection, msg, &pending, message.timeout())) {
        TQT_DBusPendingCall *pcall = new TQT_DBusPendingCall;
        pcall->receiver = receiver;
        pcall->method = method;
        pcall->pending = pending;
        pendingCalls.insert(pcall->pending, pcall);
 
        dbus_pending_call_set_notify(pending, qDBusResultReceived, this, 0);
 
        msg_serial = dbus_message_get_serial(msg);
    }
 
    dbus_message_unref(msg);
    return msg_serial;
}

References connection, TQT_DBusConnectionPrivate::TQT_DBusPendingCall::method, objectDestroyed(), TQT_DBusConnectionPrivate::TQT_DBusPendingCall::pending, pendingCalls, qDBusResultReceived(), TQT_DBusConnectionPrivate::TQT_DBusPendingCall::receiver, TQT_DBusMessage::timeout(), and TQT_DBusMessage::toDBusMessage().

Here is the call graph for this function:

setConnection()

void TQT_DBusConnectionPrivate::setConnection

(

DBusConnection *

connection

)

Definition at line 576 of file tqdbusintegrator.cpp.

{
    if (!dbc) {
        handleError();
        return;
    }
 
    connection = dbc;
    mode = ClientMode;
 
    dbus_connection_set_exit_on_disconnect(connection, false);
    dbus_connection_set_watch_functions(connection, qDBusAddWatch, qDBusRemoveWatch,
                                        qDBusToggleWatch, this, 0);
    dbus_connection_set_timeout_functions(connection, qDBusAddTimeout, qDBusRemoveTimeout,
                                          qDBusToggleTimeout, this, 0);
 
    dbus_bus_add_match(connection, "type='signal'", &error);
    if (handleError()) {
        closeConnection();
        return;
    }
 
    const char *service = dbus_bus_get_unique_name(connection);
    if (service) {
        TQCString filter;
        filter += "destination='";
        filter += service;
        filter += "'";
 
        dbus_bus_add_match(connection, filter.data(), &error);
        if (handleError()) {
            closeConnection();
            return;
        }
    } else {
        tqWarning("TQT_DBusConnectionPrivate::SetConnection: Unable to get unique name");
    }
 
    dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0);
 
    //tqDebug("unique name: %s", service);
}

References ClientMode, closeConnection(), connection, error, handleError(), mode, qDBusAddTimeout(), qDBusAddWatch(), qDBusRemoveTimeout(), qDBusRemoveWatch(), qDBusSignalFilter(), qDBusToggleTimeout(), and qDBusToggleWatch().

Here is the call graph for this function:

setServer()

void TQT_DBusConnectionPrivate::setServer

(

DBusServer *

server

)

Definition at line 553 of file tqdbusintegrator.cpp.

{
    if (!server) {
        handleError();
        return;
    }
 
    server = s;
    mode = ServerMode;
 
    dbus_server_allocate_data_slot(&server_slot);
    if (server_slot < 0)
        return;
 
    dbus_server_set_watch_functions(server, qDBusAddWatch, qDBusRemoveWatch,
                                    qDBusToggleWatch, this, 0); // ### check return type?
    dbus_server_set_timeout_functions(server, qDBusAddTimeout, qDBusRemoveTimeout,
                                      qDBusToggleTimeout, this, 0);
    dbus_server_set_new_connection_function(server, qDBusNewConnection, this, 0);
 
    dbus_server_set_data(server, server_slot, this, 0);
}

References handleError(), mode, qDBusAddTimeout(), qDBusAddWatch(), qDBusNewConnection(), qDBusRemoveTimeout(), qDBusRemoveWatch(), qDBusToggleTimeout(), qDBusToggleWatch(), server, server_slot, and ServerMode.

Here is the call graph for this function:

socketRead

void TQT_DBusConnectionPrivate::socketRead ( int fd )

slot

Definition at line 395 of file tqdbusintegrator.cpp.

{
    // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(watchers);
    WatcherHash::const_iterator it = watchers.find(fd);
    if (it != watchers.end()) {
        const WatcherList& list = *it;
        for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit) {
            if ((*wit).read && (*wit).read->isEnabled()) {
                if (!dbus_watch_handle((*wit).watch, DBUS_WATCH_READABLE))
                    tqDebug("OUT OF MEM");
            }
        }
    }
    if (mode == ClientMode)
        scheduleDispatch();
}

References ClientMode, mode, scheduleDispatch(), and watchers.

Here is the call graph for this function:

Here is the caller graph for this function:

socketWrite

void TQT_DBusConnectionPrivate::socketWrite ( int fd )

slot

Definition at line 412 of file tqdbusintegrator.cpp.

{
    // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(watchers);
    WatcherHash::const_iterator it = watchers.find(fd);
    if (it != watchers.end()) {
        const WatcherList& list = *it;
        for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit) {
            if ((*wit).write && (*wit).write->isEnabled()) {
                if (!dbus_watch_handle((*wit).watch, DBUS_WATCH_WRITABLE))
                    tqDebug("OUT OF MEM");
            }
        }
    }
}

References watchers.

timerEvent()

void TQT_DBusConnectionPrivate::timerEvent

(

TQTimerEvent *

e

)

Definition at line 246 of file tqdbusconnection.cpp.

{
    DBusTimeout *timeout = timeouts[e->timerId()];
    dbus_timeout_handle(timeout);
}

References timeouts.

transmitMessageEmissionQueue

void TQT_DBusConnectionPrivate::transmitMessageEmissionQueue ( )

privateslot

Definition at line 512 of file tqdbusintegrator.cpp.

{
    TQT_DBusConnectionPrivate::PendingMessagesForEmit::iterator pmfe;
    pmfe = pendingMessages.begin();
    while (pmfe != pendingMessages.end()) {
        TQT_DBusMessage msg = *pmfe;
        pmfe = pendingMessages.remove(pmfe);
        dbusSignal(msg);
    }
}

References dbusSignal(), and pendingMessages.

Here is the call graph for this function:

Here is the caller graph for this function:

transmitResultEmissionQueue

void TQT_DBusConnectionPrivate::transmitResultEmissionQueue ( )

privateslot

Definition at line 693 of file tqdbusintegrator.cpp.

{
    if (!m_resultEmissionQueue.isEmpty()) {
        TQT_DBusResultInfoList::Iterator it;
        it = m_resultEmissionQueue.begin();
        while (it != m_resultEmissionQueue.end()) {
            TQT_DBusResultInfo dbusResult = (*it);
            m_resultEmissionQueue.remove(it);
            it = m_resultEmissionQueue.begin();
 
            TQObject::connect(this, TQ_SIGNAL(dbusPendingCallReply(const TQT_DBusMessage&)), dbusResult.receiver, dbusResult.method.data());
            emitPendingCallReply(dbusResult.message);
            TQObject::disconnect(this, TQ_SIGNAL(dbusPendingCallReply(const TQT_DBusMessage&)), dbusResult.receiver, dbusResult.method.data());
        }
    }
}

References dbusPendingCallReply(), emitPendingCallReply(), m_resultEmissionQueue, TQT_DBusResultInfo::message, TQT_DBusResultInfo::method, and TQT_DBusResultInfo::receiver.

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

connection

DBusConnection* TQT_DBusConnectionPrivate::connection

Definition at line 117 of file tqdbusconnection_p.h.

dispatcher

TQTimer* TQT_DBusConnectionPrivate::dispatcher

Definition at line 120 of file tqdbusconnection_p.h.

error

DBusError TQT_DBusConnectionPrivate::error

Definition at line 109 of file tqdbusconnection_p.h.

inDispatch

bool TQT_DBusConnectionPrivate::inDispatch

Definition at line 162 of file tqdbusconnection_p.h.

lastError

TQT_DBusError TQT_DBusConnectionPrivate::lastError

Definition at line 110 of file tqdbusconnection_p.h.

m_messageEmissionQueueTimer

TQTimer* TQT_DBusConnectionPrivate::m_messageEmissionQueueTimer

private

Definition at line 175 of file tqdbusconnection_p.h.

m_resultEmissionQueue

TQT_DBusResultInfoList TQT_DBusConnectionPrivate::m_resultEmissionQueue

Definition at line 164 of file tqdbusconnection_p.h.

m_resultEmissionQueueTimer

TQTimer* TQT_DBusConnectionPrivate::m_resultEmissionQueueTimer

private

Definition at line 174 of file tqdbusconnection_p.h.

messageMetaType

int TQT_DBusConnectionPrivate::messageMetaType = 0

static

Definition at line 122 of file tqdbusconnection_p.h.

mode

ConnectionMode TQT_DBusConnectionPrivate::mode

Definition at line 116 of file tqdbusconnection_p.h.

pendingCalls

PendingCallMap TQT_DBusConnectionPrivate::pendingCalls

Definition at line 157 of file tqdbusconnection_p.h.

pendingMessages

PendingMessagesForEmit TQT_DBusConnectionPrivate::pendingMessages

Definition at line 160 of file tqdbusconnection_p.h.

pendingTimeouts

TQValueList<DBusTimeout *> TQT_DBusConnectionPrivate::pendingTimeouts

Definition at line 148 of file tqdbusconnection_p.h.

ref

Atomic TQT_DBusConnectionPrivate::ref

Definition at line 115 of file tqdbusconnection_p.h.

registeredObjects

ObjectMap TQT_DBusConnectionPrivate::registeredObjects

Definition at line 146 of file tqdbusconnection_p.h.

removedWatches

WatcherList TQT_DBusConnectionPrivate::removedWatches

Definition at line 137 of file tqdbusconnection_p.h.

server

DBusServer* TQT_DBusConnectionPrivate::server

Definition at line 118 of file tqdbusconnection_p.h.

timeouts

TimeoutHash TQT_DBusConnectionPrivate::timeouts

Definition at line 143 of file tqdbusconnection_p.h.

watchers

WatcherHash TQT_DBusConnectionPrivate::watchers

Definition at line 139 of file tqdbusconnection_p.h.

---

The documentation for this class was generated from the following files:

• tqdbusconnection_p.h
• tqdbusconnection.cpp
• tqdbusintegrator.cpp