DBus-1-TQt  1.0
TQT_DBusConnectionPrivate Class Reference

#include <tqdbusconnection_p.h>

+ Inheritance diagram for TQT_DBusConnectionPrivate:
+ Collaboration diagram for TQT_DBusConnectionPrivate:

Classes

struct  TQT_DBusPendingCall
 
struct  Watcher
 

Public Types

enum  ConnectionMode { InvalidMode , ServerMode , ClientMode }
 
typedef TQValueList< WatcherWatcherList
 
typedef TQMap< int, WatcherListWatcherHash
 
typedef TQMap< int, DBusTimeout * > TimeoutHash
 
typedef TQMap< TQString, TQT_DBusObjectBase * > ObjectMap
 
typedef TQMap< DBusPendingCall *, TQT_DBusPendingCall * > PendingCallMap
 
typedef TQValueList< TQT_DBusMessagePendingMessagesForEmit
 

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

Definition at line 145 of file tqdbusconnection_p.h.

◆ PendingCallMap

Definition at line 156 of file tqdbusconnection_p.h.

◆ PendingMessagesForEmit

◆ TimeoutHash

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

Definition at line 142 of file tqdbusconnection_p.h.

◆ WatcherHash

Definition at line 138 of file tqdbusconnection_p.h.

◆ WatcherList

Member Enumeration Documentation

◆ ConnectionMode

Constructor & Destructor Documentation

◆ TQT_DBusConnectionPrivate()

TQT_DBusConnectionPrivate::TQT_DBusConnectionPrivate ( TQObject *  parent = 0)

Definition at line 274 of file tqdbusintegrator.cpp.

275  : TQObject(parent), ref(1), mode(InvalidMode), connection(0), server(0),
276  dispatcher(0), inDispatch(false)
277 {
278  static const int msgType = registerMessageMetaType();
279  Q_UNUSED(msgType);
280 
281  dbus_error_init(&error);
282 
283  dispatcher = new TQTimer(this);
284  TQObject::connect(dispatcher, TQ_SIGNAL(timeout()), this, TQ_SLOT(dispatch()));
285 
286  m_resultEmissionQueueTimer = new TQTimer(this);
287  TQObject::connect(m_resultEmissionQueueTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(transmitResultEmissionQueue()));
288  m_messageEmissionQueueTimer = new TQTimer(this);
289  TQObject::connect(m_messageEmissionQueueTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(transmitMessageEmissionQueue()));
290 }

References dispatch(), dispatcher, error, m_messageEmissionQueueTimer, m_resultEmissionQueueTimer, registerMessageMetaType(), 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.

293 {
294  for (PendingCallMap::iterator it = pendingCalls.begin(); it != pendingCalls.end();)
295  {
296  PendingCallMap::iterator copyIt = it;
297  ++it;
298  dbus_pending_call_cancel(copyIt.key());
299  dbus_pending_call_unref(copyIt.key());
300  delete copyIt.data();
301  pendingCalls.erase(copyIt);
302  }
303 
304  if (dbus_error_is_set(&error))
305  dbus_error_free(&error);
306 
307  closeConnection();
308 }

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.

371 {
372  // Yay, now that we have an application we are in business
373  // Re-add all watchers
374  WatcherHash oldWatchers = watchers;
375  watchers.clear();
376  // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(oldWatchers);
377  for (WatcherHash::const_iterator it = oldWatchers.begin(); it != oldWatchers.end(); ++it)
378  {
379  const WatcherList& list = *it;
380  for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit)
381  {
382  if (!(*wit).read && !(*wit).write) {
383  qDBusAddWatch((*wit).watch, this);
384  }
385  }
386  }
387 
388  // Re-add all timeouts
389  while (!pendingTimeouts.isEmpty()) {
390  qDBusAddTimeout(pendingTimeouts.first(), this);
391  pendingTimeouts.pop_front();
392  }
393 }
TQValueList< DBusTimeout * > pendingTimeouts
TQValueList< Watcher > WatcherList
TQMap< int, WatcherList > WatcherHash
static dbus_bool_t qDBusAddWatch(DBusWatch *watch, void *data)
static dbus_bool_t qDBusAddTimeout(DBusTimeout *timeout, void *data)

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ closeConnection()

void TQT_DBusConnectionPrivate::closeConnection ( )

Definition at line 310 of file tqdbusintegrator.cpp.

311 {
312  ConnectionMode oldMode = mode;
313  mode = InvalidMode; // prevent reentrancy
314  if (oldMode == ServerMode) {
315  if (server) {
316  dbus_server_disconnect(server);
317  dbus_server_unref(server);
318  server = 0;
319  }
320  } else if (oldMode == ClientMode) {
321  if (connection) {
322  // closing shared connections is forbidden
323 #if 0
324  dbus_connection_close(connection);
325  // send the "close" message
326  while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS);
327 #endif
328  dbus_connection_unref(connection);
329  connection = 0;
330  }
331  }
332 }

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.

492 {
493  // dbus_connection_dispatch will hang if called recursively
494  if (inDispatch) {
495  printf("[dbus-1-tqt] WARNING: Attempt to call dispatch() recursively was silently ignored to prevent lockup!\n\r"); fflush(stdout);
496  return;
497  }
498  inDispatch = true;
499 
500  if (mode == ClientMode)
501  {
502  if (dbus_connection_dispatch(connection) != DBUS_DISPATCH_DATA_REMAINS)
503  {
504  // stop dispatch timer
505  dispatcher->stop();
506  }
507  }
508 
509  inDispatch = false;
510 }

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.

366 {
367  emit dbusPendingCallReply(message);
368 }
void dbusPendingCallReply(const TQT_DBusMessage &message)

References dbusPendingCallReply().

+ Here is the caller graph for this function:

◆ flush()

void TQT_DBusConnectionPrivate::flush ( )

Definition at line 681 of file tqdbusintegrator.cpp.

682 {
683  if (!connection) return;
684 
685  dbus_connection_flush(connection);
686 }

References connection.

+ Here is the caller graph for this function:

◆ handleError()

bool TQT_DBusConnectionPrivate::handleError ( )

Definition at line 334 of file tqdbusintegrator.cpp.

335 {
337  if (dbus_error_is_set(&error))
338  dbus_error_free(&error);
339  return lastError.isValid();
340 }
Class for transporting D-Bus errors.
Definition: tqdbuserror.h:41
bool isValid() const
Returns whether the error object is valid.

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ handleObjectCall()

bool TQT_DBusConnectionPrivate::handleObjectCall ( DBusMessage *  message)

Definition at line 523 of file tqdbusintegrator.cpp.

524 {
526 
527  ObjectMap::iterator it = registeredObjects.find(msg.path());
528  if (it == registeredObjects.end())
529  return false;
530 
531  return it.data()->handleMethodCall(msg);
532 }
A message converts and transports data over D-Bus.
TQString path() const
Returns the message's object path.
static TQT_DBusMessage fromDBusMessage(DBusMessage *dmsg)
Creates a TQt3-bindings message from the given raw D-Bus message.

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.

535 {
537 
538  // yes, it is a single "|" below...
539  // FIXME-QT4
540  //return handleSignal(TQString(), msg) | handleSignal(msg.path(), msg);
541 
542  // If dbusSignal(msg) were called here, it could easily cause a lockup as it would enter the TQt3 event loop,
543  // which could result in arbitrary methods being called while still inside dbus_connection_dispatch.
544  // Instead, I enqueue the messages here for TQt3 event loop transmission after dbus_connection_dispatch is finished.
545  pendingMessages.append(msg);
546  if (!m_messageEmissionQueueTimer->isActive()) m_messageEmissionQueueTimer->start(0, true);
547 
548  return true;
549 }
PendingMessagesForEmit pendingMessages

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.

343 {
344  bool res = true;
345  WatcherHash::iterator it = watchers.begin();
346  while (it != watchers.end())
347  {
348  WatcherList &list = *it;
349  WatcherList::iterator listIt = list.begin();
350  while (listIt != list.end())
351  {
352  Watcher watcher = *listIt;
353  if (watcher.read)
354  {
355  socketRead(watcher.read->socket());
356  res &= (!handleError());
357  }
358  ++listIt;
359  }
360  ++it;
361  }
362  return res;
363 }

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ newMethodInResultEmissionQueue()

void TQT_DBusConnectionPrivate::newMethodInResultEmissionQueue ( )

Definition at line 688 of file tqdbusintegrator.cpp.

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

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.

428 {
429  //tqDebug("Object destroyed");
430  for (PendingCallMap::iterator it = pendingCalls.begin(); it != pendingCalls.end();)
431  {
432  TQObject* receiver = (TQObject*) it.data()->receiver;
433  if (receiver == object || receiver == 0)
434  {
435  PendingCallMap::iterator copyIt = it;
436  ++it;
437 
438  dbus_pending_call_cancel(copyIt.key());
439  dbus_pending_call_unref(copyIt.key());
440  delete copyIt.data();
441  pendingCalls.erase(copyIt);
442  }
443  else
444  ++it;
445  }
446 }

References pendingCalls.

+ Here is the caller graph for this function:

◆ purgeRemovedWatches

void TQT_DBusConnectionPrivate::purgeRemovedWatches ( )
slot

Definition at line 448 of file tqdbusintegrator.cpp.

449 {
450  if (removedWatches.isEmpty()) return;
451 
452  WatcherList::iterator listIt = removedWatches.begin();
453  for (; listIt != removedWatches.end(); ++listIt)
454  {
455  delete (*listIt).read;
456  delete (*listIt).write;
457  }
458  removedWatches.clear();
459 
460  uint count = 0;
461  WatcherHash::iterator it = watchers.begin();
462  while (it != watchers.end())
463  {
464  WatcherList& list = *it;
465  listIt = list.begin();
466  while (listIt != list.end())
467  {
468  if (!((*listIt).read) && !((*listIt).write))
469  {
470  listIt = list.erase(listIt);
471  ++count;
472  }
473  }
474 
475  if (list.isEmpty())
476  {
477  WatcherHash::iterator copyIt = it;
478  ++it;
479  watchers.erase(copyIt);
480  }
481  else
482  ++it;
483  }
484 }

References removedWatches, and watchers.

◆ registerMessageMetaType()

int TQT_DBusConnectionPrivate::registerMessageMetaType ( )
static

Definition at line 267 of file tqdbusintegrator.cpp.

268 {
269  // FIXME-QT4 int tp = messageMetaType = qRegisterMetaType<TQT_DBusMessage>("TQT_DBusMessage");
270  int tp = 0;
271  return tp;
272 }
+ Here is the caller graph for this function:

◆ scheduleDispatch

void TQT_DBusConnectionPrivate::scheduleDispatch ( )
slot

Definition at line 486 of file tqdbusintegrator.cpp.

487 {
488  dispatcher->start(0);
489 }

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.

651 {
652  if (!receiver || !method)
653  return 0;
654 
655  if (!TQObject::connect(receiver, TQ_SIGNAL(destroyed(TQObject*)),
656  this, TQ_SLOT(objectDestroyed(TQObject*))))
657  return false;
658 
659  DBusMessage *msg = message.toDBusMessage();
660  if (!msg)
661  return 0;
662 
663  int msg_serial = 0;
664  DBusPendingCall *pending = 0;
665  if (dbus_connection_send_with_reply(connection, msg, &pending, message.timeout())) {
666  TQT_DBusPendingCall *pcall = new TQT_DBusPendingCall;
667  pcall->receiver = receiver;
668  pcall->method = method;
669  pcall->pending = pending;
670  pendingCalls.insert(pcall->pending, pcall);
671 
672  dbus_pending_call_set_notify(pending, qDBusResultReceived, this, 0);
673 
674  msg_serial = dbus_message_get_serial(msg);
675  }
676 
677  dbus_message_unref(msg);
678  return msg_serial;
679 }
void objectDestroyed(TQObject *object)
int timeout() const
Returns the message's timeout.
DBusMessage * toDBusMessage() const
Creates a raw D-Bus message from this TQt3-bindings message.
static void qDBusResultReceived(DBusPendingCall *pending, void *user_data)

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:
+ Here is the caller graph for this function:

◆ setConnection()

void TQT_DBusConnectionPrivate::setConnection ( DBusConnection *  connection)

Definition at line 576 of file tqdbusintegrator.cpp.

577 {
578  if (!dbc) {
579  handleError();
580  return;
581  }
582 
583  connection = dbc;
584  mode = ClientMode;
585 
586  dbus_connection_set_exit_on_disconnect(connection, false);
587  dbus_connection_set_watch_functions(connection, qDBusAddWatch, qDBusRemoveWatch,
588  qDBusToggleWatch, this, 0);
589  dbus_connection_set_timeout_functions(connection, qDBusAddTimeout, qDBusRemoveTimeout,
590  qDBusToggleTimeout, this, 0);
591 
592  dbus_bus_add_match(connection, "type='signal'", &error);
593  if (handleError()) {
594  closeConnection();
595  return;
596  }
597 
598  const char *service = dbus_bus_get_unique_name(connection);
599  if (service) {
600  TQCString filter;
601  filter += "destination='";
602  filter += service;
603  filter += "'";
604 
605  dbus_bus_add_match(connection, filter.data(), &error);
606  if (handleError()) {
607  closeConnection();
608  return;
609  }
610  } else {
611  tqWarning("TQT_DBusConnectionPrivate::SetConnection: Unable to get unique name");
612  }
613 
614  dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0);
615 
616  //tqDebug("unique name: %s", service);
617 }
static void qDBusRemoveWatch(DBusWatch *watch, void *data)
static void qDBusToggleTimeout(DBusTimeout *timeout, void *data)
static void qDBusRemoveTimeout(DBusTimeout *timeout, void *data)
static DBusHandlerResult qDBusSignalFilter(DBusConnection *connection, DBusMessage *message, void *data)
static void qDBusToggleWatch(DBusWatch *watch, void *data)

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setServer()

void TQT_DBusConnectionPrivate::setServer ( DBusServer *  server)

Definition at line 553 of file tqdbusintegrator.cpp.

554 {
555  if (!server) {
556  handleError();
557  return;
558  }
559 
560  server = s;
561  mode = ServerMode;
562 
563  dbus_server_allocate_data_slot(&server_slot);
564  if (server_slot < 0)
565  return;
566 
567  dbus_server_set_watch_functions(server, qDBusAddWatch, qDBusRemoveWatch,
568  qDBusToggleWatch, this, 0); // ### check return type?
569  dbus_server_set_timeout_functions(server, qDBusAddTimeout, qDBusRemoveTimeout,
570  qDBusToggleTimeout, this, 0);
571  dbus_server_set_new_connection_function(server, qDBusNewConnection, this, 0);
572 
573  dbus_server_set_data(server, server_slot, this, 0);
574 }
static void qDBusNewConnection(DBusServer *server, DBusConnection *c, void *data)
static dbus_int32_t server_slot

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ socketRead

void TQT_DBusConnectionPrivate::socketRead ( int  fd)
slot

Definition at line 395 of file tqdbusintegrator.cpp.

396 {
397  // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(watchers);
398  WatcherHash::const_iterator it = watchers.find(fd);
399  if (it != watchers.end()) {
400  const WatcherList& list = *it;
401  for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit) {
402  if ((*wit).read && (*wit).read->isEnabled()) {
403  if (!dbus_watch_handle((*wit).watch, DBUS_WATCH_READABLE))
404  tqDebug("OUT OF MEM");
405  }
406  }
407  }
408  if (mode == ClientMode)
410 }

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.

413 {
414  // FIXME-QT4 TQHashIterator<int, TQT_DBusConnectionPrivate::Watcher> it(watchers);
415  WatcherHash::const_iterator it = watchers.find(fd);
416  if (it != watchers.end()) {
417  const WatcherList& list = *it;
418  for (WatcherList::const_iterator wit = list.begin(); wit != list.end(); ++wit) {
419  if ((*wit).write && (*wit).write->isEnabled()) {
420  if (!dbus_watch_handle((*wit).watch, DBUS_WATCH_WRITABLE))
421  tqDebug("OUT OF MEM");
422  }
423  }
424  }
425 }

References watchers.

◆ timerEvent()

void TQT_DBusConnectionPrivate::timerEvent ( TQTimerEvent *  e)

Definition at line 246 of file tqdbusconnection.cpp.

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

References timeouts.

◆ transmitMessageEmissionQueue

void TQT_DBusConnectionPrivate::transmitMessageEmissionQueue ( )
privateslot

Definition at line 512 of file tqdbusintegrator.cpp.

513 {
514  TQT_DBusConnectionPrivate::PendingMessagesForEmit::iterator pmfe;
515  pmfe = pendingMessages.begin();
516  while (pmfe != pendingMessages.end()) {
517  TQT_DBusMessage msg = *pmfe;
518  pmfe = pendingMessages.remove(pmfe);
519  dbusSignal(msg);
520  }
521 }
void dbusSignal(const TQT_DBusMessage &message)

References dbusSignal(), and pendingMessages.

+ Here is the caller graph for this function:

◆ transmitResultEmissionQueue

void TQT_DBusConnectionPrivate::transmitResultEmissionQueue ( )
privateslot

Definition at line 693 of file tqdbusintegrator.cpp.

694 {
695  if (!m_resultEmissionQueue.isEmpty()) {
696  TQT_DBusResultInfoList::Iterator it;
697  it = m_resultEmissionQueue.begin();
698  while (it != m_resultEmissionQueue.end()) {
699  TQT_DBusResultInfo dbusResult = (*it);
700  m_resultEmissionQueue.remove(it);
701  it = m_resultEmissionQueue.begin();
702 
703  TQObject::connect(this, TQ_SIGNAL(dbusPendingCallReply(const TQT_DBusMessage&)), dbusResult.receiver, dbusResult.method.data());
704  emitPendingCallReply(dbusResult.message);
705  TQObject::disconnect(this, TQ_SIGNAL(dbusPendingCallReply(const TQT_DBusMessage&)), dbusResult.receiver, dbusResult.method.data());
706  }
707  }
708 }
TQT_DBusResultInfoList m_resultEmissionQueue
void emitPendingCallReply(const TQT_DBusMessage &message)
TQT_DBusMessage message

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: