dbus-qt.h message.h connection.h
libdbus_qt_1_la_SOURCES = \
- dbus-qthread.cpp message.cpp connection.cpp
+ dbus-qthread.cpp message.cpp connection.cpp \
+ integrator.cpp
libdbus_qt_1_la_LIBADD= $(DBUS_QT_LIBS) $(top_builddir)/dbus/libdbus-1.la
libdbus_qt_1_la_LDFLAGS= -version-info 1:0
*/
#include "connection.h"
-#include <qsocketnotifier.h>
-#include <qintdict.h>
-
using namespace DBusQt;
-struct QtWatch {
- QtWatch(): readSocket( 0 ), writeSocket( 0 ) { }
-
- DBusWatch *watch;
- QSocketNotifier *readSocket;
- QSocketNotifier *writeSocket;
-};
+#include "integrator.h"
+using Internal::Integrator;
struct Connection::Private
{
DBusConnection *connection;
int connectionSlot;
DBusError error;
- QIntDict<QtWatch> watches;
+ Integrator *integrator;
};
Connection::Connection( const QString& host )
{
d = new Private;
- dbus_error_init( &d->error );
+ d->integrator = new Integrator( this );
+ connect( d->integrator, SIGNAL(readReady()),
+ SLOT(dispatchRead()) );
+
+ initDbus();
if ( !host.isEmpty() )
init( host );
}
+void Connection::initDbus()
+{
+}
+
void Connection::init( const QString& host )
{
+ dbus_error_init( &d->error );
d->connection = dbus_connection_open( host.ascii(), &d->error );
- dbus_connection_allocate_data_slot( &d->connectionSlot );
- dbus_connection_set_data( d->connection, d->connectionSlot, 0, 0 );
+ //dbus_connection_allocate_data_slot( &d->connectionSlot );
+ //dbus_connection_set_data( d->connection, d->connectionSlot, 0, 0 );
+ initDbus();
}
bool Connection::isConnected() const
dbus_connection_flush( d->connection );
}
-void Connection::slotRead( int fd )
+void Connection::dispatchRead()
{
- Q_UNUSED( fd );
while ( dbus_connection_dispatch( d->connection ) == DBUS_DISPATCH_DATA_REMAINS )
;
}
-void Connection::slotWrite( int fd )
+DBusConnection* Connection::connection() const
{
- Q_UNUSED( fd );
+ return d->connection;
}
-void Connection::addWatch( DBusWatch *watch )
-{
- if ( !dbus_watch_get_enabled( watch ) )
- return;
-
- QtWatch *qtwatch = new QtWatch;
- qtwatch->watch = watch;
-
- int flags = dbus_watch_get_flags( watch );
- int fd = dbus_watch_get_fd( watch );
-
- if ( flags & DBUS_WATCH_READABLE ) {
- qtwatch->readSocket = new QSocketNotifier( fd, QSocketNotifier::Read, this );
- QObject::connect( qtwatch->readSocket, SIGNAL(activated(int)), SLOT(slotRead(int)) );
- }
-
- if (flags & DBUS_WATCH_WRITABLE) {
- qtwatch->writeSocket = new QSocketNotifier( fd, QSocketNotifier::Write, this );
- QObject::connect( qtwatch->writeSocket, SIGNAL(activated(int)), SLOT(slotWrite(int)) );
- }
-
- d->watches.insert( fd, qtwatch );
-
-}
-
-void Connection::removeWatch( DBusWatch *watch )
-{
- int key = dbus_watch_get_fd( watch );
-
- QtWatch *qtwatch = d->watches.take( key );
-
- if ( qtwatch ) {
- delete qtwatch->readSocket; qtwatch->readSocket = 0;
- delete qtwatch->writeSocket; qtwatch->writeSocket = 0;
- delete qtwatch;
- }
-}
-
-
/////////////////////////////////////////////////////////
+
+#include "connection.moc"
#ifndef DBUS_QT_CONNECTION_H
#define DBUS_QT_CONNECTION_H
+#include "message.h"
+
#include <qobject.h>
#include <qstring.h>
#include "dbus/dbus.h"
namespace DBusQt {
+ namespace Internal {
+ class Integrator;
+ }
class Connection : public QObject
{
bool isConnected() const;
bool isAuthenticated() const;
+ Message borrowMessage();
+ Message popMessage();
+ void stealBorrowMessage( const Message& );
+
public slots:
void open( const QString& );
void close();
void flush();
+ void send( const Message& );
+ void sendWithReply( const Message& );
+ void sendWithReplyAndBlock( const Message& );
protected slots:
- void slotRead( int );
- void slotWrite( int );
-
- protected:
- void addWatch( DBusWatch* );
- void removeWatch( DBusWatch* );
-
- public:
- friend dbus_bool_t dbusAddWatch( DBusWatch*, void* );
- friend dbus_bool_t dbusRemoveWatch( DBusWatch*, void* );
- friend dbus_bool_t dbusToggleWatch( DBusWatch*, void* );
+ void dispatchRead();
protected:
void init( const QString& host );
+ void initDbus();
virtual void* virtual_hook( int id, void* data );
private:
+ friend class Internal::Integrator;
+ DBusConnection* connection() const;
+ private:
struct Private;
Private *d;
};
- //////////////////////////////////////////////////////////////
- //Friends
- dbus_bool_t dbusAddWatch( DBusWatch *watch, void *data )
- {
- Connection *con = static_cast<Connection*>( data );
- con->addWatch( watch );
- }
- dbus_bool_t dbusRemoveWatch( DBusWatch *watch, void *data )
- {
- Connection *con = static_cast<Connection*>( data );
- con->removeWatch( watch );
- }
-
- dbus_bool_t dbusToggleWatch( DBusWatch*, void* )
- {
- //I don't know how to handle this one right now
-#warning "FIXME: implement"
- }
- //////////////////////////////////////////////////////////////
-
}
--- /dev/null
+// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+/* integrator.h: integrates D-BUS into Qt event loop
+ *
+ * Copyright (C) 2003 Zack Rusin <zack@kde.org>
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#include "integrator.h"
+#include "connection.h"
+
+#include <qtimer.h>
+#include <qsocketnotifier.h>
+#include <qintdict.h>
+#include <qptrlist.h>
+
+namespace DBusQt
+{
+namespace Internal {
+
+struct QtWatch {
+ QtWatch(): readSocket( 0 ), writeSocket( 0 ) { }
+
+ DBusWatch *watch;
+ QSocketNotifier *readSocket;
+ QSocketNotifier *writeSocket;
+};
+
+struct DBusQtTimeout {
+ DBusQtTimeout(): timer( 0 ), timeout( 0 ) { }
+ ~DBusQtTimeout() {
+ delete timer;
+ }
+ QTimer *timer;
+ DBusTimeout *timeout;
+};
+
+void dbusWakeupMain( void* )
+{
+}
+
+Integrator::Integrator( Connection *parent )
+ : QObject( parent ), m_parent( parent )
+{
+ dbus_connection_set_watch_functions( m_parent->connection(),
+ dbusAddWatch,
+ dbusRemoveWatch,
+ dbusToggleWatch,
+ this, 0 );
+ dbus_connection_set_timeout_functions( m_parent->connection(),
+ dbusAddTimeout,
+ dbusRemoveTimeout,
+ dbusToggleTimeout,
+ this, 0 );
+ dbus_connection_set_wakeup_main_function( m_parent->connection(),
+ dbusWakeupMain,
+ this, 0 );
+}
+
+void Integrator::slotRead( int fd )
+{
+ Q_UNUSED( fd );
+ emit readReady();
+}
+
+void Integrator::slotWrite( int fd )
+{
+ Q_UNUSED( fd );
+}
+
+void Integrator::addWatch( DBusWatch *watch )
+{
+ if ( !dbus_watch_get_enabled( watch ) )
+ return;
+
+ QtWatch *qtwatch = new QtWatch;
+ qtwatch->watch = watch;
+
+ int flags = dbus_watch_get_flags( watch );
+ int fd = dbus_watch_get_fd( watch );
+
+ if ( flags & DBUS_WATCH_READABLE ) {
+ qtwatch->readSocket = new QSocketNotifier( fd, QSocketNotifier::Read, this );
+ QObject::connect( qtwatch->readSocket, SIGNAL(activated(int)), SLOT(slotRead(int)) );
+ }
+
+ if (flags & DBUS_WATCH_WRITABLE) {
+ qtwatch->writeSocket = new QSocketNotifier( fd, QSocketNotifier::Write, this );
+ QObject::connect( qtwatch->writeSocket, SIGNAL(activated(int)), SLOT(slotWrite(int)) );
+ }
+
+ m_watches.insert( fd, qtwatch );
+}
+
+void Integrator::removeWatch( DBusWatch *watch )
+{
+ int key = dbus_watch_get_fd( watch );
+
+ QtWatch *qtwatch = m_watches.take( key );
+
+ if ( qtwatch ) {
+ delete qtwatch->readSocket; qtwatch->readSocket = 0;
+ delete qtwatch->writeSocket; qtwatch->writeSocket = 0;
+ delete qtwatch;
+ }
+}
+
+
+}//end namespace Internal
+}//end namespace DBusQt
+
+#include "integrator.moc"
--- /dev/null
+// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+/* integrator.h: integrates D-BUS into Qt event loop
+ *
+ * Copyright (C) 2003 Zack Rusin <zack@kde.org>
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#ifndef DBUS_QT_INTEGRATOR_H
+#define DBUS_QT_INTEGRATOR_H
+
+#include <qobject.h>
+
+#include <qintdict.h>
+#include <qptrlist.h>
+
+#include "dbus/dbus.h"
+
+namespace DBusQt
+{
+ class Connection;
+
+ namespace Internal
+ {
+ struct QtWatch;
+ struct DBusQtTimeout;
+ class Integrator : public QObject
+ {
+ Q_OBJECT
+ public:
+ Integrator( Connection* parent );
+
+ signals:
+ void readReady();
+
+ protected slots:
+ void slotRead( int );
+ void slotWrite( int );
+
+ protected:
+ void addWatch( DBusWatch* );
+ void removeWatch( DBusWatch* );
+
+ void addTimeout( DBusTimeout* );
+ void removeTimeout( DBusTimeout* );
+ private:
+ QIntDict<QtWatch> m_watches;
+ QPtrList<DBusQtTimeout> m_timeouts;
+ Connection* m_parent;
+
+ private:
+ friend dbus_bool_t dbusAddWatch( DBusWatch*, void* );
+ friend void dbusRemoveWatch( DBusWatch*, void* );
+ friend void dbusToggleWatch( DBusWatch*, void* );
+
+ friend dbus_bool_t dbusAddTimeout( DBusTimeout*, void* );
+ friend void dbusRemoveTimeout( DBusTimeout*, void* );
+ friend void dbusToggleTimeout( DBusTimeout*, void* );
+ };
+
+ //////////////////////////////////////////////////////////////
+ //Friends
+ dbus_bool_t dbusAddWatch( DBusWatch *watch, void *data )
+ {
+ Integrator *con = static_cast<Integrator*>( data );
+ con->addWatch( watch );
+ return true;
+ }
+ void dbusRemoveWatch( DBusWatch *watch, void *data )
+ {
+ Integrator *con = static_cast<Integrator*>( data );
+ con->removeWatch( watch );
+ }
+
+ void dbusToggleWatch( DBusWatch*, void* )
+ {
+ //I don't know how to handle this one right now
+//#warning "FIXME: implement"
+ }
+
+ dbus_bool_t dbusAddTimeout( DBusTimeout *timeout, void *data )
+ {
+ Integrator *con = static_cast<Integrator*>( data );
+ con->addTimeout( timeout );
+ return true;
+ }
+
+ void dbusRemoveTimeout( DBusTimeout *timeout, void *data )
+ {
+ Integrator *con = static_cast<Integrator*>( data );
+ }
+
+ void dbusToggleTimeout( DBusTimeout *timeout, void *data )
+ {
+ Integrator *con = static_cast<Integrator*>( data );
+ }
+ /////////////////////////////////////////////////////////////
+ }
+}
+
+#endif
projects / platform / upstream / dbus.git / commitdiff