better commit that...

4 files changed, 34 insertions, 27 deletions

diff --git a/x11/ipc/client/ocopclient.cpp b/x11/ipc/client/ocopclient.cpp
index 91827e7..f59fa41 100644
--- a/x11/ipc/client/ocopclient.cpp
+++ b/x11/ipc/client/ocopclient.cpp
@@ -1,167 +1,167 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/un.h>
 
 
 #include <qfile.h>
 #include <qtimer.h>
 
 #include "../common/ocoppacket.h"
 
 #include "ocopclient.h"
 
 OCOPClient* OCOPClient::m_self = 0;
 
 OCOPClient*  OCOPClient::self() {
     if (!m_self ) {
         m_self = new OCOPClient();
     }
     return m_self;
 }
 
 OCOPClient::OCOPClient( const QString& path, QObject* obj )
     : QObject( obj )
 {
     m_tries = 0;
     init(QFile::encodeName(path) );
 }
 OCOPClient::~OCOPClient() {
     delete m_notify;
     close( m_socket );
 }
 void OCOPClient::init() {
     // failed start ther server NOW!!!
     startUP();
     QCString str;
     init(str );
 }
 void OCOPClient::init( const QCString&  ) {
     m_tries++;
     struct sockaddr_un unix_adr;
     if ( (m_socket = socket(PF_UNIX, SOCK_STREAM, 0) ) < 0 ) {
         qWarning("could not socket");
         if ( m_tries < 8 )
             QTimer::singleShot(400, this,SLOT(init() ) );
         return;
     }
     memset(&unix_adr, 0, sizeof(unix_adr ) );
     unix_adr.sun_family = AF_UNIX;
     sprintf(unix_adr.sun_path,"%s/.opie.cop",  getenv("HOME") );
     int length = sizeof(unix_adr.sun_family) + strlen(unix_adr.sun_path);
 
     if ( ::connect(m_socket,  (struct sockaddr*)&unix_adr, length ) < 0 ) {
         qWarning("could not connect %d", errno );
         close( m_socket );
         if ( m_tries < 8 )
             QTimer::singleShot(400, this, SLOT(init() ) );
         return;
     }
     m_notify = new QSocketNotifier(m_socket, QSocketNotifier::Read, this );
     connect( m_notify, SIGNAL(activated(int) ),
              this, SLOT(newData() ) );
 }
 /**
  * new data
  * read the header check magic number
  * and maybe read body
  */
 void OCOPClient::newData() {
     OCOPPacket pack = packet();
     if ( pack.channel().isEmpty() )
         return;
 
     switch( pack.type() ) {
     case OCOPPacket::Register:
     case OCOPPacket::Unregister:
     case OCOPPacket::Method:
     case OCOPPacket::RegisterChannel:
     case OCOPPacket::UnregisterChannel:
     case OCOPPacket::Return:
     case OCOPPacket::Signal:
         /* is Registered should be handled sync */
     case OCOPPacket::IsRegistered:
         break;
         /* emit the signal */
     case OCOPPacket::Call:
         emit called( pack.channel(), pack.header(), pack.content() );
         break;
     }
 }
 OCOPPacket OCOPClient::packet() const{
     QCString chan;
     QCString func;
     QByteArray ar;
     OCOPHead head;
     memset(&head, 0, sizeof(head) );
     read(m_socket, &head, sizeof(head) );
     if ( head.magic == 47 ) {
-        qWarning("Client:Magic Match");
+//        qWarning("Client:Magic Match");
         chan = QCString( head.chlen+1);
         func = QCString( head.funclen+1 );
         ar = QByteArray( head.datalen);
         read(m_socket, chan.data(), head.chlen );
         read(m_socket, func.data(), head.funclen );
         read(m_socket, ar.data(), head.datalen );
-	qWarning("Client:%d %s",head.chlen,chan.data() );
+//	qWarning("Client:%d %s",head.chlen,chan.data() );
     }
     OCOPPacket pack(head.type, chan,  func, ar );
     return pack;
 }
 /*
  * we've blocking IO here on these sockets
  * so we send and go on read
  * this will be blocked
  */
 bool OCOPClient::isRegistered( const QCString& chan ) const{
-    qWarning("OCopClient::isRegistered %s", chan.data() );
+//    qWarning("OCopClient::isRegistered %s", chan.data() );
     /* should I disconnect the socket notfier? */
     OCOPPacket packe(OCOPPacket::IsRegistered, chan );
     OCOPHead head = packe.head();
     write(m_socket, &head, sizeof(head) );
     write(m_socket, chan.data(), chan.size() );
     /* block */
     OCOPPacket pack = packet();
     qWarning("unblock %s %s", pack.channel().data(), chan.data() );
 
     /* connect here again */
     if ( pack.channel() == chan ) {
         QCString func = pack.header();
         if (func[0] == 1 )
             return true;
     }
 
     return false;
 };
 void OCOPClient::send( const QCString& chan, const QCString& fu, const QByteArray& arr ) {
-    qWarning("ClientSending %s %s", chan.data(), fu.data() );
+//    qWarning("ClientSending %s %s", chan.data(), fu.data() );
     OCOPPacket pack(OCOPPacket::Call, chan, fu, arr );
     call( pack );
 }
 void OCOPClient::addChannel(const QCString& channel) {
     OCOPPacket pack(OCOPPacket::RegisterChannel, channel );
     call( pack );
 }
 void OCOPClient::delChannel(const QCString& chan ) {
     OCOPPacket pack(OCOPPacket::UnregisterChannel, chan );
     call( pack );
 }
 void OCOPClient::call( const OCOPPacket& pack ) {
     OCOPHead head = pack.head();
     write(m_socket, &head, sizeof(head) );
     write(m_socket, pack.channel().data(), pack.channel().size() );
     write(m_socket, pack.header().data(), pack.header().size() );
     write(m_socket, pack.content().data(), pack.content().size() );
 }
 void OCOPClient::startUP() {
     qWarning("Start me up");
     pid_t pi = fork();
     if ( pi == 0 ) {
         setsid();
         execlp("ocopserver", "ocopserver", NULL );
         _exit(1);
     }
 }
diff --git a/x11/ipc/server/ocopserver.cpp b/x11/ipc/server/ocopserver.cpp
index ee5ea18..992cb8c 100644
--- a/x11/ipc/server/ocopserver.cpp
+++ b/x11/ipc/server/ocopserver.cpp
@@ -1,413 +1,413 @@
 #include <errno.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 
 #include <qcstring.h>
 #include <qtimer.h>
 
 #include "ocopserver.h"
 
 OCopServer::OCopServer()
     : QObject()
 {
     setName( "ocopserver");
 
     /*
      * init the server
      */
     init();
     initSocket();
 }
 OCopServer::~OCopServer() {
 // socket notifiers should be deleted
     close(m_serverfd );
 }
 void OCopServer::init() {
     /*
      * we set SIGPIPE to SIG_IGN
      * to get EPIPE on reads ;)
      */
-    qWarning("SIGPIPE to be ignored");
+//    qWarning("SIGPIPE to be ignored");
     signal(SIGPIPE,  SIG_IGN );
 
     /*
      * initialize some variables
      */
     m_server = 0l;
     m_serverError = 0l;
 }
 
 /**
  * here we will init our server
  * socket and bind and do the listen
  */
 void OCopServer::initSocket() {
     /* get the home dir */
     QCString home( getenv("HOME") );
     QCString path( home + "/.opie.cop");
 
     if ( ( m_serverfd = socket( PF_UNIX, SOCK_STREAM, 0 ) ) == -1 ) {
         qWarning("failed to create server socket");
         /* try again later */
         QTimer::singleShot( 400, this, SLOT(initSocket() ) );
         return;
     }
     qWarning( "unlinking file %s", path.data() );
 
     /* unlink previous sockets */
     unlink( path.data() );
 
     struct sockaddr_un m_address;
     memset(&m_address, 0, sizeof(m_address ) );
     m_address.sun_family = AF_UNIX; /* unix domain socket */
     strcpy(m_address.sun_path, path.data() );
     m_adrlaenge = sizeof(m_address.sun_family) + strlen(m_address.sun_path );
 
     /* cast to make it a (sockadr*) */
     if (bind(m_serverfd,  (struct sockaddr*)&m_address, m_adrlaenge ) == -1 ) {
         qWarning("Server could not bind try again");
         close(m_serverfd);
         QTimer::singleShot(400, this, SLOT(initSocket() ) );
         return;
     }
 
     /* tell the kernel that we're listening and accepting
      * 5 pending connections */
     if (listen(m_serverfd, 5) == -1 ) {
         qWarning("could not listen");
         close(m_serverfd );
         QTimer::singleShot(400, this, SLOT(initSocket() ) );
         return;
     }
 
     /*
      * now we will create two QSocketNotifier
      * which will us notify on reads
      * and errors
      * we do this because they integrate
      * nicely into the QApplication eventloop
      */
     m_server = new QSocketNotifier(m_serverfd, QSocketNotifier::Read, this );
     connect( m_server, SIGNAL(activated(int) ),
              this, SLOT(newOnServer() ) );
 
     m_serverError = new QSocketNotifier( m_serverfd, QSocketNotifier::Exception, this);
     connect(m_serverError, SIGNAL(activated(int) ),
             this, SLOT(errorOnServer() ) );
 
     qWarning("done with registering");
 }
 /**
  * we got the possibility to read
  * on the server
  * this is mostly due a connect
  * on a client side
  * we will accept it
  * add it to our list
  */
 void OCopServer::newOnServer() {
     int fd = accept();
     if ( fd < 0 )
         return;
 
     /*
      * we got a successfull new connection
      * be happy
      * set SocketNotifier
      * connect it
      * and a OCOPClient
      */
-    qWarning("Heureka new connection %d", fd );
+//    qWarning("Heureka new connection %d", fd );
 
 
     registerClient( fd );
 }
 int OCopServer::accept() {
     /*
      * accept it
      * the socket is currently blocking IIRC
      */
     return ::accept( m_serverfd,  (struct sockaddr*)&m_address, &m_adrlaenge );
 }
 void OCopServer::newOnClient( int fd ) {
     errno = 0;
     OCOPHead head;
     memset(&head, 0, sizeof(head) );
     int rea = ::read(fd, &head, sizeof(head) );
     //qWarning("read %d %d", rea,  errno);
     /*
      * I should get EPIPE but nothing like this happens
      * so if rea == 0 and we were signaled by the notifier
      * we close it and drop the clients...
      */
     if ( rea <= 0 ) {
         deregisterClient( fd );
         return;
     }
     /*
      * OCOPHead
      */
     //qWarning("data %s %d", &bug, rea );
 
     /*
      * Check the magic
      * if chcked read till EOF if magic does not match
      * otherwise do read
      *  channel
      * func
      * data into mem
      * and then send the OCOPPacket
      *
      */
     if (head.magic == 47 ) {
 //        qWarning("magic match");
         QCString channel( head.chlen+1 );
         QCString func( head.funclen+1 );
         QByteArray data ( head.datalen+1 );
 
         /*
          * we do not check for errors
          */
 //        qWarning("read ");
         int s = read(fd, channel.data(), head.chlen );
         s = read(fd, func.data(), head.funclen );
         s = read(fd, data.data(), head.datalen );
 //        qWarning("read");
 
         /* debug output */
 //        qWarning("channel %s %d", channel.data(), head.chlen );
 //        qWarning("func %s %d", func.data(), head.funclen );
         /* debug end */
 
         /*
          * now that we got the complete body
          * we need to make a package
          * and then we need to send it to clients
          * making a package is done here
          * dispatching it not
          */
         OCOPPacket packet( head.type, channel, func, data );
         dispatch( packet, fd );
 
     }else{
-        qWarning("magic does not match");
-        qWarning("magic %d", head.magic );
+//        qWarning("magic does not match");
+//        qWarning("magic %d", head.magic );
     }
 }
 void OCopServer::registerClient( int fd ) {
     if (m_clients.contains(fd) )
         return;
 
     QSocketNotifier* notify = new QSocketNotifier(fd, QSocketNotifier::Read, this );
     connect(notify, SIGNAL(activated(int) ),
             this, SLOT(newOnClient(int) ) );
     OCOPClient client;
     client.fd = fd;
     client.notify = notify;
     m_clients.insert( client.fd, client );
-    qWarning("clients are up to %d", m_clients.count() );
+//    qWarning("clients are up to %d", m_clients.count() );
 };
 void OCopServer::deregisterClient(int fd ) {
     QMap<int, OCOPClient>::Iterator it = m_clients.find( fd );
     if (it != m_clients.end() ) {
         /*
          * TIME_ME
          *
          * now delete from all channels
          * go through all channels
          * remove the fd from the list
          * if count becomes 0 remove the channel
          * otherwise replace QArray<int>
          */
         QMap<QCString, QValueList<int> >::Iterator it2;
     repeatIt:
         for ( it2 = m_channels.begin(); it2 != m_channels.end(); ++it2 ) {
             /*
              * The channel contains this fd
              */
-            qWarning("Channel %s %d", it2.key().data(), it2.data().count() );
+//            qWarning("Channel %s %d", it2.key().data(), it2.data().count() );
             if ( it2.data().contains( fd ) ) {
                 qWarning("contains");
                 QValueList<int> array = it2.data();
 
                 /*
                  * remove channel or just replace
                  */
                 if ( array.count() == 1 || array.count() == 0) {
-                    qWarning("Invalidate!");
+//                    qWarning("Invalidate!");
                     /* is the list now invalidatet? */
                     m_channels.remove( it2 );
                     /* That is the first go to of my life
                      * but Iterator remove( Iterator )
                      * does not exist
                      * it2 = --it2;
                      * does not work reliable too
                      * so the only way is to reiterate :(
                      */
                     goto repeatIt;
                 }else{
-                    qWarning("removing count %d %d",fd, array.count() );
+//                    qWarning("removing count %d %d",fd, array.count() );
                     QValueList<int>::Iterator it3 = array.find( fd );
                     it3 = array.remove( it3 );
                     QCString key = it2.key().copy();
                     it2 = m_channels.replace( key, array );
                 }
             }
         } // off all channels
         OCOPClient client = it.data();
         delete client.notify;
         m_clients.remove(fd );
         close(fd );
     }
-    qWarning("clients are now at %d", m_clients.count() );
-};
+//    qWarning("clients are now at %d", m_clients.count() );
+}
 /**
  * this function will evaluate
  * the package and then do the appropriate thins
  */
 void OCopServer::dispatch( const OCOPPacket& packet, int sourceFD ) {
-    qWarning("packet.type() == %d", packet.type() );
+//    qWarning("packet.type() == %d", packet.type() );
     switch( packet.type() ) {
     case OCOPPacket::Register:
         registerClient(sourceFD );
         break;
     case OCOPPacket::Unregister:
         deregisterClient(sourceFD );
         break;
     case OCOPPacket::Call:
         call( packet, sourceFD );
         break;
         /* not implemented */
     case OCOPPacket::Method:
         break;
         /* nit implemented */
     case OCOPPacket::Reply:
         break;
     case OCOPPacket::RegisterChannel:
         addChannel( packet.channel() , sourceFD );
         break;
     case OCOPPacket::UnregisterChannel:
         delChannel( packet.channel(), sourceFD );
         break;
         /* not implemented */
     case OCOPPacket::Return:
         break;
         /* not implemented :( */
     case OCOPPacket::Signal:
         break;
     case OCOPPacket::IsRegistered:
-        qWarning("Server:IsRegistered %s", packet.channel().data() );
+//        qWarning("Server:IsRegistered %s", packet.channel().data() );
         isRegistered( packet.channel(), sourceFD );
         break;
     };
 }
 void OCopServer::errorOnServer() {
     /*
      * something is wrong on the server socket?
      * what should we do?
      * FIXME
      */
 }
 QStringList OCopServer::channels() {
     QStringList list;
     {
         QMap<QCString, QValueList<int> >::Iterator it;
         for (it = m_channels.begin(); it != m_channels.end(); ++it ) {
             list << it.key();
         };
     }
     return list;
 }
 bool OCopServer::isChannelRegistered( const QCString& chan ) const{
     return m_channels.contains( chan );
 }
 void OCopServer::addChannel( const QCString& channel,
                              int fd ) {
     QMap<QCString, QValueList<int> >::Iterator it;
     it = m_channels.find( channel );
     if ( it != m_channels.end() ) {
         /* could be empty */
         QValueList<int> list = it.data();
         list.append( fd );
-        qWarning("count is now in addChannel %d %s", list.count(), channel.data() );
+        qWarning("Server:count is now in addChannel %d %s", list.count(), channel.data() );
         it = m_channels.replace( channel, list );
     }else {
         QValueList<int> ints;
         ints.append( fd );
         m_channels.insert( channel, ints );
     }
 };
 void OCopServer::delChannel( const QCString& channel,
                              int fd ) {
-    qWarning("remove %s, %d", channel.data(), fd );
+//    qWarning("remove %s, %d", channel.data(), fd );
     if (!m_channels.contains( channel ) )
         return;
 
     QMap<QCString, QValueList<int> >::Iterator it;
     it = m_channels.find( channel );
 
     if ( it.data().contains(fd) ) {
         QValueList<int> ints = it.data();
         if ( ints.count() == 1  )
             m_channels.remove( channel );
         else{
             QValueList<int> ints = it.data();
             QValueList<int>::Iterator rem = ints.find( fd );
             rem = ints.remove( rem );
             QCString str = it.key().copy();
             m_channels.replace( str, ints );
         }
-        qWarning(" channel count is now %d", ints.count() );
+//        qWarning(" channel count is now %d", ints.count() );
     }
 }
 void OCopServer::isRegistered( const QCString& channel, int fd) {
-    qWarning("Server:isRegistered %s", channel.data() );
+//    qWarning("Server:isRegistered %s", channel.data() );
     OCOPHead head;
     QCString func(2);
 
     memset(&head, 0, sizeof(head ) );
     head.magic = 47;
     head.type = OCOPPacket::IsRegistered;
     head.chlen = channel.size();
     head.funclen = func.size();
     head.datalen = 0;
 
     if ( isChannelRegistered( channel ) ) {
         //is registered
         func[0] = 1;
-	qWarning("Server:Channel is Registered %d", head.chlen);
+//	qWarning("Server:Channel is Registered %d", head.chlen);
     }else{
         func[0] = 0;
-	qWarning("Server:Channel is NotRegistered");
+//	qWarning("Server:Channel is NotRegistered");
     }
 
     /**
      * write the head
      * and then channel
      * success/failure inside func
      */
     write(fd, &head, sizeof(head) );
     write(fd, channel.data(), channel.size() );
     write(fd, func.data(), func.size() );
 }
 QValueList<int> OCopServer::clients( const QCString& channel ) {
     return m_channels[channel];
 }
 void OCopServer::call( const OCOPPacket& p, int ) {
     QValueList<int> cli = clients( p.channel() );
     QValueList<int>::Iterator it;
 
     OCOPHead head = p.head();
     for (it = cli.begin(); it != cli.end(); ++it ) {
-        qWarning("Server:calling %d %s %s", (*it), p.channel().data(), p.header().data() );
+//        qWarning("Server:calling %d %s %s", (*it), p.channel().data(), p.header().data() );
         write( (*it), &head, sizeof(head ) );
         /* expl. shared! */
         write( (*it), p.channel().data(), p.channel().size() );
         write( (*it), p.header().data(), p.header().size() );
         write( (*it), p.content().data(), p.content().size() );
     };
 }
diff --git a/x11/libqpe-x11/qpe/qpeapplication.cpp b/x11/libqpe-x11/qpe/qpeapplication.cpp
index 49115d8..c4f8f38 100644
--- a/x11/libqpe-x11/qpe/qpeapplication.cpp
+++ b/x11/libqpe-x11/qpe/qpeapplication.cpp
@@ -1,788 +1,788 @@
 #define QTOPIA_INTERNAL_LANGLIST
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/file.h>
 
 
 #include <qdir.h>
 #include <qdialog.h>
 #include <qdragobject.h>
 #include <qevent.h>
 #include <qlabel.h>
 #include <qlist.h>
 #include <qtextstream.h>
 #include <qtextcodec.h>
 #include <qpalette.h>
 #include <qptrdict.h>
 #include <qregexp.h>
 #include <qtimer.h>
 
 #include <qpe/alarmserver.h>
 #include <qpe/applnk.h>
 #include <qpe/qpemenubar.h>
 #include <qpe/textcodecinterface.h>
 #include <qpe/imagecodecinterface.h>
 #include <qpe/qlibrary.h>
 #include <qpe/qpestyle.h>
 #include <qpe/styleinterface.h>
 #include <qpe/global.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 #include <qpe/network.h>
 
 #include <qpe/qpeapplication.h>
 #include <qpe/timestring.h>
 #include <qpe/qcopenvelope_qws.h>
 
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 const int XKeyPress = KeyPress;
 const int XKeyRelease = KeyRelease;
 #undef KeyPress
 #undef KeyRelease
 
 namespace {
     struct QCopRec{
         QCopRec( const QCString& ch, const QCString& msg, const QByteArray& ar )
             : channel(ch), message(msg), data(ar) {
 
         }
         QCString channel;
         QCString message;
         QByteArray data;
     };
 };
 
 
 class QPEApplication::Private {
 public:
     Private();
     ~Private();
     void enqueueQCop( const QCString& ch, const QCString& msg,
                       const QByteArray& );
     void sendQCopQ();
     static void show_mx(QWidget* mw, bool nomaximize );
     void show( QWidget* mw, bool nomax );
     void loadTextCodecs();
     void loadImageCodecs();
 
     int kbgrabber;
     int presstimer;
 
     bool rightpressed  : 1;
     bool kbregrab      : 1;
     bool notbusysent   : 1;
     bool preloaded     : 1;
     bool forceshow     : 1;
     bool nomaximize    : 1;
     bool keep_running  : 1;
 
     QWidget* presswidget;
     QPoint presspos;
     QWidget* qpe_main_widget;
     QString appName;
     QString styleName;
     QString decorationName;
     Atom wm_delete_window;
     Atom wm_take_focus;
     Atom wm_context_help;
     Atom wm_context_accept;
     Atom wm_protocols;
 
 private:
     QList<QCopRec> qcopq;
 };
 QPEApplication::Private::~Private() {
 }
 QPEApplication::Private::Private()
     : kbgrabber(0 ), presstimer(0 ), rightpressed( FALSE ), kbregrab( FALSE ), notbusysent( FALSE ),
       preloaded( FALSE ), forceshow( FALSE ), nomaximize( FALSE ), keep_running( TRUE ),
       presswidget( 0 ), qpe_main_widget(0 ) {
 
     qcopq.setAutoDelete( TRUE );
 }
 void QPEApplication::Private::enqueueQCop( const QCString& chan, const QCString& msg,
                                            const QByteArray& ar ) {
     qcopq.append( new QCopRec(chan, msg, ar ) );
 }
 void QPEApplication::Private::sendQCopQ() {
     QCopRec* r;
     for ( r = qcopq.first(); r; r = qcopq.next() ) {
         QCopChannel::sendLocally( r->channel, r->message, r->data );
     }
     qcopq.clear();
 }
 void QPEApplication::Private::show_mx(QWidget* mw, bool nomaximize ) {
     if (mw->layout() && mw->inherits("QDialog") ) {
         QPEApplication::showDialog( (QDialog*)mw, nomaximize );
     }else {
         if (!nomaximize )
             mw->showMaximized();
         else
             mw->show();
     }
 }
 void QPEApplication::Private::show( QWidget* mw, bool nomax ) {
     nomaximize = nomax;
     qpe_main_widget = mw;
 
     sendQCopQ();
 
     if ( preloaded ) {
         if (forceshow )
             show_mx(mw, nomax );
     }else if ( keep_running )
         show_mx( mw, nomax );
 }
 void QPEApplication::Private::loadTextCodecs() {
     QString path = QPEApplication::qpeDir() + "/plugins/textcodecs";
     QDir dir( path, "lib*.so" );
     QStringList list = dir.entryList();
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
         TextCodecInterface *iface = 0;
         QLibrary *lib = new QLibrary( path + "/" + *it );
         if ( lib->queryInterface( IID_QtopiaTextCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
             QValueList<int> mibs = iface->mibEnums();
             for (QValueList<int>::ConstIterator i = mibs.begin(); i != mibs.end(); ++i) {
                 (void)iface->createForMib(*i);
                 // ### it exists now; need to remember if we can delete it
             }
         }
         else {
             lib->unload();
             delete lib;
         }
     }
 }
 void QPEApplication::Private::loadImageCodecs() {
     QString path = QPEApplication::qpeDir() + "/plugins/imagecodecs";
     QDir dir( path, "lib*.so" );
     QStringList list = dir.entryList();
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
         ImageCodecInterface *iface = 0;
         QLibrary *lib = new QLibrary( path + "/" + *it );
         if ( lib->queryInterface( IID_QtopiaImageCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
             QStringList formats = iface->keys();
             for (QStringList::ConstIterator i = formats.begin(); i != formats.end(); ++i) {
                 (void)iface->installIOHandler(*i);
                 // ### it exists now; need to remember if we can delete it
             }
         }
         else {
             lib->unload();
             delete lib;
         }
     }
 }
 
 // The Help System hook
 namespace {
     class ResourceMimeFactory : public QMimeSourceFactory
     {
     public:
         ResourceMimeFactory();
         ~ResourceMimeFactory();
         const QMimeSource* data( const QString& abs_name )const;
     };
     ResourceMimeFactory::ResourceMimeFactory()
     {
         setFilePath( Global::helpPath() );
         setExtensionType( "html", "text/html;charset=UTF-8" );
     }
     ResourceMimeFactory::~ResourceMimeFactory() {
     }
 
     const QMimeSource* ResourceMimeFactory::data( const QString& abs_name ) const
     {
         const QMimeSource * r = QMimeSourceFactory::data( abs_name );
         if ( !r ) {
             int sl = abs_name.length();
             do {
                 sl = abs_name.findRev( '/', sl - 1 );
                 QString name = sl >= 0 ? abs_name.mid( sl + 1 ) : abs_name;
                 int dot = name.findRev( '.' );
                 if ( dot >= 0 )
                     name = name.left( dot );
                 QImage img = Resource::loadImage( name );
                 if ( !img.isNull() )
                     r = new QImageDrag( img );
             }
             while ( !r && sl > 0 );
         }
         return r;
     };
 };
 // QPEApplication
 QPEApplication::~QPEApplication() {
     qWarning("~QPEApplication");
     ungrabKeyboard();
     qWarning("UngrabKeyboard");
 
 //    delete m_sys;
 //    delete m_pid;
 
     delete d;
 }
 QPEApplication::QPEApplication(int &arg, char** argv, Type t)
     : QApplication( arg, argv, t ) {
     d = new Private;
     d->loadTextCodecs();
     d->loadImageCodecs();
 
     // Init X-Atom
     Atom *atoms[5];
     Atom atoms_re[5];
     char* names[5];
     int n = 0;
     atoms[n]   = &d->wm_delete_window;
     names[n++] = "WM_DELETE_WINDOW";
 
     atoms[n]   = &d->wm_take_focus;
     names[n++] = "WM_TAKE_FOCUS";
 
     atoms[n]   = &d->wm_context_help;
     names[n++] = "_NET_WM_CONTEXT_HELP";
 
     atoms[n]   = &d->wm_context_accept;
     names[n++] = "_NET_WM_CONTEXT_ACCEPT";
 
     atoms[n]   = &d->wm_protocols;
     names[n++] = "WM_PROTOCOLS";
 
     XInternAtoms( qt_xdisplay(), names, n, FALSE, atoms_re);
     // now copy the values over to the properties
     for (int i = 0; i < n; i++ )
         *atoms[i] = atoms_re[i];
     // done with X11 Stuff
 
     int dw = desktop()->width();
     if ( dw < 200 ) {
         setFont( QFont( "helvetica", 8 ) );
         AppLnk::setSmallIconSize( 10 );
         AppLnk::setBigIconSize( 28 );
     }else if ( dw > 600 ) {
         setFont( QFont( "helvetica", 12 ) );
         AppLnk::setSmallIconSize( 24 );
         AppLnk::setBigIconSize( 48 );
     }else if ( dw > 200 ) {
         setFont( QFont( "helvetica", 10 ) );
         AppLnk::setSmallIconSize( 16 );
         AppLnk::setBigIconSize( 32 );
     }
     QMimeSourceFactory::setDefaultFactory( new ResourceMimeFactory );
 
     connect( this, SIGNAL( lastWindowClosed() ), this, SLOT(hideOrQuit() ) );
 
     QString qcopfn( "/tmp/qcop-msg-" );
     qcopfn += QString( argv[0] ); // append command name to the QCOP name
     QFile file( qcopfn );
     if (file.open(IO_ReadOnly ) ) {
         flock( file.handle(), LOCK_EX );
     }
 
     /* Hmmm damn we need to make the parent 0l otherwise it get's deleted
      * past the QApplication
      */
     m_sys = new QCopChannel( "QPE/System", 0l);
     connect(m_sys, SIGNAL( received( const QCString&, const QByteArray& ) ),
             this, SLOT(systemMessage( const QCString&, const QByteArray& ) ) );
 
     // private channel QPE/Application/appname
     QCString channel = QCString( argv[0] );
     channel.replace( QRegExp( ".*/"), "" );
     d->appName = channel;
     channel = "QPE/Application/"+ channel;
     m_pid = new QCopChannel( channel, 0l );
     connect(m_pid, SIGNAL( received( const QCString&, const QByteArray& ) ),
             this, SLOT( pidMessage( const QCString&, const QByteArray& ) ) );
 
     // read the Pre QCOP Stuff  from the file
     if ( file.isOpen() ) {
         d->keep_running = FALSE;
         QDataStream ds( &file );
         QCString chanel, message;
         QByteArray data;
         while (!ds.atEnd() ) {
             ds >> chanel >> message >> data;
             d->enqueueQCop( chanel, message, data );
         }
         flock( file.handle(), LOCK_UN );
         file.close();
         file.remove();
     }
 
     // read in some stuff from the command line
     // we do not have setArgs so we need to take
     // care of that
     for ( int a = 0; a < arg; a++ ) {
         if ( qstrcmp( argv[a], "-preload" ) == 0 ) {
             d->preloaded = TRUE;
         }else if ( qstrcmp( argv[a ] ,  "-preload-show" ) == 0 ) {
             d->preloaded = TRUE;
             d->forceshow = TRUE;
         }
     }
     initTranslations();
     applyStyle();
 
     if ( type() == GuiServer )
         ;
 
     installEventFilter( this );
     QPEMenuToolFocusManager::initialize();
 }
 void QPEApplication::initTranslations() {
     // Translations add it
     QStringList langs = Global::languageList();
     for ( QStringList::ConstIterator it = langs.begin(); it != langs.end(); ++it ) {
         QString lang = *it;
 
         QTranslator * trans;
         QString tfn;
 
         trans = new QTranslator( this );
         tfn = qpeDir() + "/i18n/" + lang + "/libqpe.qm";
         if ( trans->load( tfn ) )
             installTranslator( trans );
         else
             delete trans;
 
         trans = new QTranslator( this );
         tfn = qpeDir() + "/i18n/" + lang + "/" + d->appName + ".qm";
         if ( trans->load( tfn ) )
             installTranslator( trans );
         else
             delete trans;
     }
 }
 QString QPEApplication::qpeDir() {
     const char * base = getenv( "OPIEDIR" );
     if ( base )
         return QString( base ) + "/";
 
     return QString( "../" );
 }
 QString QPEApplication::documentDir() {
     const char* base = getenv( "HOME");
     if ( base )
         return QString( base ) + "/Documents";
 
     return QString( "../Documents" );
 }
 void QPEApplication::applyStyle() {
     Config config( "qpe" );
 
     config.setGroup( "Appearance" );
 
     // Widget style
     QString style = config.readEntry( "Style", "Light" );
     internalSetStyle( style );
 
     // Colors
     QColor bgcolor( config.readEntry( "Background", "#E5E1D5" ) );
     QColor btncolor( config.readEntry( "Button", "#D6CDBB" ) );
     QPalette pal( btncolor, bgcolor );
     QString color = config.readEntry( "Highlight", "#800000" );
     pal.setColor( QColorGroup::Highlight, QColor( color ) );
     color = config.readEntry( "HighlightedText", "#FFFFFF" );
     pal.setColor( QColorGroup::HighlightedText, QColor( color ) );
     color = config.readEntry( "Text", "#000000" );
     pal.setColor( QColorGroup::Text, QColor( color ) );
     color = config.readEntry( "ButtonText", "#000000" );
     pal.setColor( QPalette::Active, QColorGroup::ButtonText, QColor( color ) );
     color = config.readEntry( "Base", "#FFFFFF" );
     pal.setColor( QColorGroup::Base, QColor( color ) );
 
     pal.setColor( QPalette::Disabled, QColorGroup::Text,
                   pal.color( QPalette::Active, QColorGroup::Background ).dark() );
 
     setPalette( pal, TRUE );
 
 
 
     // Font
     QString ff = config.readEntry( "FontFamily", font().family() );
     int fs = config.readNumEntry( "FontSize", font().pointSize() );
     setFont( QFont(ff, fs) );
 }
 int QPEApplication::defaultRotation() {
     return 0;
 }
 void QPEApplication::setDefaultRotation(int r ) {
 
 }
 void QPEApplication::grabKeyboard() {
     QPEApplication::Private * d = ( ( QPEApplication* ) qApp ) ->d;
     if ( qApp->type() == QApplication::GuiServer )
         d->kbgrabber = 0;
     else {
         QCopEnvelope e( "QPE/System", "grabKeyboard(QString)" );
         e << d->appName;
 
         d->kbgrabber = 2; // me
     }
 }
 void QPEApplication::ungrabKeyboard() {
     QPEApplication::Private * d = ( ( QPEApplication* ) qApp ) ->d;
     if ( d->kbgrabber == 2 ) {
         QCopEnvelope e( "QPE/System", "grabKeyboard(QString)" );
         e << QString::null;
 
         d->kbregrab = FALSE;
         d->kbgrabber = 0;
     }
 }
 void QPEApplication::showMainWidget( QWidget* wid, bool b) {
     d->show(wid, b );
 }
 void QPEApplication::showMainDocumentWidget( QWidget* mw, bool m) {
     if ( mw && argc() == 2 )
         Global::setDocument( mw, QString::fromUtf8(argv()[1] ) );
 
     d->show(mw, m );
 }
 void QPEApplication::showDialog( QDialog* d, bool nomax ) {
     QSize sh = d->sizeHint();
     int w = QMAX(sh.width(),d->width());
     int h = QMAX(sh.height(),d->height());
     if ( !nomax
          && ( w > qApp->desktop()->width()*3/4
               || h > qApp->desktop()->height()*3/4 ) )
     {
 	d->showMaximized();
     } else {
 	d->resize(w,h);
 	d->show();
     }
 }
 int QPEApplication::execDialog( QDialog* d, bool nomax) {
     showDialog(d,nomax);
     return d->exec();
 }
 void QPEApplication::setKeepRunning() {
     if ( qApp && qApp->inherits( "QPEApplication" ) ) {
         QPEApplication * qpeApp = ( QPEApplication* ) qApp;
         qpeApp->d->keep_running = TRUE;
     }
 }
 bool QPEApplication::keepRunning()const {
     return d->keep_running;
 }
 bool QPEApplication::keyboardGrabbed()const {
     return d->kbgrabber;
 }
 int QPEApplication::exec() {
     /* now send the QCOP stuff gotten from the file */
     d->sendQCopQ();
 
     if ( d->keep_running ) {
         qWarning("going to exec");
         int a = QApplication::exec();
         qWarning("left");
         return a;
     }
 
     {
         QCopEnvelope e( "QPE/System", "closing(QString)" );
         e << d->appName;
     }
     qWarning("processing events!");
     processEvents();
     return 0;
 }
 void QPEApplication::internalSetStyle( const QString& ) {
 
 }
-void QPEApplication::systemMessage( const QCString&, const QByteArray& ) {
-
+void QPEApplication::systemMessage( const QCString& chan, const QByteArray& ) {
+    qWarning("QPEApplication::systemMessage( %s )", chan.data() );
 }
 void QPEApplication::pidMessage( const QCString&, const QByteArray& ) {
 
 }
 void QPEApplication::timerEvent( QTimerEvent* e ) {
     if ( e->timerId() == d->presstimer && d->presswidget ) {
         // Right pressed
         postEvent( d->presswidget,
                    new QMouseEvent( QEvent::MouseButtonPress, d->presspos,
                                     RightButton, LeftButton ) );
         killTimer( d->presstimer );
         d->presstimer = 0;
     }
 }
 
 // InputMethods Hints
 namespace {
     static QPtrDict<void>* inputMethodDict = 0;
     static void createInputMethodDict(){
 	if ( !inputMethodDict )
             inputMethodDict = new QPtrDict<void>;
     }
 
     static QPtrDict<void>* stylusDict = 0;
     static void createDict() {
         if ( !stylusDict )
             stylusDict = new QPtrDict<void>;
     }
 };
 
 void QPEApplication::setInputMethodHint( QWidget* w, InputMethodHint mode ) {
     createInputMethodDict();
     if ( mode == Normal ) {
         inputMethodDict->remove
             ( w );
     }else {
         inputMethodDict->insert( w, ( void* ) mode );
     }
 }
 QPEApplication::InputMethodHint QPEApplication::inputMethodHint( QWidget* w) {
     if ( inputMethodDict && w )
         return ( InputMethodHint ) ( int ) inputMethodDict->find( w );
     return Normal;
 }
 
 
 void QPEApplication::removeSenderFromStylusDict() {
     stylusDict->remove( ( void* ) sender() );
     if ( d->presswidget == sender() )
         d->presswidget = 0;
 }
 void QPEApplication::setStylusOperation( QWidget* w, StylusMode mode) {
     createDict();
     if ( mode == LeftOnly ) {
         stylusDict->remove
             ( w );
         w->removeEventFilter( qApp );
     }else {
         stylusDict->insert( w, ( void* ) mode );
         connect( w, SIGNAL( destroyed() ), qApp, SLOT( removeSenderFromStylusDict() ) );
         w->installEventFilter( qApp );
     }
 }
 QPEApplication::StylusMode QPEApplication::stylusOperation( QWidget* w) {
     if ( stylusDict )
         return ( StylusMode ) ( int ) stylusDict->find( w );
     return LeftOnly;
 }
 
 // eventFilter......
 bool QPEApplication::eventFilter( QObject* o, QEvent* e ) {
     /*
      * We want our WM to show Ok and a X button
      * on dialogs
      * our part is to set the _NET_WM_CONTEXT_ACCEPT
      * propery
      * and then wait for a client message -zecke
      * on show we will add the prop
      */
     if (o->inherits("QDialog") && e->type() == QEvent::Show ) {
         QDialog* dialog = (QDialog*)o;
         Atom wm_prot[45];
         int n = 0;
         wm_prot[n++] = d->wm_delete_window;
         wm_prot[n++] = d->wm_take_focus;
         wm_prot[n++] = d->wm_context_accept;
         if ( dialog->testWFlags( WStyle_ContextHelp ) )
             wm_prot[n++] = d->wm_context_help;
         XSetWMProtocols( qt_xdisplay(), dialog->winId(), wm_prot, n );
         return TRUE; // should be save
     }
     if ( stylusDict && e->type() >= QEvent::MouseButtonPress && e->type() <= QEvent::MouseMove ) {
         QMouseEvent * me = ( QMouseEvent* ) e;
         StylusMode mode = (StylusMode)(int)stylusDict->find(o);
         switch (mode) {
         case RightOnHold:
             switch ( me->type() ) {
             case QEvent::MouseButtonPress:
                 if ( me->button() == LeftButton ) {
                     d->presstimer = startTimer(500); // #### pref.
                     d->presswidget = (QWidget*)o;
                     d->presspos = me->pos();
                     d->rightpressed = FALSE;
                 }
                 break;
             case QEvent::MouseMove:
                 if (d->presstimer && (me->pos() - d->presspos).manhattanLength() > 8) {
                     killTimer(d->presstimer);
                     d->presstimer = 0;
                 }
                 break;
             case QEvent::MouseButtonRelease:
                 if ( me->button() == LeftButton ) {
                     if ( d->presstimer ) {
                         killTimer(d->presstimer);
                         d->presstimer = 0;
                     }
                     if ( d->rightpressed && d->presswidget ) {
                         // Right released
                         postEvent( d->presswidget,
                                    new QMouseEvent( QEvent::MouseButtonRelease, me->pos(),
                                                     RightButton, LeftButton + RightButton ) );
                         // Left released, off-widget
                         postEvent( d->presswidget,
                                    new QMouseEvent( QEvent::MouseMove, QPoint( -1, -1),
                                                     LeftButton, LeftButton ) );
                         postEvent( d->presswidget,
                                    new QMouseEvent( QEvent::MouseButtonRelease, QPoint( -1, -1),
                                                     LeftButton, LeftButton ) );
                         d->rightpressed = FALSE;
                         return TRUE; // don't send the real Left release
                     }
                 }
                 break;
             default:
                 break;
             }
             break;
         default:
             ;
         }
     }
     else if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
         QKeyEvent *ke = (QKeyEvent *)e;
         if ( ke->key() == Key_Enter ) {
             if ( o->isA( "QRadioButton" ) || o->isA( "QCheckBox" ) ) {
                 postEvent( o, new QKeyEvent( e->type(), Key_Space, ' ',
                                              ke->state(), " ", ke->isAutoRepeat(), ke->count() ) );
                 return TRUE;
             }
         }
     }
     return FALSE;
 }
 
 // Quit stuff
 void QPEApplication::restart() {
 
 }
 void QPEApplication::shutdown() {
 
 }
 void QPEApplication::tryQuit() {
     qWarning("TryQuit!!");
     if ( activeModalWidget() || strcmp( argv() [ 0 ], "embeddedkonsole" ) == 0 )
         return ; // Inside modal loop or konsole. Too hard to save state.
     {
         QCopEnvelope e( "QPE/System", "closing(QString)" );
         e << d->appName;
     }
     processEvents();
 
     quit();
 }
 void QPEApplication::hideOrQuit() {
     qWarning("hide or close");
     processEvents();
     qWarning("past processing");
 
     // If we are a preloaded application we don't actually quit, so emit
     // a System message indicating we're quasi-closing.
     if ( d->preloaded && d->qpe_main_widget )
 
     {
         qWarning("hiding");
         QCopEnvelope e("QPE/System", "fastAppHiding(QString)" );
         e << d->appName;
         d->qpe_main_widget->hide();
     }
     else
         quit();
 }
 
 /*!
   \internal
 */
 void QPEApplication::prepareForTermination( bool willrestart )
 {
 	if ( willrestart ) {
 		// Draw a big wait icon, the image can be altered in later revisions
 		//  QWidget *d = QApplication::desktop();
 		QImage img = Resource::loadImage( "launcher/new_wait" );
 		QPixmap pix;
 		pix.convertFromImage( img.smoothScale( 1 * img.width(), 1 * img.height() ) );
 		QLabel *lblWait = new QLabel( 0, "wait hack!", QWidget::WStyle_Customize |
 		                              QWidget::WStyle_NoBorder | QWidget::WStyle_Tool );
 		lblWait->setPixmap( pix );
 		lblWait->setAlignment( QWidget::AlignCenter );
 		lblWait->show();
 		lblWait->showMaximized();
 	}
 #ifndef SINGLE_APP
 	{ QCopEnvelope envelope( "QPE/System", "forceQuit()" );
 	}
 	processEvents(); // ensure the message goes out.
 	sleep( 1 ); // You have 1 second to comply.
 #endif
 }
 int QPEApplication::x11ClientMessage(QWidget* w, XEvent* event, bool b ) {
     qWarning("X11 ClientMessage %d %d", event->type,  ClientMessage);
     if ( event->type == ClientMessage ) {
         if ( (event->xclient.message_type == d->wm_protocols) &&
              (event->xclient.data.l[0] == d->wm_context_accept ) ) {
             qWarning("accepted!!!");
             /*
              * I'm not sure if we should use activeWidget
              * or activeModalWidget
              * a QDialog could be not modal too
              */
             if ( w->inherits("QDialog" ) ) {
                 qWarning("inherits QDialog!!!");
                 QDialog* dia = (QDialog*)w;
                 /*
                  * call it directly or via QTimer::singleShot?
                  */
                 QTimer::singleShot(0, dia, SLOT(accept() ) );
                  return 0;
             }
 
         }
     }
     return QApplication::x11ClientMessage(w, event, b );
 }
 
 #define KeyPress XKeyPress
 #define KeyRelease XKeyRelease
 
 #if defined(QT_QWS_IPAQ) || defined(QT_QWS_EBX)
 
 // The libraries with the skiff package (and possibly others) have
 // completely useless implementations of builtin new and delete that
 // use about 50% of your CPU. Here we revert to the simple libc
 // functions.
 
 void* operator new[]( size_t size )
 {
 	return malloc( size );
 }
 
 void* operator new( size_t size )
 {
 	return malloc( size );
 }
 
 void operator delete[]( void* p )
 {
 	free( p );
 }
 
 void operator delete[]( void* p, size_t /*size*/ )
 {
 	free( p );
 }
 
 void operator delete( void* p )
 {
 	free( p );
 }
 
 void operator delete( void* p, size_t /*size*/ )
 {
 	free( p );
 }
 
 #endif
diff --git a/x11/libqpe-x11/qt/qcopchannel_qws.cpp b/x11/libqpe-x11/qt/qcopchannel_qws.cpp
index 1cea80c..706756e 100644
--- a/x11/libqpe-x11/qt/qcopchannel_qws.cpp
+++ b/x11/libqpe-x11/qt/qcopchannel_qws.cpp
@@ -1,76 +1,83 @@
 
 #include "../../ipc/client/ocopclient.h"
 
 #include <qcopchannel_qws.h>
 
 QList<QCopChannel>* QCopChannel::m_list = 0;
 QMap<QCString, int> QCopChannel::m_refCount;
 
 QCopChannel::QCopChannel( const QCString& channel, QObject* parent,
                           const char* name )
     : QObject( parent, name ),m_chan(channel) {
     if (!m_list ) {
         m_list = new QList<QCopChannel>;
         /* only connect once */
         connect(OCOPClient::self(), SIGNAL(called(const QCString&, const QCString&, const QByteArray& ) ),
                 this, SLOT(rev(const QCString&, const QCString&, const QByteArray&) ) );
     }
     /* first registration  or ref count is 0 for m_chan*/
     if (!m_refCount.contains( m_chan ) || !m_refCount[m_chan]  ) {
+        qWarning("adding channel %s", m_chan.data() );
         m_refCount[m_chan] = 1;
         OCOPClient::self()->addChannel( m_chan );
-    }else
+    }else{
+        qWarning("reffing up for %s %d", m_chan.data(), m_refCount[m_chan] );
         m_refCount[m_chan]++;
+    }
 
     m_list->append(this);
 }
 void QCopChannel::receive( const QCString& msg, const QByteArray& ar ) {
     emit received( msg, ar );
 }
 QCopChannel::~QCopChannel() {
     if (m_refCount[m_chan] == 1 ) {
         OCOPClient::self()->delChannel( m_chan );
         m_refCount[m_chan] = 0;
     }else
         m_refCount[m_chan]--;
 
 
     m_list->remove(this);
     if (m_list->count() == 0 ) {
         delete m_list;
         m_list = 0;
     }
 
 }
 QCString QCopChannel::channel()const {
     return m_chan;
 }
-bool QCopChannel::isRegistered( const QCString& chan) {;
+bool QCopChannel::isRegistered( const QCString& chan) {
+    if (m_refCount.contains(chan) ) {
+            qDebug("Client:locally contains");
+            return true;
+    }
     return OCOPClient::self()->isRegistered( chan );
 }
 bool QCopChannel::send( const QCString& chan, const QCString& msg ) {
     QByteArray ar;
     return send(chan, msg, ar );
 }
 bool QCopChannel::send( const QCString& chan, const QCString& msg,
                      const QByteArray& ar ) {
     OCOPClient::self()->send( chan, msg, ar );
     return true;
 }
 bool QCopChannel::sendLocally( const QCString& chann, const QCString& msg,
                                const QByteArray& ar ) {
     qWarning("Client:sendLocally %s %s", chann.data(), msg.data() );
     if (!m_list )
         return true;
     QCopChannel* chan;
 
     for ( chan = m_list->first(); chan; chan = m_list->next() ) {
         if ( chan->channel() == chann )
             chan->receive( msg, ar );
     }
 
     return true;
 }
 void QCopChannel::rev( const QCString& chan, const QCString& msg, const QByteArray& ar ) {
     sendLocally( chan, msg, ar );
 }