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
@@ -90,63 +90,63 @@ void OCOPClient::newData() {
         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 ) {
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
@@ -22,25 +22,25 @@ OCopServer::OCopServer()
     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
@@ -112,25 +112,25 @@ void OCopServer::initSocket() {
 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 ) {
@@ -185,101 +185,101 @@ void OCopServer::newOnClient( int fd ) {
 
         /*
          * 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:
@@ -291,25 +291,25 @@ void OCopServer::dispatch( const OCOPPacket& packet, int sourceFD ) {
         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() {
@@ -324,90 +324,90 @@ QStringList OCopServer::channels() {
 }
 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
@@ -490,26 +490,26 @@ int QPEApplication::exec() {
 
     {
         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;
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
@@ -8,53 +8,60 @@ 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,