TQT_DBusConnectionPrivate Class Reference

#include <tqdbusconnection_p.h>

Collaboration diagram for TQT_DBusConnectionPrivate:
[legend]

List of all members.

Classes

struct  TQT_DBusPendingCall
struct  Watcher

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 ()
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

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

Definition at line 144 of file tqdbusconnection_p.h.

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

Definition at line 155 of file tqdbusconnection_p.h.

typedef TQValueList<TQT_DBusMessage> TQT_DBusConnectionPrivate::PendingMessagesForEmit

Definition at line 158 of file tqdbusconnection_p.h.

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

Definition at line 141 of file tqdbusconnection_p.h.

typedef TQMap<int, WatcherList> TQT_DBusConnectionPrivate::WatcherHash

Definition at line 137 of file tqdbusconnection_p.h.

typedef TQValueList<Watcher> TQT_DBusConnectionPrivate::WatcherList

Definition at line 135 of file tqdbusconnection_p.h.

Member Enumeration Documentation

enum TQT_DBusConnectionPrivate::ConnectionMode
Enumerator:
InvalidMode 
ServerMode 
ClientMode 

Definition at line 111 of file tqdbusconnection_p.h.

00111 { InvalidMode, ServerMode, ClientMode };

Constructor & Destructor Documentation

TQT_DBusConnectionPrivate::TQT_DBusConnectionPrivate ( TQObject *  parent = 0  ) 

Definition at line 274 of file tqdbusintegrator.cpp.

References dispatch(), dispatcher, error, m_messageEmissionQueueTimer, m_resultEmissionQueueTimer, registerMessageMetaType(), transmitMessageEmissionQueue(), and transmitResultEmissionQueue().

00275     : TQObject(parent), ref(1), mode(InvalidMode), connection(0), server(0),
00276       dispatcher(0), inDispatch(false)
00277 {
00278     static const int msgType = registerMessageMetaType();
00279     Q_UNUSED(msgType);
00280 
00281     dbus_error_init(&error);
00282 
00283     dispatcher = new TQTimer(this);
00284     TQObject::connect(dispatcher, TQT_SIGNAL(timeout()), this, TQT_SLOT(dispatch()));
00285 
00286     m_resultEmissionQueueTimer = new TQTimer(this);
00287     TQObject::connect(m_resultEmissionQueueTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(transmitResultEmissionQueue()));
00288     m_messageEmissionQueueTimer = new TQTimer(this);
00289     TQObject::connect(m_messageEmissionQueueTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(transmitMessageEmissionQueue()));
00290 }

Here is the call graph for this function:

TQT_DBusConnectionPrivate::~TQT_DBusConnectionPrivate (  ) 

Definition at line 292 of file tqdbusintegrator.cpp.

References closeConnection(), error, and pendingCalls.

00293 {
00294     for (PendingCallMap::iterator it = pendingCalls.begin(); it != pendingCalls.end();)
00295     {
00296         PendingCallMap::iterator copyIt = it;
00297         ++it;
00298         dbus_pending_call_cancel(copyIt.key());
00299         dbus_pending_call_unref(copyIt.key());
00300         delete copyIt.data();
00301         pendingCalls.erase(copyIt);
00302     }
00303 
00304     if (dbus_error_is_set(&error))
00305         dbus_error_free(&error);
00306 
00307     closeConnection();
00308 }

Here is the call graph for this function:

Member Function Documentation

void TQT_DBusConnectionPrivate::bindToApplication (  ) 

Definition at line 347 of file tqdbusintegrator.cpp.

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

00348 {
00349     // Yay, now that we have an application we are in business
00350     // Re-add all watchers
00351     WatcherHash oldWatchers = watchers;
00352     watchers.clear();
00353     // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(oldWatchers);
00354     for (WatcherHash::const_iterator it = oldWatchers.begin(); it != oldWatchers.end(); ++it)
00355     {
00356         const WatcherList& list = *it;
00357         for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit)
00358         {
00359             if (!(*wit).read && !(*wit).write) {
00360                 qDBusAddWatch((*wit).watch, this);
00361             }
00362         }
00363     }
00364 
00365     // Re-add all timeouts
00366     while (!pendingTimeouts.isEmpty()) {
00367        qDBusAddTimeout(pendingTimeouts.first(), this);
00368        pendingTimeouts.pop_front();
00369     }
00370 }

Here is the call graph for this function:

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::closeConnection (  ) 

Definition at line 310 of file tqdbusintegrator.cpp.

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

00311 {
00312     ConnectionMode oldMode = mode;
00313     mode = InvalidMode; // prevent reentrancy
00314     if (oldMode == ServerMode) {
00315         if (server) {
00316             dbus_server_disconnect(server);
00317             dbus_server_unref(server);
00318             server = 0;
00319         }
00320     } else if (oldMode == ClientMode) {
00321         if (connection) {
00322             // closing shared connections is forbidden
00323 #if 0
00324             dbus_connection_close(connection);
00325             // send the "close" message
00326             while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS);
00327 #endif
00328             dbus_connection_unref(connection);
00329             connection = 0;
00330         }
00331     }
00332 }

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::dbusPendingCallReply ( const TQT_DBusMessage &  message  )  [signal]

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::dbusSignal ( const TQT_DBusMessage &  message  )  [signal]

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::dispatch (  )  [slot]

Definition at line 468 of file tqdbusintegrator.cpp.

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

00469 {
00470     // dbus_connection_dispatch will hang if called recursively
00471     if (inDispatch) {
00472         printf("[dbus-1-tqt] WARNING: Attempt to call dispatch() recursively was silently ignored to prevent lockup!\n\r"); fflush(stdout);
00473         return;
00474     }
00475     inDispatch = true;
00476 
00477     if (mode == ClientMode)
00478     {
00479         if (dbus_connection_dispatch(connection) != DBUS_DISPATCH_DATA_REMAINS)
00480         {
00481             // stop dispatch timer
00482             dispatcher->stop();
00483         }
00484     }
00485 
00486     inDispatch = false;
00487 }

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::emitPendingCallReply ( const TQT_DBusMessage &  message  ) 

Definition at line 342 of file tqdbusintegrator.cpp.

References dbusPendingCallReply().

00343 {
00344     emit dbusPendingCallReply(message);
00345 }

Here is the call graph for this function:

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::flush (  ) 

Definition at line 660 of file tqdbusintegrator.cpp.

References connection.

00661 {
00662     if (!connection) return;
00663 
00664     dbus_connection_flush(connection);
00665 }

Here is the caller graph for this function:

bool TQT_DBusConnectionPrivate::handleError (  ) 

Definition at line 334 of file tqdbusintegrator.cpp.

References error, TQT_DBusError::isValid(), and lastError.

00335 {
00336     lastError = TQT_DBusError(&error);
00337     if (dbus_error_is_set(&error))
00338         dbus_error_free(&error);
00339     return lastError.isValid();
00340 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool TQT_DBusConnectionPrivate::handleObjectCall ( DBusMessage *  message  ) 

Definition at line 500 of file tqdbusintegrator.cpp.

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

00501 {
00502     TQT_DBusMessage msg = TQT_DBusMessage::fromDBusMessage(message);
00503 
00504     ObjectMap::iterator it = registeredObjects.find(msg.path());
00505     if (it == registeredObjects.end())
00506         return false;
00507 
00508     return it.data()->handleMethodCall(msg);
00509 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool TQT_DBusConnectionPrivate::handleSignal ( DBusMessage *  msg  ) 

Definition at line 511 of file tqdbusintegrator.cpp.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::newMethodInResultEmissionQueue (  ) 

Definition at line 667 of file tqdbusintegrator.cpp.

References m_resultEmissionQueueTimer.

00668 {
00669     if (!m_resultEmissionQueueTimer->isActive()) m_resultEmissionQueueTimer->start(0, TRUE);
00670 }

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::objectDestroyed ( TQObject *  object  )  [slot]

Definition at line 404 of file tqdbusintegrator.cpp.

References pendingCalls.

00405 {
00406     //tqDebug("Object destroyed");
00407     for (PendingCallMap::iterator it = pendingCalls.begin(); it != pendingCalls.end();)
00408     {
00409         TQObject* receiver = (TQObject*) it.data()->receiver;
00410         if (receiver == object || receiver == 0)
00411         {
00412             PendingCallMap::iterator copyIt = it;
00413             ++it;
00414 
00415             dbus_pending_call_cancel(copyIt.key());
00416             dbus_pending_call_unref(copyIt.key());
00417             delete copyIt.data();
00418             pendingCalls.erase(copyIt);
00419         }
00420         else
00421             ++it;
00422     }
00423 }

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::purgeRemovedWatches (  )  [slot]

Definition at line 425 of file tqdbusintegrator.cpp.

References removedWatches, and watchers.

00426 {
00427     if (removedWatches.isEmpty()) return;
00428 
00429     WatcherList::iterator listIt = removedWatches.begin();
00430     for (; listIt != removedWatches.end(); ++listIt)
00431     {
00432         delete (*listIt).read;
00433         delete (*listIt).write;
00434     }
00435     removedWatches.clear();
00436 
00437     uint count = 0;
00438     WatcherHash::iterator it = watchers.begin();
00439     while (it != watchers.end())
00440     {
00441         WatcherList& list = *it;
00442         listIt = list.begin();
00443         while (listIt != list.end())
00444         {
00445             if (!((*listIt).read) && !((*listIt).write))
00446             {
00447                 listIt = list.erase(listIt);
00448                 ++count;
00449             }
00450         }
00451 
00452         if (list.isEmpty())
00453         {
00454             WatcherHash::iterator copyIt = it;
00455             ++it;
00456             watchers.erase(copyIt);
00457         }
00458         else
00459             ++it;
00460     }
00461 }

int TQT_DBusConnectionPrivate::registerMessageMetaType (  )  [static]

Definition at line 267 of file tqdbusintegrator.cpp.

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

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::scheduleDispatch (  )  [slot]

Definition at line 463 of file tqdbusintegrator.cpp.

References dispatcher.

00464 {
00465     dispatcher->start(0);
00466 }

Here is the caller graph for this function:

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

Definition at line 628 of file tqdbusintegrator.cpp.

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().

00630 {
00631     if (!receiver || !method)
00632         return 0;
00633 
00634     if (!TQObject::connect(receiver, TQT_SIGNAL(destroyed(TQObject*)),
00635                           this, TQT_SLOT(objectDestroyed(TQObject*))))
00636         return false;
00637 
00638     DBusMessage *msg = message.toDBusMessage();
00639     if (!msg)
00640         return 0;
00641 
00642     int msg_serial = 0;
00643     DBusPendingCall *pending = 0;
00644     if (dbus_connection_send_with_reply(connection, msg, &pending, message.timeout())) {
00645         TQT_DBusPendingCall *pcall = new TQT_DBusPendingCall;
00646         pcall->receiver = receiver;
00647         pcall->method = method;
00648         pcall->pending = pending;
00649         pendingCalls.insert(pcall->pending, pcall);
00650 
00651         dbus_pending_call_set_notify(pending, qDBusResultReceived, this, 0);
00652 
00653         msg_serial = dbus_message_get_serial(msg);
00654     }
00655 
00656     dbus_message_unref(msg);
00657     return msg_serial;
00658 }

Here is the call graph for this function:

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::setConnection ( DBusConnection *  connection  ) 

Definition at line 553 of file tqdbusintegrator.cpp.

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

00554 {
00555     if (!dbc) {
00556         handleError();
00557         return;
00558     }
00559 
00560     connection = dbc;
00561     mode = ClientMode;
00562 
00563     dbus_connection_set_exit_on_disconnect(connection, false);
00564     dbus_connection_set_watch_functions(connection, qDBusAddWatch, qDBusRemoveWatch,
00565                                         qDBusToggleWatch, this, 0);
00566     dbus_connection_set_timeout_functions(connection, qDBusAddTimeout, qDBusRemoveTimeout,
00567                                           qDBusToggleTimeout, this, 0);
00568 //    dbus_bus_add_match(connection, "type='signal',interface='com.trolltech.dbus.Signal'", &error);
00569 //    dbus_bus_add_match(connection, "type='signal'", &error);
00570 
00571     dbus_bus_add_match(connection, "type='signal'", &error);
00572     if (handleError()) {
00573         closeConnection();
00574         return;
00575     }
00576 
00577     const char *service = dbus_bus_get_unique_name(connection);
00578     if (service) {
00579         TQCString filter;
00580         filter += "destination='";
00581         filter += service;
00582         filter += "\'";
00583 
00584         dbus_bus_add_match(connection, filter.data(), &error);
00585         if (handleError()) {
00586             closeConnection();
00587             return;
00588         }
00589     } else {
00590         tqWarning("TQT_DBusConnectionPrivate::SetConnection: Unable to get unique name");
00591     }
00592 
00593     dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0);
00594 
00595     //tqDebug("unique name: %s", service);
00596 }

Here is the call graph for this function:

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::setServer ( DBusServer *  server  ) 

Definition at line 530 of file tqdbusintegrator.cpp.

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

00531 {
00532     if (!server) {
00533         handleError();
00534         return;
00535     }
00536 
00537     server = s;
00538     mode = ServerMode;
00539 
00540     dbus_server_allocate_data_slot(&server_slot);
00541     if (server_slot < 0)
00542         return;
00543 
00544     dbus_server_set_watch_functions(server, qDBusAddWatch, qDBusRemoveWatch,
00545                                     qDBusToggleWatch, this, 0); // ### check return type?
00546     dbus_server_set_timeout_functions(server, qDBusAddTimeout, qDBusRemoveTimeout,
00547                                       qDBusToggleTimeout, this, 0);
00548     dbus_server_set_new_connection_function(server, qDBusNewConnection, this, 0);
00549 
00550     dbus_server_set_data(server, server_slot, this, 0);
00551 }

Here is the call graph for this function:

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::socketRead ( int  fd  )  [slot]

Definition at line 372 of file tqdbusintegrator.cpp.

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

00373 {
00374     // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(watchers);
00375     WatcherHash::const_iterator it = watchers.find(fd);
00376     if (it != watchers.end()) {
00377         const WatcherList& list = *it;
00378         for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit) {
00379             if ((*wit).read && (*wit).read->isEnabled()) {
00380                 if (!dbus_watch_handle((*wit).watch, DBUS_WATCH_READABLE))
00381                     tqDebug("OUT OF MEM");
00382             }
00383         }
00384     }
00385     if (mode == ClientMode)
00386         scheduleDispatch();
00387 }

Here is the call graph for this function:

void TQT_DBusConnectionPrivate::socketWrite ( int  fd  )  [slot]

Definition at line 389 of file tqdbusintegrator.cpp.

References watchers.

00390 {
00391     // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(watchers);
00392     WatcherHash::const_iterator it = watchers.find(fd);
00393     if (it != watchers.end()) {
00394         const WatcherList& list = *it;
00395         for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit) {
00396             if ((*wit).write && (*wit).write->isEnabled()) {
00397                 if (!dbus_watch_handle((*wit).watch, DBUS_WATCH_WRITABLE))
00398                     tqDebug("OUT OF MEM");
00399             }
00400         }
00401     }
00402 }

void TQT_DBusConnectionPrivate::timerEvent ( TQTimerEvent *  e  ) 

Definition at line 246 of file tqdbusconnection.cpp.

References timeouts.

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

void TQT_DBusConnectionPrivate::transmitMessageEmissionQueue (  )  [private, slot]

Definition at line 489 of file tqdbusintegrator.cpp.

References dbusSignal(), and pendingMessages.

00490 {
00491     TQT_DBusConnectionPrivate::PendingMessagesForEmit::iterator pmfe;
00492     pmfe = pendingMessages.begin();
00493     while (pmfe != pendingMessages.end()) {
00494         TQT_DBusMessage msg = *pmfe;
00495         pmfe = pendingMessages.remove(pmfe);
00496         dbusSignal(msg);
00497     }
00498 }

Here is the call graph for this function:

Here is the caller graph for this function:

void TQT_DBusConnectionPrivate::transmitResultEmissionQueue (  )  [private, slot]

Definition at line 672 of file tqdbusintegrator.cpp.

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

00673 {
00674     if (!m_resultEmissionQueue.isEmpty()) {
00675         TQT_DBusResultInfoList::Iterator it;
00676         it = m_resultEmissionQueue.begin();
00677         while (it != m_resultEmissionQueue.end()) {
00678             TQT_DBusResultInfo dbusResult = (*it);
00679             m_resultEmissionQueue.remove(it);
00680             it = m_resultEmissionQueue.begin();
00681 
00682             TQObject::connect(this, TQT_SIGNAL(dbusPendingCallReply(const TQT_DBusMessage&)), dbusResult.receiver, dbusResult.method.data());
00683             emitPendingCallReply(dbusResult.message);
00684             TQObject::disconnect(this, TQT_SIGNAL(dbusPendingCallReply(const TQT_DBusMessage&)), dbusResult.receiver, dbusResult.method.data());
00685         }
00686     }
00687 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

DBusConnection* TQT_DBusConnectionPrivate::connection

Definition at line 116 of file tqdbusconnection_p.h.

TQTimer* TQT_DBusConnectionPrivate::dispatcher

Definition at line 119 of file tqdbusconnection_p.h.

DBusError TQT_DBusConnectionPrivate::error

Definition at line 108 of file tqdbusconnection_p.h.

bool TQT_DBusConnectionPrivate::inDispatch

Definition at line 161 of file tqdbusconnection_p.h.

TQT_DBusError TQT_DBusConnectionPrivate::lastError

Definition at line 109 of file tqdbusconnection_p.h.

TQTimer* TQT_DBusConnectionPrivate::m_messageEmissionQueueTimer [private]

Definition at line 174 of file tqdbusconnection_p.h.

TQT_DBusResultInfoList TQT_DBusConnectionPrivate::m_resultEmissionQueue

Definition at line 163 of file tqdbusconnection_p.h.

TQTimer* TQT_DBusConnectionPrivate::m_resultEmissionQueueTimer [private]

Definition at line 173 of file tqdbusconnection_p.h.

int TQT_DBusConnectionPrivate::messageMetaType = 0 [static]

Definition at line 121 of file tqdbusconnection_p.h.

ConnectionMode TQT_DBusConnectionPrivate::mode

Definition at line 115 of file tqdbusconnection_p.h.

PendingCallMap TQT_DBusConnectionPrivate::pendingCalls

Definition at line 156 of file tqdbusconnection_p.h.

PendingMessagesForEmit TQT_DBusConnectionPrivate::pendingMessages

Definition at line 159 of file tqdbusconnection_p.h.

TQValueList<DBusTimeout *> TQT_DBusConnectionPrivate::pendingTimeouts

Definition at line 147 of file tqdbusconnection_p.h.

Atomic TQT_DBusConnectionPrivate::ref

Definition at line 114 of file tqdbusconnection_p.h.

ObjectMap TQT_DBusConnectionPrivate::registeredObjects

Definition at line 145 of file tqdbusconnection_p.h.

WatcherList TQT_DBusConnectionPrivate::removedWatches

Definition at line 136 of file tqdbusconnection_p.h.

DBusServer* TQT_DBusConnectionPrivate::server

Definition at line 117 of file tqdbusconnection_p.h.

TimeoutHash TQT_DBusConnectionPrivate::timeouts

Definition at line 142 of file tqdbusconnection_p.h.

WatcherHash TQT_DBusConnectionPrivate::watchers

Definition at line 138 of file tqdbusconnection_p.h.

The documentation for this class was generated from the following files:
Generated on Fri Apr 26 16:30:21 2019 for DBus-1-TQt by  doxygen 1.6.3