From dfe289850f068f19ba4a83ab4e7e22a7e09c13c9 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sat, 26 Jan 2013 13:17:21 -0600 Subject: Rename a number of libraries and executables to avoid conflicts with KDE4 --- interfaces/tdeimproxy/library/CMakeLists.txt | 51 ++ interfaces/tdeimproxy/library/Makefile.am | 26 + interfaces/tdeimproxy/library/icons/CMakeLists.txt | 13 + interfaces/tdeimproxy/library/icons/Makefile.am | 1 + .../library/icons/cr16-action-presence_away.png | Bin 0 -> 852 bytes .../library/icons/cr16-action-presence_offline.png | Bin 0 -> 549 bytes .../library/icons/cr16-action-presence_online.png | Bin 0 -> 922 bytes .../library/icons/cr16-action-presence_unknown.png | Bin 0 -> 822 bytes .../library/icons/cr32-action-presence_away.png | Bin 0 -> 2402 bytes .../library/icons/cr32-action-presence_offline.png | Bin 0 -> 1407 bytes .../library/icons/cr32-action-presence_online.png | Bin 0 -> 2547 bytes .../library/icons/cr32-action-presence_unknown.png | Bin 0 -> 2483 bytes .../library/icons/cr48-action-presence_away.png | Bin 0 -> 3328 bytes .../library/icons/cr48-action-presence_offline.png | Bin 0 -> 1717 bytes .../library/icons/cr48-action-presence_online.png | Bin 0 -> 3370 bytes interfaces/tdeimproxy/library/tdeimproxy.cpp | 653 ++++++++++++++++++++ interfaces/tdeimproxy/library/tdeimproxy.h | 654 +++++++++++++++++++++ interfaces/tdeimproxy/library/tdeimproxyiface.h | 38 ++ 18 files changed, 1436 insertions(+) create mode 100644 interfaces/tdeimproxy/library/CMakeLists.txt create mode 100644 interfaces/tdeimproxy/library/Makefile.am create mode 100644 interfaces/tdeimproxy/library/icons/CMakeLists.txt create mode 100644 interfaces/tdeimproxy/library/icons/Makefile.am create mode 100644 interfaces/tdeimproxy/library/icons/cr16-action-presence_away.png create mode 100644 interfaces/tdeimproxy/library/icons/cr16-action-presence_offline.png create mode 100644 interfaces/tdeimproxy/library/icons/cr16-action-presence_online.png create mode 100644 interfaces/tdeimproxy/library/icons/cr16-action-presence_unknown.png create mode 100644 interfaces/tdeimproxy/library/icons/cr32-action-presence_away.png create mode 100644 interfaces/tdeimproxy/library/icons/cr32-action-presence_offline.png create mode 100644 interfaces/tdeimproxy/library/icons/cr32-action-presence_online.png create mode 100644 interfaces/tdeimproxy/library/icons/cr32-action-presence_unknown.png create mode 100644 interfaces/tdeimproxy/library/icons/cr48-action-presence_away.png create mode 100644 interfaces/tdeimproxy/library/icons/cr48-action-presence_offline.png create mode 100644 interfaces/tdeimproxy/library/icons/cr48-action-presence_online.png create mode 100644 interfaces/tdeimproxy/library/tdeimproxy.cpp create mode 100644 interfaces/tdeimproxy/library/tdeimproxy.h create mode 100644 interfaces/tdeimproxy/library/tdeimproxyiface.h (limited to 'interfaces/tdeimproxy/library') diff --git a/interfaces/tdeimproxy/library/CMakeLists.txt b/interfaces/tdeimproxy/library/CMakeLists.txt new file mode 100644 index 000000000..9aa1f60ee --- /dev/null +++ b/interfaces/tdeimproxy/library/CMakeLists.txt @@ -0,0 +1,51 @@ +################################################# +# +# (C) 2010 Serghei Amelian +# serghei (DOT) amelian (AT) gmail.com +# +# Improvements and feedback are welcome +# +# This file is released under GPL >= 2 +# +################################################# + +add_subdirectory( icons ) + +include_directories( + ${TQT_INCLUDE_DIRS} + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_BINARY_DIR}/tdecore + ${CMAKE_SOURCE_DIR}/dcop + ${CMAKE_SOURCE_DIR}/tdecore + ${CMAKE_SOURCE_DIR}/tdeui + ${CMAKE_SOURCE_DIR}/kio/kio +) + +link_directories( + ${TQT_LIBRARY_DIRS} +) + + +##### headers ################################### + +install( FILES + tdeimproxy.h tdeimproxyiface.h + DESTINATION ${INCLUDE_INSTALL_DIR} ) + + +##### tdeimproxy ################################## + +set( target tdeimproxy ) + +set( ${target}_SRCS + tdeimproxy.cpp tdeimproxyiface.skel + ${CMAKE_SOURCE_DIR}/interfaces/tdeimproxy/interface/kimiface.stub +) + +tde_add_library( ${target} SHARED AUTOMOC + SOURCES ${${target}_SRCS} + VERSION 0.0.0 + LINK kio-shared + DESTINATION ${LIB_INSTALL_DIR} + DEPENDENCIES dcopidl +) diff --git a/interfaces/tdeimproxy/library/Makefile.am b/interfaces/tdeimproxy/library/Makefile.am new file mode 100644 index 000000000..743b76424 --- /dev/null +++ b/interfaces/tdeimproxy/library/Makefile.am @@ -0,0 +1,26 @@ +SUBDIRS = icons + +INCLUDES = $(all_includes) + +noinst_HEADERS = tdeimproxyiface.h + +METASOURCES = AUTO + +AM_CPPFLAGS = $(all_includes) + +messages: rc.cpp + $(XGETTEXT) *.cpp -o $(podir)/tdeimproxy.pot + +tdeimproxyincludedir = $(includedir) +tdeimproxyinclude_HEADERS = tdeimproxy.h tdeimproxyiface.h + +lib_LTLIBRARIES = libtdeimproxy.la +libtdeimproxy_la_LDFLAGS = -no-undefined $(all_libraries) +libtdeimproxy_la_LIBADD = $(LIB_KIO) $(LIB_QT) $(LIB_TDECORE) $(top_builddir)/dcop/libDCOP.la $(LIB_TDEUI) +libtdeimproxy_la_SOURCES = tdeimproxy.cpp kimiface.stub tdeimproxyiface.skel + +kimiface_DIR = $(top_srcdir)/interfaces/tdeimproxy/interface + +include $(top_srcdir)/admin/Doxyfile.am +DOXYGEN_REFERENCES = kabc dcop + diff --git a/interfaces/tdeimproxy/library/icons/CMakeLists.txt b/interfaces/tdeimproxy/library/icons/CMakeLists.txt new file mode 100644 index 000000000..ac95aa58c --- /dev/null +++ b/interfaces/tdeimproxy/library/icons/CMakeLists.txt @@ -0,0 +1,13 @@ +################################################# +# +# (C) 2010 Serghei Amelian +# serghei (DOT) amelian (AT) gmail.com +# +# Improvements and feedback are welcome +# +# This file is released under GPL >= 2 +# +################################################# + +tde_install_icons( ) + diff --git a/interfaces/tdeimproxy/library/icons/Makefile.am b/interfaces/tdeimproxy/library/icons/Makefile.am new file mode 100644 index 000000000..a4b97f06a --- /dev/null +++ b/interfaces/tdeimproxy/library/icons/Makefile.am @@ -0,0 +1 @@ +KDE_ICON=AUTO diff --git a/interfaces/tdeimproxy/library/icons/cr16-action-presence_away.png b/interfaces/tdeimproxy/library/icons/cr16-action-presence_away.png new file mode 100644 index 000000000..f96a9c65f Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr16-action-presence_away.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr16-action-presence_offline.png b/interfaces/tdeimproxy/library/icons/cr16-action-presence_offline.png new file mode 100644 index 000000000..f5c53d711 Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr16-action-presence_offline.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr16-action-presence_online.png b/interfaces/tdeimproxy/library/icons/cr16-action-presence_online.png new file mode 100644 index 000000000..6cb52496b Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr16-action-presence_online.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr16-action-presence_unknown.png b/interfaces/tdeimproxy/library/icons/cr16-action-presence_unknown.png new file mode 100644 index 000000000..290bc852a Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr16-action-presence_unknown.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr32-action-presence_away.png b/interfaces/tdeimproxy/library/icons/cr32-action-presence_away.png new file mode 100644 index 000000000..086184582 Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr32-action-presence_away.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr32-action-presence_offline.png b/interfaces/tdeimproxy/library/icons/cr32-action-presence_offline.png new file mode 100644 index 000000000..caadb14d4 Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr32-action-presence_offline.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr32-action-presence_online.png b/interfaces/tdeimproxy/library/icons/cr32-action-presence_online.png new file mode 100644 index 000000000..41e79ad9d Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr32-action-presence_online.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr32-action-presence_unknown.png b/interfaces/tdeimproxy/library/icons/cr32-action-presence_unknown.png new file mode 100644 index 000000000..52ab79ed5 Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr32-action-presence_unknown.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr48-action-presence_away.png b/interfaces/tdeimproxy/library/icons/cr48-action-presence_away.png new file mode 100644 index 000000000..58e62c1d3 Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr48-action-presence_away.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr48-action-presence_offline.png b/interfaces/tdeimproxy/library/icons/cr48-action-presence_offline.png new file mode 100644 index 000000000..b69630f33 Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr48-action-presence_offline.png differ diff --git a/interfaces/tdeimproxy/library/icons/cr48-action-presence_online.png b/interfaces/tdeimproxy/library/icons/cr48-action-presence_online.png new file mode 100644 index 000000000..52fdad8f9 Binary files /dev/null and b/interfaces/tdeimproxy/library/icons/cr48-action-presence_online.png differ diff --git a/interfaces/tdeimproxy/library/tdeimproxy.cpp b/interfaces/tdeimproxy/library/tdeimproxy.cpp new file mode 100644 index 000000000..a65388974 --- /dev/null +++ b/interfaces/tdeimproxy/library/tdeimproxy.cpp @@ -0,0 +1,653 @@ +/* + tdeimproxy.cpp + + IM service library for KDE + + Copyright (c) 2004 Will Stephenson + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "kimiface_stub.h" + +#include "tdeimproxy.h" + +static KStaticDeleter _staticDeleter; + +KIMProxy * KIMProxy::s_instance = 0L; + +struct AppPresenceCurrent +{ + TQCString appId; + int presence; +}; + +class ContactPresenceListCurrent : public TQValueList +{ + public: + // return value indicates if the supplied parameter was better than any existing presence + bool update( const AppPresenceCurrent ); + AppPresenceCurrent best(); +}; + + +struct KIMProxy::Private +{ + DCOPClient * dc; + // list of the strings in use by KIMIface + TQStringList presence_strings; + // list of the icon names in use by KIMIface + TQStringList presence_icons; + // map of presences + PresenceStringMap presence_map; +}; + +bool ContactPresenceListCurrent::update( AppPresenceCurrent ap ) +{ + if ( isEmpty() ) + { + append( ap ); + return true; + } + + bool bestChanged = false; + AppPresenceCurrent best; + best.presence = -1; + ContactPresenceListCurrent::iterator it = begin(); + const ContactPresenceListCurrent::iterator itEnd = end(); + ContactPresenceListCurrent::iterator existing = itEnd; + + while ( it != itEnd ) + { + if ( (*it).presence > best.presence ) + best = (*it); + if ( (*it).appId == ap.appId ) + existing = it; + ++it; + } + + if ( ap.presence > best.presence || + best.appId == ap.appId ) + bestChanged = true; + + if ( existing != itEnd ) + { + remove( existing ); + append( ap ); + } + return bestChanged; +} + +AppPresenceCurrent ContactPresenceListCurrent::best() +{ + AppPresenceCurrent best; + best.presence = -1; + ContactPresenceListCurrent::iterator it = begin(); + const ContactPresenceListCurrent::iterator itEnd = end(); + while ( it != itEnd ) + { + if ( (*it).presence > best.presence ) + best = (*it); + ++it; + } + // if it's still -1 here, we have no presence data, so we return Unknown + if ( best.presence == -1 ) + best.presence = 0; + return best; +} + +// int bestPresence( AppPresence* ap ) +// { +// Q_ASSERT( ap ); +// AppPresence::const_iterator it; +// it = ap->begin(); +// int best = 0; // unknown +// if ( it != ap->end() ) +// { +// best = it.data(); +// ++it; +// for ( ; it != ap->end(); ++it ) +// { +// if ( it.data() > best ) +// best = it.data(); +// } +// } +// return best; +// } +// +// TQCString bestAppId( AppPresence* ap ) +// { +// Q_ASSERT( ap ); +// AppPresence::const_iterator it; +// TQCString bestAppId; +// it = ap->begin(); +// if ( it != ap->end() ) +// { +// int best = it.data(); +// bestAppId = it.key(); +// ++it; +// for ( ; it != ap->end(); ++it ) +// { +// if ( it.data() > best ) +// { +// best = it.data(); +// bestAppId = it.key(); +// } +// } +// } +// return bestAppId; +// } + +KIMProxy * KIMProxy::instance( DCOPClient * client ) +{ + if ( client ) + { + if ( !s_instance ) + _staticDeleter.setObject( s_instance, new KIMProxy( client ) ); + return s_instance; + } + else + return 0L; +} + +KIMProxy::KIMProxy( DCOPClient* dc ) : DCOPObject( "KIMProxyIface" ), TQObject(), d( new Private ) +{ + m_im_client_stubs.setAutoDelete( true ); + + d->dc = dc; + m_initialized = false; + connect( d->dc, TQT_SIGNAL( applicationRemoved( const TQCString& ) ) , this, TQT_SLOT( unregisteredFromDCOP( const TQCString& ) ) ); + connect( d->dc, TQT_SIGNAL( applicationRegistered( const TQCString& ) ) , this, TQT_SLOT( registeredToDCOP( const TQCString& ) ) ); + d->dc->setNotifications( true ); + + d->presence_strings.append( "Unknown" ); + d->presence_strings.append( "Offline" ); + d->presence_strings.append( "Connecting" ); + d->presence_strings.append( "Away" ); + d->presence_strings.append( "Online" ); + + d->presence_icons.append( "presence_unknown" ); + d->presence_icons.append( "presence_offline" ); + d->presence_icons.append( "presence_connecting" ); + d->presence_icons.append( "presence_away" ); + d->presence_icons.append( "presence_online" ); + + //TQCString senderApp = "Kopete"; + //TQCString senderObjectId = "KIMIface"; + TQCString method = "contactPresenceChanged( TQString, TQCString, int )"; + //TQCString receiverObjectId = "KIMProxyIface"; + + // FIXME: make this work when the sender object id is set to KIMIFace + if ( !connectDCOPSignal( 0, 0, method, method, false ) ) + kdWarning() << "Couldn't connect DCOP signal. Won't receive any status notifications!" << endl; +} + +KIMProxy::~KIMProxy( ) +{ + //d->dc->setNotifications( false ); +} + +bool KIMProxy::initialize() +{ + if ( !m_initialized ) + { + m_initialized = true; // we should only do this once, as registeredToDCOP() will catch any new starts + // So there is no error from a failed query when using tdelibs 3.2, which don't have this servicetype + if ( KServiceType::serviceType( IM_SERVICE_TYPE ) ) + { + //kdDebug( 790 ) << k_funcinfo << endl; + TQCString dcopObjectId = "KIMIface"; + + // see what apps implementing our service type are out there + KService::List offers = KServiceType::offers( IM_SERVICE_TYPE ); + KService::List::iterator offer; + typedef TQValueList QCStringList; + QCStringList registeredApps = d->dc->registeredApplications(); + QCStringList::iterator app; + const QCStringList::iterator end = registeredApps.end(); + // for each registered app + for ( app = registeredApps.begin(); app != end; ++app ) + { + //kdDebug( 790 ) << " considering: " << *app << endl; + //for each offer + for ( offer = offers.begin(); offer != offers.end(); ++offer ) + { + TQCString dcopService = (*offer)->property("X-DCOP-ServiceName").toString().latin1(); + if ( !dcopService.isEmpty() ) + { + //kdDebug( 790 ) << " is it: " << dcopService << "?" << endl; + // get the application name ( minus any process ID ) + TQCString instanceName = (*app).left( dcopService.length() ); + // if the application implements the dcop service, add it + if ( instanceName == dcopService ) + { + m_apps_available = true; + //kdDebug( 790 ) << " app name: " << (*offer)->name() << ", has instance " << *app << ", dcopService: " << dcopService << endl; + if ( !m_im_client_stubs.find( dcopService ) ) + { + kdDebug( 790 ) << "App " << *app << ", dcopObjectId " << dcopObjectId << " found, using it for presence info." << endl; + m_im_client_stubs.insert( *app, new KIMIface_stub( d->dc, *app, dcopObjectId ) ); + pollApp( *app ); + } + } + } + } + } + } + } + return !m_im_client_stubs.isEmpty(); +} + +void KIMProxy::registeredToDCOP( const TQCString& appId ) +{ + //kdDebug( 790 ) << k_funcinfo << " appId '" << appId << "'" << endl; + // check that appId implements our service + // if the appId ends with a number, i.e. a pid like in foobar-12345, + if ( appId.isEmpty() ) + return; + + bool newApp = false; + // get an up to date list of offers in case a new app was installed + // and check each of the offers that implement the service type we're looking for, + // to see if any of them are the app that just registered + const KService::List offers = KServiceType::offers( IM_SERVICE_TYPE ); + KService::List::const_iterator it; + for ( it = offers.begin(); it != offers.end(); ++it ) + { + TQCString dcopObjectId = "KIMIface"; + TQCString dcopService = (*it)->property("X-DCOP-ServiceName").toString().latin1(); + if ( appId.left( dcopService.length() ) == dcopService ) + { + // if it's not already known, insert it + if ( !m_im_client_stubs.find( appId ) ) + { + newApp = true; + kdDebug( 790 ) << "App: " << appId << ", dcopService: " << dcopService << " started, using it for presence info."<< endl; + m_im_client_stubs.insert( appId, new KIMIface_stub( d->dc, appId, dcopObjectId ) ); + } + } + //else + // kdDebug( 790 ) << "App doesn't implement our ServiceType" << endl; + } + //if ( newApp ) + // emit sigPresenceInfoExpired(); +} + +void KIMProxy::unregisteredFromDCOP( const TQCString& appId ) +{ + //kdDebug( 790 ) << k_funcinfo << appId << endl; + if ( m_im_client_stubs.find( appId ) ) + { + kdDebug( 790 ) << appId << " quit, removing its presence info." << endl; + + PresenceStringMap::Iterator it = d->presence_map.begin(); + const PresenceStringMap::Iterator end = d->presence_map.end(); + for ( ; it != end; ++it ) + { + ContactPresenceListCurrent list = it.data(); + ContactPresenceListCurrent::iterator cpIt = list.begin(); + while( cpIt != list.end() ) + { + ContactPresenceListCurrent::iterator gone = cpIt++; + if ( (*gone).appId == appId ) + { + list.remove( gone ); + } + } + } + m_im_client_stubs.remove( appId ); + emit sigPresenceInfoExpired(); + } +} + +void KIMProxy::contactPresenceChanged( TQString uid, TQCString appId, int presence ) +{ + // update the presence map + //kdDebug( 790 ) << k_funcinfo << "uid: " << uid << " appId: " << appId << " presence " << presence << endl; + ContactPresenceListCurrent current; + current = d->presence_map[ uid ]; + //kdDebug( 790 ) << "current best presence from : " << current.best().appId << " is: " << current.best().presence << endl; + AppPresenceCurrent newPresence; + newPresence.appId = appId; + newPresence.presence = presence; + + if ( current.update( newPresence ) ) + { + d->presence_map.insert( uid, current ); + emit sigContactPresenceChanged( uid ); + } +} + +int KIMProxy::presenceNumeric( const TQString& uid ) +{ + AppPresenceCurrent ap; + ap.presence = 0; + if ( initialize() ) + { + ContactPresenceListCurrent presence = d->presence_map[ uid ]; + ap = presence.best(); + } + return ap.presence; +} + +TQString KIMProxy::presenceString( const TQString& uid ) +{ + AppPresenceCurrent ap; + ap.presence = 0; + if ( initialize() ) + { + ContactPresenceListCurrent presence = d->presence_map[ uid ]; + ap = presence.best(); + } + if ( ap.appId.isEmpty() ) + return TQString::null; + else + return d->presence_strings[ ap.presence ]; +} + +TQPixmap KIMProxy::presenceIcon( const TQString& uid ) +{ + AppPresenceCurrent ap; + ap.presence = 0; + if ( initialize() ) + { + ContactPresenceListCurrent presence = d->presence_map[ uid ]; + ap = presence.best(); + } + if ( ap.appId.isEmpty() ) + { + //kdDebug( 790 ) << k_funcinfo << "returning a null TQPixmap because we were asked for an icon for a uid we know nothing about" << endl; + return TQPixmap(); + } + else + { + //kdDebug( 790 ) << k_funcinfo << "returning this: " << d->presence_icons[ ap.presence ] << endl; + return SmallIcon( d->presence_icons[ ap.presence ]); + } +} + +TQStringList KIMProxy::allContacts() +{ + TQStringList value = d->presence_map.keys(); + return value; +} + +TQStringList KIMProxy::reachableContacts() +{ + TQStringList value; + + if ( initialize() ) + { + TQDictIterator it( m_im_client_stubs ); + for ( ; it.current(); ++it ) + { + value += it.current()->reachableContacts( ); + } + } + return value; +} + +TQStringList KIMProxy::onlineContacts() +{ + TQStringList value; + PresenceStringMap::iterator it = d->presence_map.begin(); + const PresenceStringMap::iterator end= d->presence_map.end(); + for ( ; it != end; ++it ) + if ( it.data().best().presence > 2 /*Better than Connecting, ie Away or Online*/ ) + value.append( it.key() ); + + return value; +} + +TQStringList KIMProxy::fileTransferContacts() +{ + TQStringList value; + + if ( initialize() ) + { + TQDictIterator it( m_im_client_stubs ); + for ( ; it.current(); ++it ) + { + value += it.current()->fileTransferContacts( ); + } + } + return value; +} + +bool KIMProxy::isPresent( const TQString& uid ) +{ + return ( !d->presence_map[ uid ].isEmpty() ); +} + +TQString KIMProxy::displayName( const TQString& uid ) +{ + TQString name; + if ( initialize() ) + { + if ( KIMIface_stub* s = stubForUid( uid ) ) + name = s->displayName( uid ); + } + //kdDebug( 790 ) << k_funcinfo << name << endl; + return name; +} + +bool KIMProxy::canReceiveFiles( const TQString & uid ) +{ + if ( initialize() ) + { + if ( KIMIface_stub* s = stubForUid( uid ) ) + return s->canReceiveFiles( uid ); + } + return false; +} + +bool KIMProxy::canRespond( const TQString & uid ) +{ + if ( initialize() ) + { + if ( KIMIface_stub* s = stubForUid( uid ) ) + return s->canRespond( uid ); + } + return false; +} + +TQString KIMProxy::context( const TQString & uid ) +{ + if ( initialize() ) + { + if ( KIMIface_stub* s = stubForUid( uid ) ) + return s->context( uid ); + } + return TQString::null; +} + +void KIMProxy::chatWithContact( const TQString& uid ) +{ + if ( initialize() ) + { + if ( KIMIface_stub* s = stubForUid( uid ) ) + { + kapp->updateRemoteUserTimestamp( s->app() ); + s->chatWithContact( uid ); + } + } + return; +} + +void KIMProxy::messageContact( const TQString& uid, const TQString& message ) +{ + if ( initialize() ) + { + if ( KIMIface_stub* s = stubForUid( uid ) ) + { + kapp->updateRemoteUserTimestamp( s->app() ); + s->messageContact( uid, message ); + } + } + return; +} + +void KIMProxy::sendFile(const TQString &uid, const KURL &sourceURL, const TQString &altFileName, uint fileSize ) +{ + if ( initialize() ) + { + TQDictIterator it( m_im_client_stubs ); + for ( ; it.current(); ++it ) + { + if ( it.current()->canReceiveFiles( uid ) ) + { + kapp->updateRemoteUserTimestamp( it.current()->app() ); + it.current()->sendFile( uid, sourceURL, altFileName, fileSize ); + break; + } + } + } + return; +} + +bool KIMProxy::addContact( const TQString &contactId, const TQString &protocol ) +{ + if ( initialize() ) + { + if ( KIMIface_stub* s = stubForProtocol( protocol ) ) + return s->addContact( contactId, protocol ); + } + return false; +} + +TQString KIMProxy::locate( const TQString & contactId, const TQString & protocol ) +{ + if ( initialize() ) + { + if ( KIMIface_stub* s = stubForProtocol( protocol ) ) + return s->locate( contactId, protocol ); + } + return TQString::null; +} + +bool KIMProxy::imAppsAvailable() +{ + return ( !m_im_client_stubs.isEmpty() ); +} + +bool KIMProxy::startPreferredApp() +{ + TQString preferences = TQString("[X-DCOP-ServiceName] = '%1'").arg( preferredApp() ); + // start/find an instance of DCOP/InstantMessenger + TQString error; + TQCString dcopService; + // Get a preferred IM client. + // The app will notify itself to us using registeredToDCOP, so we don't need to record a stub for it here + // FIXME: error in preferences, see debug output + preferences = TQString::null; + int result = KDCOPServiceStarter::self()->findServiceFor( IM_SERVICE_TYPE, TQString::null, preferences, &error, &dcopService ); + + kdDebug( 790 ) << k_funcinfo << "error was: " << error << ", dcopService: " << dcopService << endl; + + return ( result == 0 ); +} + + +void KIMProxy::pollAll( const TQString &uid ) +{ +/* // We only need to call this function if we don't have any data at all + // otherwise, the data will be kept fresh by received presence change + // DCOP signals + if ( !d->presence_map.contains( uid ) ) + { + AppPresence *presence = new AppPresence(); + // record current presence from known clients + TQDictIterator it( m_im_client_stubs ); + for ( ; it.current(); ++it ) + { + presence->insert( it.currentKey().ascii(), it.current()->presenceStatus( uid ) ); // m_im_client_stubs has qstring keys... + } + d->presence_map.insert( uid, presence ); + }*/ +} + +void KIMProxy::pollApp( const TQCString & appId ) +{ + //kdDebug( 790 ) << k_funcinfo << endl; + KIMIface_stub * appStub = m_im_client_stubs[ appId ]; + TQStringList contacts = m_im_client_stubs[ appId ]->allContacts(); + TQStringList::iterator it = contacts.begin(); + TQStringList::iterator end = contacts.end(); + for ( ; it != end; ++it ) + { + ContactPresenceListCurrent current = d->presence_map[ *it ]; + AppPresenceCurrent ap; + ap.appId = appId; + ap.presence = appStub->presenceStatus( *it ); + current.append( ap ); + + d->presence_map.insert( *it, current ); + if ( current.update( ap ) ) + emit sigContactPresenceChanged( *it ); + //kdDebug( 790 ) << " uid: " << *it << " presence: " << ap.presence << endl; + } +} + +KIMIface_stub * KIMProxy::stubForUid( const TQString &uid ) +{ + // get best appPresence + AppPresenceCurrent ap = d->presence_map[ uid ].best(); + // look up the presence string from that app + return m_im_client_stubs.find( ap.appId ); +} + +KIMIface_stub * KIMProxy::stubForProtocol( const TQString &protocol) +{ + KIMIface_stub * app; + // see if the preferred client supports this protocol + TQString preferred = preferredApp(); + if ( ( app = m_im_client_stubs.find( preferred ) ) ) + { + if ( app->protocols().grep( protocol ).count() > 0 ) + return app; + } + // preferred doesn't do this protocol, try the first of the others that says it does + TQDictIterator it( m_im_client_stubs ); + for ( ; it.current(); ++it ) + { + if ( it.current()->protocols().grep( protocol ).count() > 0 ) + return it.current(); + } + return 0L; +} + +TQString KIMProxy::preferredApp() +{ + TDEConfig *store = new KSimpleConfig( IM_CLIENT_PREFERENCES_FILE ); + store->setGroup( IM_CLIENT_PREFERENCES_SECTION ); + TQString preferredApp = store->readEntry( IM_CLIENT_PREFERENCES_ENTRY ); + //kdDebug( 790 ) << k_funcinfo << "found preferred app: " << preferredApp << endl; + return preferredApp; +} + +#include "tdeimproxy.moc" diff --git a/interfaces/tdeimproxy/library/tdeimproxy.h b/interfaces/tdeimproxy/library/tdeimproxy.h new file mode 100644 index 000000000..1a20c4b22 --- /dev/null +++ b/interfaces/tdeimproxy/library/tdeimproxy.h @@ -0,0 +1,654 @@ +/* + tdeimproxy.h + + IM service library for KDE + + Copyright (c) 2004 Will Stephenson + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef KIMPROXY_H +#define KIMPROXY_H + +#include +#include +#include +#include + + +#define IM_SERVICE_TYPE "DCOP/InstantMessenger" +#define IM_CLIENT_PREFERENCES_FILE "default_components" +#define IM_CLIENT_PREFERENCES_SECTION "InstantMessenger" +#define IM_CLIENT_PREFERENCES_ENTRY "imClient" + +#include "tdeimproxyiface.h" + +class DCOPClient; +class KIMIface_stub; +class KURL; +class ContactPresenceListCurrent; + +/** FIXME: remove for KDE4, binary compability again. */ +typedef TQMap AppPresence; // appId->presence; contains all applications' ideas of a user's presence +typedef TQDict PresenceMap; // uid->AppPresence; contains a AppPresences for all users +/** FIXME: remove presenceMap and call this presenceMap in KDE4. This hack is for binary compatibility */ +typedef TQMap PresenceStringMap; + +/** + * @brief Provides access to instant messenger programs which implement KDE's + * instant messanger interface KIMIface + * + * This class provides an easy-to-use interface to all running instant + * messengers or chat programs that implement KIMIface. + * + * It works simultaneously with any running programs that implement the + * ServiceType @c DCOP/InstantMessenger. + * + * IM-contacts are identified using unique identifier strings (UID) used by + * KDE's address book framework KABC. + * However the use of the address book API is optional, KIMProxy provides + * methods to fetch lists of available contact UIDs from the applications. + * If a UID is reachable with more than one program, KIMProxy aggregates the + * available information and presents the 'best' presence. For example, for a + * contact who can be seen to be @c Away in @c IRC on program A but @c Online + * using @c ICQ on program B, the information from program B will be used. + * + * KIMProxy is designed for simple information in a wide number of cases, not + * for detailed messaging. + * + * The class is implemented as a singleton, so whenever you need access to + * one of its methods, just retrieve the single instance using instance(). + * The following code snippet demonstrated how to send a message to all + * reachable IM-contacts: + * @code + * // get proxy instance + * KIMProxy* proxy = KIMProxy::instance(); + * + * // check if there are suitable applications reachable + * if (!proxy->initialize()) return; + * + * TQString message = "Hi!\nHow are you on this wonderful day?"; + * + * // iterate over the list of reachable contacts + * TQStringList reachableContacts = proxy->reachableContacts(); + * for (TQStringList::const_iterator it = reachableContacts.begin(); + * it != reachableContacts.end(); ++it) + * { + proxy->messageContact(*it, message); + * } + * @endcode + * + * @note While it is possible to communicate with each of those application's + * by DCOP using KIMProxy has the advantage of communicating with all + * applications simultaneously and thus getting an augmented view of + * availability, capability and presence (online status) of IM-contacts. + * + * @see KIMIface + * @see KABC::AddressBook + * @see KABC::Addressee + * + * @since 3.3 + * @author Will Stephenson + */ +class KIMPROXY_EXPORT KIMProxy : public TQObject, virtual public KIMProxyIface +{ + Q_OBJECT + struct Private; + + template friend class KStaticDeleter; + ~KIMProxy(); + + public: + /** + * @brief Obtain an instance of KIMProxy + * + * Creates a new instance if it is called for the first time. + * Call initialize() to check if there are applications available for + * communication. + * + * @note KIMProxy uses DCOPClient::setNotifications() to make sure + * it updates its information about IM applications it interacts with, + * e.g. that it gets notified about newly available applications or + * about applications exiting + * + * @param client your application's DCOP client + * @return the singleton instance of this class + */ + static KIMProxy * instance( DCOPClient * client ); + + /** + * @brief Get the proxy ready to connect + * + * Discover any running IM clients and setup communication handlers for + * them. The list of available clients is updated automatically + * through notification about added or removed DCOP applications as + * provided by DCOPClient. + * + * It is safe to call this method more than once, initialization only + * occurs at the first time. + * + * @return whether the proxy is ready to use. + * @c false if there are no suitable apps running + */ + bool initialize(); + + /** + * @brief Obtain a list of IM-contacts known to IM-applications + * + * Returns a list of KABC UIDs gathered by merging the lists of + * each application the proxy can communicate with. + * The method uses cached information to make it fast and not + * require actually communicating with the applications every time + * it is called. + * + * @return a list of KABC UIDs known to any IM-application + * + * @see reachableContacts() + * @see onlineContacts() + * @see fileTransferContacts() + * @see isPresent() + * @see KABC::Addressee::uid() + */ + TQStringList allContacts(); + + /** + * @brief Obtain a list of IM-contacts that are currently reachable + * + * Returns a list of KABC UIDs gathered by merging the lists of + * each application the proxy can communicate with. + * + * @return a list of KABC UIDs who can receive a message, even if offline + * + * @see allContacts() + * @see onlineContacts() + * @see fileTransferContacts() + * @see messageContact() + * @see KABC::Addressee::uid() + */ + TQStringList reachableContacts(); + + /** + * @brief Obtain a list of IM-contacts that are currently online + * + * Returns a list of KABC UIDs gathered by merging the lists of + * each application the proxy can communicate with. + * The method uses cached information to make it fast and not + * require actually communicating with the applications every time + * it is called. + * + * @return a list of KABC UIDs who are online with unspecified presence + * + * @see allContacts() + * @see reachableContacts() + * @see fileTransferContacts() + * @see messageContact() + * @see chatWithContact() + * @see KABC::Addressee::uid() + */ + TQStringList onlineContacts(); + + /** + * @brief Obtain a list of IM-contacts who may receive file transfers + * + * Returned IM-contacts might not be capable of receiving file + * tranfers due to limitations of their clients or because they are + * behind a firewall. + * KIMProxy doesn't have the possibilities to discover this and will + * list them as well. + * + * Returns a list of KABC UIDs gathered by merging the lists of + * each application the proxy can communicate with. + * + * @return a list of KABC UIDs capable of file transfer + * + * @see allContacts() + * @see reachableContacts() + * @see onlineContacts() + * @see canReceiveFiles() + * @see KABC::Addressee::uid() + */ + TQStringList fileTransferContacts(); + + /** + * @brief Confirm if a given contact is known to the proxy + * + * A contact is known to the proxy if it is know to at least one + * IM-application the proxy is communicating with. + * + * The method uses cached information to make it fast and not + * require actually communicating with the applications every time + * it is called. + * + * @param uid the KABC UID you are interested in + * @return whether any IM-program knows of this KABC UID + * + * @see allContacts() + * @see presenceString() + * @see presenceNumeric() + * @see KABC::Addressee::uid() + */ + bool isPresent( const TQString& uid ); + + /** + * @brief Obtain the proxy's idea of the contact's display name + * + * If the given KABC UID is known to more than one IM-application + * the result of the application which has the best presence for the + * contact is taken. + * For example if a contact is @c Online on ICQ and @c Away on AIM, the + * value returned by the application providing ICQ is taken. + * + * Useful if KABC lookups may be too slow. + * + * @param uid the KABC UID you are interested in + * @return the corresponding display name or TQString:null if the + * UID is unknown + * + * @see isPresent() + * @see presenceString() + * @see presenceNumeric() + * @see KABC::Addressee::uid() + */ + TQString displayName( const TQString& uid ); + + /** + * @brief Obtain the IM presence as a number for the specified contact + * + * Returns one of the following values depending on the given contact's + * presence: + * - 0 - @c Unknown: for contacts where you can not use any of the + * other values + * + * - 1 - @c Offline: for contacts that are offline, i.e. not connected + * to their IM-service. + * + * - 2 - @c Connecting + * + * - 3 - @c Away: for contacts that are connected to their IM-service + * but not @c Online + * + * - 4 - @c Online + * + * If the given KABC UID is known to more than one IM-application + * the result of the application which has the best presence for the + * contact is taken. + * For example if a contact is @c Online on ICQ and Away on AIM, the + * value returned by the application providing ICQ is taken. + * + * The method uses cached information to make it fast and not + * require actually communicating with the applications every time + * it is called. + * + * @param uid the KABC UID you want the presence for + * @return a numeric representation of presence - currently one of + * 0 (Unknown), 1 (Offline), 2 (Connecting), 3 (Away), + * 4 (Online). Returns 0 if the given UID is unknown + * + * @see isPresent() + * @see presenceString() + * @see presenceIcon() + * @see KIMIface::presenceStatus() + * @see KABC::Addressee::uid() + */ + int presenceNumeric( const TQString& uid ); + + /** + * @brief Obtain the IM presence as a i18ned string for the specified + * contact + * + * The presence string is one of the following: + * - i18n("Unknown") + * - i18n("Offline") + * - i18n("Connecting") + * - i18n("Away") + * - i18n("Online") + * + * If the given KABC UID is known to more than one IM-application + * the result of the application which has the best presence for the + * contact is taken. + * For example if a contact is @c Online on ICQ and Away on AIM, the + * value returned by the application providing ICQ is taken. + * + * @note The presence string is created based on the numerical + * presence value returned by the applications. It currently + * does not return the presence strings used by the applications. + * + * The method uses cached information to make it fast and not + * require actually communicating with the applications every time + * it is called. + * + * @param uid the KABC UID you want the presence for + * @return the i18ned string describing the contact's presence or + * TQString::null if the UID is unknown + * + * @see isPresent() + * @see presenceNumeric() + * @see presenceIcon() + * @see KABC::Addressee::uid() + */ + TQString presenceString( const TQString& uid ); + + /** + * @brief Obtain the icon representing the IM presence for the + * specified contact + * + * If the given KABC UID is known to more than one IM-application + * the result of the application which has the best presence for the + * contact is taken. + * For example if a contact is @c Online on ICQ and Away on AIM, the + * value returned by the application providing ICQ is taken. + * + * @note The presence icon is chosen based on the numerical + * presence value returned by the applications. It currently + * does not return the presence icon used by the applications. + * + * The method uses cached information to make it fast and not + * require actually communicating with the applications every time + * it is called. + * + * @param uid the KABC UID you want the presence icon for + * @return a pixmap representing the contact's presence or a null + * pixmap if the contact is unknown. See TQPixmap::isNull() + * + * @see isPresent() + * @see presenceString() + * @see presenceNumeric() + * @see KABC::Addressee::uid() + */ + TQPixmap presenceIcon( const TQString& uid ); + + /** + * @brief Indicate if a given contact can receive files + * + * If the given KABC UID is known to more than one IM-application + * the result of the application which has the best presence for the + * contact is taken. + * For example if a contact is @c Online on ICQ and Away on AIM, the + * value returned by the application providing ICQ is taken. + * + * @param uid the KABC UID you want to the file transfer capability for + * @return whether the specified contact can receive files + * + * @see fileTransferContacts() + * @see KABC::Addressee::uid() + */ + bool canReceiveFiles( const TQString & uid ); + + /** + * @brief Indicate if a given contact will be able to respond + * + * Some media are unidirectional (e.g., sending SMS via a web + * interface). + * This refers to the contact's ability to respond as defined by the + * medium, not by their presence. + * + * Someone may appear offline (SMS has no presence) to you but in fact + * be able to respond. + * + * If the given KABC UID is known to more than one IM-application + * the result of the application which has the best presence for the + * contact is taken. + * For example if a contact is @c Online on ICQ and Away on AIM, the + * value returned by the application providing ICQ is taken. + * + * @param uid the KABC UID you are interested in + * @return whether the specified contact can respond + * + * @see isPresent() + * @see KABC::Addressee::uid() + */ + bool canRespond( const TQString & uid ); + + /** + * @brief Obtain the KABC UID corresponding to the given IM address + * + * @param contactId the protocol specific identifier for the contact, + * e.g. UIN for ICQ, screenname for AIM, nick for IRC + * @param protocol the IM protocol/service to check. + * See KIMIface::protocols() + * @return the KABC UID for the given contact or @c TQString::null if + * not found or either input stream was empty or the protocol + * is not supported + * + * @see KIMIface::protocols() + * @see addContact() + * @see isPresent() + * @see KABC::Addressee::uid() + */ + TQString locate( const TQString & contactId, const TQString & protocol ); + + /** + * @brief Obtain the given contact's current context (home, work, or + * any) + * + * Not all IM services/protocols support the concept of contexts. If the + * given UID maps to such a service, @c TQString::null will be returned + * + * If the given KABC UID is known to more than one IM-application + * the result of the application which has the best presence for the + * contact is taken. + * For example if a contact is @c Online on ICQ and Away on AIM, the + * value returned by the application providing ICQ is taken. + * + * @param uid the KABC UID you want the context for + * @return a string describing the context, or @c TQString::null if not + * supported or if the contact is unknown + * + * @see isPresent() + * @see KABC::Addressee::uid() + */ + TQString context( const TQString & uid ); + + /** + * @brief Start a chat session with the specified contact + * + * @param uid the KABC UID you want to chat with + * + * @see messageContact() + * @see sendFile() + * @see isPresent() + * @see reachableContacts() + * @see KABC::Addressee::uid() + */ + void chatWithContact( const TQString& uid ); + + /** + * @brief Send a single message to the specified contact + * + * Any response will be handled by the IM client as a normal + * conversation. + * + * @param uid the KABC UID you want to send the message to + * @param message the message text to send to the contact + * + * @see chatWithContact() + * @see sendFile() + * @see isPresent() + * @see reachableContacts() + * @see KABC::Addressee::uid() + */ + void messageContact( const TQString& uid, const TQString& message ); + + /** + * @brief Send a file to the contact + * + * Initiates a file transfer with the given contact if possible. + * + * @param uid the KABC UID you want to send to + * @param sourceURL a KURL pointing to the file to send + * @param altFileName an alternate filename describing the file or a + * description or title + * @param fileSize file size in bytes + * + * @see messageContact() + * @see chatWithContact() + * @see isPresent() + * @see fileTransferContacts() + * @see KABC::Addressee::uid() + */ + void sendFile(const TQString &uid, const KURL &sourceURL, + const TQString &altFileName = TQString::null, uint fileSize = 0); + + /** + * @brief Add a new contact given its protocol specific identifier + * + * @param contactId the protocol specific identifier for the contact + * e.g. UIN for ICQ, screenname for AIM, nick for IRC + * @param protocol the IM protocol/service to use. + * See KIMIface:::protocols() + * @return whether the add succeeded. @c false may signal already present, + * protocol not supported, or add operation not supported. + * + * @see locate() + * @see KIMIface::protocols() + */ + bool addContact( const TQString &contactId, const TQString &protocol ); + + /** + * @brief Checks if there are any compatible instant messaging + * applications available + * + * Available means that they are started and registered with DCOP + * and implementing the correct DCOP service. + * This information will be updated on the first call to initialize() + * and whenever an application registers or unregisters with DCOP, + * i.e. the information will be kept up to date. + * + * @return @c true if there are any apps available + */ + bool imAppsAvailable(); + + /** + * @brief Start the user's preferred IM application + * @return whether a preferred app was found. No guarantee that it + * started correctly + */ + bool startPreferredApp(); + + /** + * Just exists to let the IDL compiler make the DCOP signal for this + */ + void contactPresenceChanged( TQString uid, TQCString appId, int presence ); + + public slots: + /** + * @brief Updates the proxy's data after a new application registered + * with DCOP + * + * Checks if the application specified by the given DCOP application + * identifier implements the instant messenger service. + * + * @param appId the DCOP application ID of the newly registered + * application + * + * @see DCOPClient::applicationRegistered() + */ + void registeredToDCOP( const TQCString& appId ); + + /** + * @brief Updates the proxy's data after an application unregistered + * with DCOP + * + * If the application specified by the given DCOP application + * identifier is one of the instant messenger applications of the + * proxy, it will remove the presence information it gathered from it + * earlier on. + * + * Emits sigPresenceInfoExpired() to let the using applcation know + * its presence related information might need updating. + * + * @param appId the DCOP application ID of the now unregistered + * application + * + * @see DCOPClient::applicationRemoved() + */ + void unregisteredFromDCOP( const TQCString& appId ); + signals: + /** + * @brief Indicates that the specified IM-contact's presence changed + * + * @param uid the KABC UID whose presence changed + * + * @see isPresent() + * @see presenceNumeric() + * @see presenceIcon() + * @see KABC::Addressee::uid() + */ + void sigContactPresenceChanged( const TQString &uid ); + + /** + * @brief Indicates that presence information obtained earlier on might + * not be valid any longer + * + * After the sources of presence information have changed so any + * previously supplied presence info is invalid. + */ + void sigPresenceInfoExpired(); + protected: + /** + * Bootstrap our presence data for a newly registered app + */ + void pollApp( const TQCString & appId ); + /** + * Bootstrap our presence data by polling all known apps + */ + void pollAll( const TQString &uid ); + + /** + * Update our records with the given data + */ + bool updatePresence( const TQString &uid, const TQCString &appId, int presence ); + + /** + * Get the name of the user's IM application of choice + */ + TQString preferredApp(); + + /** + * Get the app stub best able to reach this uid + */ + KIMIface_stub * stubForUid( const TQString &uid ); + + /** + * Get the app stub for this protocol. + * Take the preferred app first, then any other. + */ + KIMIface_stub * stubForProtocol( const TQString &protocol ); + + private: + // client stubs used to get presence + // appId (from DCOP) -> KIMIface_stub + TQDict m_im_client_stubs; + // map containing numeric presence and the originating application ID for each KABC uid we know of + // KABC Uid -> (appId, numeric presence )(AppPresence) + PresenceMap m_presence_map; + // cache of the client strings in use by each application + // dictionary of KIMIface_stub -> map of numeric presence -> string presence + // FIXME: remove for KDE4 - UNUSED but maintained for binary compatibility in KDE 3.4 + TQPtrDict m_client_presence_strings; + Private * d; + bool m_apps_available; + bool m_initialized; + /** + * Construct an instance of the proxy library. + */ + KIMProxy( DCOPClient * client); + static KIMProxy * s_instance; +}; + +#endif + diff --git a/interfaces/tdeimproxy/library/tdeimproxyiface.h b/interfaces/tdeimproxy/library/tdeimproxyiface.h new file mode 100644 index 000000000..a7d416371 --- /dev/null +++ b/interfaces/tdeimproxy/library/tdeimproxyiface.h @@ -0,0 +1,38 @@ +/* + tdeimproxyiface.cpp + + IM service library for KDE + + DCOP interface to allow us to receive DCOP signals + + Copyright (c) 2004 Will Stephenson + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef KIMPROXYIFACE_H +#define KIMPROXYIFACE_H + +#include + +class KIMProxyIface : virtual public DCOPObject +{ + K_DCOP + k_dcop: + virtual void contactPresenceChanged( TQString uid, TQCString appId, int presence ) = 0; +}; + +#endif -- cgit v1.2.1