fdo-mirrors/dbus
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/dbus/dbus.git synced 2026-05-06 09:18:12 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Seperating integration with D-BUS from Connection to the internal Integrator

Browse source 
class. I simply hated the interfaces in the public Connection when it
had to contain a bunch of friends and protected members that were never
really meant to be seen.
This commit is contained in:
Zack Rusin 2003-11-24 05:21:12 +00:00
parent fb1df4eaff
commit 63a1458aaf
5 changed files with 281 additions and 89 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
qt/Makefile.am
View file

@ -8,7 +8,8 @@ dbusinclude_HEADERS= \
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

78
qt/connection.cpp
View file

@ -22,41 +22,43 @@
*/
#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
@ -84,55 +86,17 @@ void Connection::flush()
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"

48
qt/connection.h
View file

@ -23,12 +23,17 @@
#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
{
@ -39,52 +44,33 @@ namespace DBusQt {
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"
}
//////////////////////////////////////////////////////////////
}

126
qt/integrator.cpp Normal file
View file

@ -0,0 +1,126 @@
// -*- 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"

115
qt/integrator.h Normal file
View file

@ -0,0 +1,115 @@
// -*- 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