Debug output

disabled some features inside the QTextView..
fixed two typos and the order of filename + description

it's sending now again

3 files changed, 15 insertions, 11 deletions

diff --git a/core/obex/obex.cc b/core/obex/obex.cc
index 83d1faf..92cd317 100644
--- a/core/obex/obex.cc
+++ b/core/obex/obex.cc
@@ -1,174 +1,175 @@
 
 #include <qapplication.h>
+#include <qfile.h>
 #include <qmessagebox.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <opie/oprocess.h>
 #include "obex.h"
 
 using namespace  OpieObex;
 
 Obex::Obex( QObject *parent, const char* name )
   : QObject(parent, name )
 {
     m_rec = 0;
     m_send=0;
     m_count = 0;
     m_receive = false;
     connect( this, SIGNAL(error(int) ), // for recovering to receive
              SLOT(slotError() ) );
     connect( this, SIGNAL(sent() ),
              SLOT(slotError() ) );
 };
 Obex::~Obex() {
     delete m_rec;
     delete m_send;
 }
 void Obex::receive()  {
     m_receive = true;
     m_outp = QString::null;
     qWarning("Receive" );
     m_rec = new OProcess();
     *m_rec << "irobex_palm3";
     // connect to the necessary slots
     connect(m_rec,  SIGNAL(processExited(OProcess*) ),
             this,  SLOT(slotExited(OProcess*) ) );
 
     connect(m_rec,  SIGNAL(receivedStdout(OProcess*, char*,  int ) ),
             this,  SLOT(slotStdOut(OProcess*, char*, int) ) );
 
     if(!m_rec->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning("could not start :(");
         emit done( false );
         delete m_rec;
         m_rec = 0;
     }
 //    emit currentTry(m_count );
 
 }
 void Obex::send( const QString& fileName) { // if currently receiving stop it send receive
     m_count = 0;
     m_file = fileName;
-    qWarning("send");
+    qWarning("send %s", fileName.latin1() );
     if (m_rec != 0 ) {
         qWarning("running");
         if (m_rec->isRunning() ) {
             emit error(-1 );
             qWarning("is running");
             delete m_rec;
             m_rec = 0;
 
         }else{
             qWarning("is not running");
             emit error( -1 ); // we did not delete yet but it's not running slotExited is pending
             return;
         }
     }
     sendNow();
 }
 void Obex::sendNow(){
     qWarning("sendNow");
     if ( m_count >= 25 ) { // could not send
         emit error(-1 );
         emit sent(false);
         return;
     }
     // OProcess inititialisation
     m_send = new OProcess();
     *m_send << "irobex_palm3";
-    *m_send << m_file;
+    *m_send << QFile::encodeName(m_file);
 
     // connect to slots Exited and and StdOut
     connect(m_send,  SIGNAL(processExited(OProcess*) ),
             this, SLOT(slotExited(OProcess*)) );
     connect(m_send,  SIGNAL(receivedStdout(OProcess*, char*,  int )),
             this, SLOT(slotStdOut(OProcess*, char*, int) ) );
 
     // now start it
     if (!m_send->start(/*OProcess::NotifyOnExit,  OProcess::AllOutput*/ ) ) {
         qWarning("could not send" );
         m_count = 25;
         emit error(-1 );
         delete m_send;
         m_send=0;
     }
     // end
     m_count++;
     emit currentTry( m_count );
 }
 
 void Obex::slotExited(OProcess* proc ){
     if (proc == m_rec ) { // receive process
         received();
     }else if ( proc == m_send ) {
         sendEnd();
     }
 }
 void Obex::slotStdOut(OProcess* proc, char* buf, int len){
     if ( proc == m_rec ) { // only receive
         QCString cstring( buf,  len );
         m_outp.append( cstring.data() );
     }
 }
 
 void Obex::received() {
   if (m_rec->normalExit() ) {
       if ( m_rec->exitStatus() == 0 ) { // we got one
           QString filename = parseOut();
           qWarning("ACHTUNG");
           emit receivedFile( filename );
       }
   }else{
       emit done(false);
   };
   delete m_rec;
   m_rec = 0;
   receive();
 }
 
 void Obex::sendEnd() {
   if (m_send->normalExit() ) {
     if ( m_send->exitStatus() == 0 ) {
       delete m_send;
       m_send=0;
       qWarning("done" );
       emit sent(true);
     }else if (m_send->exitStatus() == 255 ) { // it failed maybe the other side wasn't ready
       // let's try it again
       delete m_send;
       m_send = 0;
       qWarning("try sending again" );
       sendNow();
     }
   }else {
     emit error( -1 );
     delete m_send;
     m_send = 0;
   }
 }
 QString Obex::parseOut(     ){
   QString path;
   QStringList list = QStringList::split("\n",  m_outp);
   QStringList::Iterator it;
   for (it = list.begin(); it != list.end(); ++it ) {
     if ( (*it).startsWith("Wrote"  ) ) {
         int pos = (*it).findRev('(' );
         if ( pos > 0 ) {
             qWarning( "%d %s", pos,  (*it).mid(6 ).latin1() ) ;
             qWarning("%d %d",  (*it).length(),  (*it).length()-pos );
 
             path = (*it).remove( pos, (*it).length() - pos );
             qWarning("%s",  path.latin1() );
             path = path.mid(6 );
             path = path.stripWhiteSpace();
             qWarning("path %s", path.latin1() );
         }
     }
   }
   return path;
 }
 /**
  * when sent is done slotError is called we  will start receive again
  */
 void Obex::slotError() {
     qWarning("slotError");
     if ( m_receive )
diff --git a/core/obex/obexhandler.cpp b/core/obex/obexhandler.cpp
index f71a233..16e1c2f 100644
--- a/core/obex/obexhandler.cpp
+++ b/core/obex/obexhandler.cpp
@@ -1,65 +1,65 @@
 #include <qcopchannel_qws.h>
 
 #include <qpe/qcopenvelope_qws.h>
 
 #include "obexsend.h"
 #include "receiver.h"
 #include "obexhandler.h"
 
 using namespace OpieObex;
 
 ObexHandler::ObexHandler() {
     m_wasRec = false;
     m_sender = 0l;
     m_receiver = 0l;
     QCopChannel* chan = new QCopChannel("QPE/Obex");
     connect(chan, SIGNAL(received(const QCString&, const QByteArray& ) ),
             this, SLOT(irdaMessage(const QCString&, const QByteArray& ) ) );
 }
 ObexHandler::~ObexHandler() {
     delete m_sender;
     delete m_receiver;
 }
 void ObexHandler::doSend(const QString& str, const QString& desc) {
     delete m_sender;
     m_sender = new SendWidget;
     m_sender->raise();
     m_sender->showMaximized();
     connect(m_sender, SIGNAL(done() ),
             this, SLOT(slotSent() ) );
     m_sender->send( str, desc );
 }
 void ObexHandler::doReceive(bool b) {
     if (m_receiver && b ) return; // we should enable receiver and it is on
     else if (!m_receiver && !b ) return; // we should disbale receiver and it is off
     else if (m_receiver && !b ) {
         delete m_receiver;
         m_receiver=0;
     }else if (!m_receiver && b ) {
         m_receiver= new Receiver;
     }
 }
 void ObexHandler::slotSent() {
     QString file = m_sender->file();
     delete m_sender;
     m_sender = 0;
     QCopEnvelope e ("QPE/Obex", "done(QString)" );
     e << file;
     doReceive(m_wasRec );
     m_wasRec = false;
 }
 void ObexHandler::irdaMessage( const QCString& msg, const QByteArray& data) {
     QDataStream stream( data, IO_ReadOnly );
     if ( msg == "send(QString,QString,QString)" ) {
         QString name,  desc;
         stream >> name;
         stream >> desc;
         m_wasRec = (m_receiver != 0 );
         doReceive( false );
-        doSend(name, desc);
+        doSend(desc, name);
     }else if (msg == "receive(int)") {
         int rec;
         stream >> rec;
         doReceive(rec);
     }
 }
diff --git a/core/obex/obexsend.cpp b/core/obex/obexsend.cpp
index a2e4c16..d5ebd81 100644
--- a/core/obex/obexsend.cpp
+++ b/core/obex/obexsend.cpp
@@ -1,251 +1,254 @@
 #include <qpushbutton.h>
 #include <qlabel.h>
 #include <qhbox.h>
 #include <qlayout.h>
 #include <qtimer.h>
 
 #include <qcopchannel_qws.h>
 
 #include <qpe/resource.h>
 #include <qpe/qcopenvelope_qws.h>
 
 #include "obex.h"
 #include "obexsend.h"
 
 using namespace OpieObex;
 
 
 SendWidget::SendWidget( QWidget* parent, const char* name )
     : QWidget( parent, name ) {
     initUI();
 }
 SendWidget::~SendWidget() {
 }
 void SendWidget::initUI() {
     m_obex = new Obex(this, "obex");
     connect(m_obex, SIGNAL(error(int) ),
             this, SLOT(slotIrError(int) ) );
     connect(m_obex, SIGNAL(sent(bool) ),
             this, SLOT(slotIrSent(bool) ) );
     connect(m_obex, SIGNAL(currentTry(unsigned int ) ),
             this, SLOT(slotIrTry(unsigned int ) ) );
 
     QCopChannel* chan = new QCopChannel("QPE/IrDaAppletBack", this );
     connect(chan, SIGNAL(received(const QCString&, const QByteArray& ) ),
-            this, SLOT(dispatchBt(const QCString&, const QByteArray& ) ) );
+            this, SLOT(dispatchIrda(const QCString&, const QByteArray& ) ) );
 
     chan = new QCopChannel("QPE/BluetoothBack", this );
     connect(chan, SIGNAL(received(const QCString&, const QByteArray& ) ),
-            this, SLOT(dispatchIrda(const QCString&, const QByteArray& ) ) );
+            this, SLOT(dispatchBt(const QCString&, const QByteArray& ) ) );
 
     QVBoxLayout* lay = new QVBoxLayout(this);
 
     QHBox* nameBox = new QHBox(this);
     QLabel* name = new QLabel(nameBox);
     name->setText( tr("<qt><h1>Sending:</h1></qt>") );
     name->setAlignment( AlignLeft | AlignTop );
     m_lblFile = new QLabel(nameBox);
     lay->addWidget(nameBox, 0);
 
     QFrame* frame = new QFrame(this);
     frame->setFrameShape( QFrame::HLine );
     frame->setFrameShadow( QFrame::Sunken );
     lay->addWidget(frame, 10);
 
     QLabel* devices = new QLabel(this);
     devices->setText("<qt><b>Devices:</b></qt>");
     devices->setAlignment( AlignLeft | AlignTop );
     lay->addWidget( devices,10 );
 
     m_devBox = new DeviceBox(this);
     lay->addWidget( m_devBox, 50 );
     connect(m_devBox, SIGNAL(selectedDevice(const QString&, int ) ),
             this, SLOT(slotSelectedDevice(const QString&, int) ) );
 
     QPushButton *but = new QPushButton(this);
     but->setText(tr("Done") );
     connect(but, SIGNAL(clicked() ),
             this, SLOT(slotDone() ) );
 
     lay->addWidget( but );
     m_lay = lay;
 
     // QT does not like if you add items to an layout which already exits....
     // and was layouted invalidate() does not help too
     // so we use RichText....
 }
 
 /*
  * in send we'll first set everything up
  * and then wait for a list of devices.
  */
 void SendWidget::send( const QString& file, const QString& desc ) {
     m_file = file;
     m_irDa.clear();
     m_start = 0;
     m_lblFile->setText(desc.isEmpty() ? file : desc );
 
     if ( !QCopChannel::isRegistered("QPE/IrDaApplet") ) {
         m_devBox->addDevice( tr("IrDa is not enabled!"), DeviceBox::Error );
         m_start++;
     }else
         m_devBox->addDevice( tr("Searching for IrDa Devices."), DeviceBox::Search );
 
     if ( !QCopChannel::isRegistered("QPE/Bluetooth") ) {
         m_devBox->addDevice( tr("Bluetooth is not available"), DeviceBox::Error );
         m_start++;
     }else
         m_devBox->addDevice( tr("Searching for bluetooth Devices."), DeviceBox::Search );
 
     if (m_start != 2 ) {
         QCopEnvelope e0("QPE/IrDaApplet", "enableIrda()");
         QCopEnvelope e1("QPE/Bluetooth", "enableBluetooth()");
         QCopEnvelope e2("QPE/IrDaApplet", "listDevices()");
         QCopEnvelope e3("QPE/Bluetooth", "listDevices()");
     }
-    QTimer::singleShot(5000, this, SLOT(testIt() ) );
 }
 void SendWidget::slotIrDaDevices( const QStringList& list) {
+    qWarning("slot it irda devices ");
     m_irDa = list;
     m_start = 0;
     for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it )
         m_devBox->addDevice( (*it), DeviceBox::IrDa, tr("Scheduling for beam.") );
-    m_devBox->removeDevice( tr("Search for IrDa Devices.") );
+
+    m_devBox->removeDevice( tr("Searching for IrDa Devices.") );
 
     slotStartIrda();
 }
 void SendWidget::slotBTDevices( const QMap<QString, QString>& str ) {
     m_bt = str;
     for(QMap<QString, QString>::ConstIterator it = str.begin(); it != str.end(); ++it ) {
         m_devBox->addDevice( it.key(), DeviceBox::BT, tr("Click to beam") );
     }
     m_devBox->removeDevice( tr("Searching for bluetooth Devices.") );
 }
 void SendWidget::slotSelectedDevice( const QString& name, int dev ) {
     qWarning("Start beam? %s %d", name.latin1(), dev );
     if ( name == tr("Search again for IrDa.") ) {
         for (QStringList::Iterator it= m_irDa.begin(); it != m_irDa.end(); ++it )
             m_devBox->removeDevice( (*it) );
+
         QCopEnvelope e2("QPE/IrDaApplet", "listDevices()");
     }
 }
 void SendWidget::dispatchIrda( const QCString& str, const QByteArray& ar ) {
     qWarning("dispatch irda %s", str.data() );
-    if ( str == "listDevices(QStringList)" ) {
+    if ( str == "devices(QStringList)" ) {
         QDataStream stream( ar, IO_ReadOnly );
         QStringList list;
         stream >> list;
         slotIrDaDevices( list );
     }
 }
 void SendWidget::dispatchBt( const QCString& str, const QByteArray& ar ) {
 
 }
 void SendWidget::slotIrError( int ) {
 
 }
 void SendWidget::slotIrSent( bool b) {
+    qWarning("irda sent!!");
     QString text = b ? tr("Sent") : tr("Failure");
-    m_devBox->setStatus( m_irDa[m_start], text );
+//    m_devBox->setStatus( m_irDa[m_start], text );
     m_start++;
     slotStartIrda();
 }
 void SendWidget::slotIrTry(unsigned int trI) {
-    m_devBox->setStatus( m_irDa[m_start], tr("Try %1").arg( QString::number( trI ) ) );
+//    m_devBox->setStatus( m_irDa[m_start], tr("Try %1").arg( QString::number( trI ) ) );
 }
 void SendWidget::slotStartIrda() {
     if (m_start >= m_irDa.count() ) {
         m_devBox->addDevice(tr("Search again for IrDa."), DeviceBox::Search );
         return;
     }
-    m_devBox->setStatus( m_irDa[m_start], tr("Start sending") );
+//    m_devBox->setStatus( m_irDa[m_start], tr("Start sending") );
     m_obex->send( m_file );
 }
 void SendWidget::slotDone() {
     QCopEnvelope e0("QPE/IrDaApplet", "disableIrda()");
     QCopEnvelope e1("QPE/Bluetooth", "disableBluetooth()");
     emit done();
 }
 QString SendWidget::file()const {
     return m_file;
 }
 DeviceBox::DeviceBox( QWidget* parent )
     : QTextBrowser( parent ) {
 
 }
 DeviceBox::~DeviceBox() {
 
 }
 void DeviceBox::addDevice( const QString& name, int dev, const QString& status ) {
     QString tex;
     DeviceItem item( name, status, dev );
     m_dev.insert( name, item );
     tex = item.toString();
     m_devices.prepend(tex);
     setText( text()+ "<br>"+tex );
 }
 void DeviceBox::removeDevice( const QString& name ) {
     if (!m_dev.contains(name) ) return;
     m_devices.remove( m_dev[name].toString() );
 
     m_dev.remove(name);
     setText( m_devices.join("<br>") );
 
 }
 void DeviceBox::setStatus( const QString& name, const QString& status ) {
     if ( !m_dev.contains(name) ) return;
     DeviceItem dev = m_dev[name];
     QString ole = dev.toString();
     dev.setStatus( status );
     int index = m_devices.findIndex( ole );
     m_devices[index] = dev.toString();
     setText( m_devices.join("<br>") );
 }
 void DeviceBox::setSource( const QString& str ) {
     qWarning("SetSource:%s", str.latin1() );
     emit selectedDevice( str, m_dev[str].device() );
 }
 
 
 DeviceItem::DeviceItem( const QString& name,
                         const QString& status, int dev)
 {
     m_name = name;
     m_status = status;
     m_dev = dev;
 }
 QString DeviceItem::name()const {
     return m_name;
 }
 QString DeviceItem::status()const {
     return m_status;
 }
 int DeviceItem::device()const {
     return m_dev;
 }
 QString DeviceItem::pixmap()const{
     QString str;
     switch(m_dev) {
     case DeviceBox::IrDa:
         str ="obex/irda";
         break;
     case DeviceBox::BT:
         str ="obex/bt";
         break;
     case DeviceBox::Search:
         str = "obex/search";
         break;
     case DeviceBox::Error:
         str = "editdelete";
         break;
     };
     return str;
 }
 DeviceItem::~DeviceItem() {
 }
 void DeviceItem::setStatus(const QString& status ) {
     m_status = status;
 }
 QString DeviceItem::toString()const {
     return "<p><a href=\""+m_name +"\" ><img src=\""+pixmap()+"\" >"+m_name+" "+m_status+" </a></p>" ;
 }