Convert the way of storing the devices in the QTextBrowser

we assign ids by now
it looks soo nice... but it counts up tries and then say there was a failure
but it is working though

3 files changed, 143 insertions, 67 deletions

diff --git a/core/obex/obex.cc b/core/obex/obex.cc
index b8ed6e0..595fed9 100644
--- a/core/obex/obex.cc
+++ b/core/obex/obex.cc
@@ -1,37 +1,40 @@
 
 #include <qapplication.h>
 #include <qfile.h>
-#include <qmessagebox.h>
+#include <qfileinfo.h>
+#include <qtextcodec.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(bool) ),
              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 ) ),
@@ -77,74 +80,87 @@ void Obex::sendNow(){
     m_send = new OProcess();
     *m_send << "irobex_palm3";
     *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
-        QString str = QString::fromUtf8( buf,  len );
-        m_outp.append( str );
+        for (int i = 0; i < len; i++ ) {
+            printf("%c", buf[i] );
+        }
+        printf("\n");
+        QByteArray ar( len );
+        memcpy( ar.data(), buf, len );
+        qWarning("parsed: %s", ar.data() );
+        m_outp.append( ar );
     }
 }
 
 void Obex::received() {
   if (m_rec->normalExit() ) {
       if ( m_rec->exitStatus() == 0 ) { // we got one
           QString filename = parseOut();
           qWarning("ACHTUNG %s", filename.latin1() );
+          if (filename.contains( 'ö' ) || filename.contains( 'ä' ) || filename.contains('ü' ) ) {
+              qWarning("renaming!!!!");
+              QFileInfo inf( filename );
+              QString newName = "/tmp/opie-obex." + inf.extension();
+              ::rename( QFile::encodeName( filename ).data(), newName );
+              qWarning("name is %s", QFile::encodeName( filename ).data() );
+          }
           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;
diff --git a/core/obex/obexsend.cpp b/core/obex/obexsend.cpp
index d5ebd81..0da57ca 100644
--- a/core/obex/obexsend.cpp
+++ b/core/obex/obexsend.cpp
@@ -1,254 +1,291 @@
 #include <qpushbutton.h>
 #include <qlabel.h>
 #include <qhbox.h>
 #include <qlayout.h>
 #include <qtimer.h>
+#include <qtl.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(dispatchIrda(const QCString&, const QByteArray& ) ) );
 
     chan = new QCopChannel("QPE/BluetoothBack", this );
     connect(chan, SIGNAL(received(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) ) );
+    connect(m_devBox, SIGNAL(selectedDevice(int, int ) ),
+            this, SLOT(slotSelectedDevice(int, 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_irDeSearch = m_devBox->addDevice( tr("IrDa is not enabled!"), DeviceBox::Error );
         m_start++;
     }else
-        m_devBox->addDevice( tr("Searching for IrDa Devices."), DeviceBox::Search );
+        m_irDeSearch = 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_btDeSearch = m_devBox->addDevice( tr("Bluetooth is not available"), DeviceBox::Error );
         m_start++;
     }else
-        m_devBox->addDevice( tr("Searching for bluetooth Devices."), DeviceBox::Search );
+        m_btDeSearch = 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()");
     }
 }
 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("Searching for IrDa Devices.") );
+    for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it ) {
+        int id = m_devBox->addDevice( (*it), DeviceBox::IrDa, tr("Scheduling for beam.") );
+        m_irDa.insert( id, (*it) );
+    }
+    m_devBox->removeDevice( m_irDeSearch );
+    m_irDaIt = m_irDa.begin();
 
     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") );
+        int id = m_devBox->addDevice( it.key(), DeviceBox::BT, tr("Click to beam") );
+        m_bt.insert( id, Pair( it.key(), it.data() ) );
     }
-    m_devBox->removeDevice( tr("Searching for bluetooth Devices.") );
+    m_devBox->removeDevice( m_btDeSearch );
 }
-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) );
+void SendWidget::slotSelectedDevice( int name, int dev ) {
+    qWarning("Start beam? %d %d", name, dev );
+    if ( name ==  m_irDeSearch ) {
+        for (QMap<int, QString>::Iterator it= m_irDa.begin(); it != m_irDa.end(); ++it )
+            m_devBox->removeDevice( it.key() );
 
         QCopEnvelope e2("QPE/IrDaApplet", "listDevices()");
     }
 }
 void SendWidget::dispatchIrda( const QCString& str, const QByteArray& ar ) {
     qWarning("dispatch irda %s", str.data() );
     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::dispatchBt( const QCString&, const QByteArray&  ) {
 
 }
 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_start++;
+    m_devBox->setStatus( m_irDaIt.key(), text );
+    ++m_irDaIt;
     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_irDaIt.key(), 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 );
+    if (m_irDaIt == m_irDa.end() ) {
+        m_irDeSearch = 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_irDaIt.key(), 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() );
+int DeviceBox::addDevice( const QString& name, int dev, const QString& status ) {
+    /* return a id for a range of devices */
+    int id = idFor ( dev );
+    DeviceItem item( name, status, dev,id );
+    m_dev.insert( id, item );
+    setText( allText() );
 
-    m_dev.remove(name);
-    setText( m_devices.join("<br>") );
+    return id;
+}
+void DeviceBox::removeDevice( int id ) {
+    if (!m_dev.contains(id) ) return;
 
+    m_dev.remove( id );
+    setText( allText() );
 }
-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::setStatus( int id, const QString& status ) {
+    if ( !m_dev.contains(id) ) return;
+    m_dev[id].setStatus(status );
+    setText( allText() );
 }
 void DeviceBox::setSource( const QString& str ) {
-    qWarning("SetSource:%s", str.latin1() );
-    emit selectedDevice( str, m_dev[str].device() );
+    qWarning("SetSource:%d", str.toInt() );
+    int id = str.toInt();
+    emit selectedDevice( id, m_dev[id].device() );
+}
+int DeviceBox::idFor ( int id ) {
+    static int irId = 1501;
+    static int irBT = 1001;
+    static int irSr = 501;
+    static int irEr = 0;
+
+    int ret = -1;
+    switch(id ) {
+    case IrDa:
+        ret = irId;
+        irId++;
+        break;
+    case BT:
+        ret = irBT;
+        irBT++;
+        break;
+    case Search:
+        ret = irSr;
+        irSr++;
+        break;
+    case Error:
+        ret = irEr;
+        irEr++;
+        break;
+    }
+    return ret;
 }
+QString DeviceBox::allText() {
+    QString str;
+    typedef QMap<int, DeviceItem> DeviceMap;
 
+    for (QMap<int, DeviceItem>::Iterator it = m_dev.begin(); it != m_dev.end(); ++it ) {
+        str += it.data().toString() + "<br>";
+    }
+    return str;
+}
 
 DeviceItem::DeviceItem( const QString& name,
-                        const QString& status, int dev)
+                        const QString& status, int dev,  int id)
 {
     m_name = name;
     m_status = status;
     m_dev = dev;
+    m_id = id;
+}
+int DeviceItem::id()const {
+    return m_id;
 }
 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>" ;
+    return "<p><a href=\""+QString::number(m_id) +"\" ><img src=\""+pixmap()+"\" >"+m_name+" "+m_status+" </a></p>" ;
 }
diff --git a/core/obex/obexsend.h b/core/obex/obexsend.h
index fd819bc..02100f7 100644
--- a/core/obex/obexsend.h
+++ b/core/obex/obexsend.h
@@ -1,99 +1,122 @@
 #ifndef OPIE_OBEX_SEND_WIDGET_H
 #define OPIE_OBEX_SEND_WIDGET_H
 
 #include <qstring.h>
 #include <qstringlist.h>
 #include <qwidget.h>
 #include <qvbox.h>
 #include <qmap.h>
 #include <qtextbrowser.h>
 
 class QLabel;
 class QVBoxLayout;
 /**
  * This is the new sending widget for Obex
  * It will attemp to smart and be able to send
  * it to multiple devices.
  * It'll support BT + IrDa
  */
 namespace OpieObex {
     class DeviceBox;
     class Obex;
+
+    struct Pair {
+        Pair(const QString& first = QString::null,
+             const QString& second = QString::null)
+            : m_first(first), m_second(second ) {
+        }
+        QString first()const{ return m_first; }
+        QString second()const { return m_second; }
+    private:
+        QString m_first;
+        QString m_second;
+    };
     class SendWidget : public QWidget{
         Q_OBJECT
     public:
         SendWidget( QWidget* parent = 0, const char* name = 0);
         ~SendWidget();
 
         QString file()const;
 
     public slots:
         void send( const QString& file, const QString& desc );
 
     signals:
         void done();
 
     private slots: // QCOP slots
         /* IrDa Names*/
         void slotIrDaDevices( const QStringList& );
         /* Bt Names + BD-Addr */
         void slotBTDevices( const QMap<QString, QString>& );
-        void slotSelectedDevice( const QString& name, int dev );
+        void slotSelectedDevice( int id, int dev );
         void dispatchIrda( const QCString& str, const QByteArray& ar );
         void dispatchBt( const QCString& str, const QByteArray& ar );
 
         void slotIrError( int );
         void slotIrSent(bool);
         void slotIrTry(unsigned int );
         void slotStartIrda();
         void slotDone();
     private:
         void initUI();
         QLabel* m_lblFile;
         DeviceBox* m_devBox;
         QVBoxLayout* m_lay;
         int m_start;
-        QStringList m_irDa;
-        QMap<QString, QString> m_bt;
+        QMap<int, QString> m_irDa;
+        QMap<int, QString>::Iterator m_irDaIt;
+        QMap<int, Pair > m_bt;
         QString m_file;
         Obex* m_obex;
+        int m_irDeSearch; // search of irda and bt devices
+        int m_btDeSearch;
     };
     class DeviceItem  {
     public:
         DeviceItem( const QString& name = QString::null,
-                    const QString& status = QString::null, int dev = 3);
+                    const QString& status = QString::null, int dev = 3,  int id = -1);
         ~DeviceItem();
         void setStatus( const QString& text );
 
         QString name()const;
         QString status()const;
         QString pixmap()const;
         int device()const;
+        int id()const;
         QString toString()const;
     private:
         QString m_name;
         QString m_status;
         int m_dev;
+        int m_id;
     };
+
+    /*
+     * The text field which contains the information about sending...
+     *
+     */
     class DeviceBox : public QTextBrowser {
         Q_OBJECT
     public:
         enum Device { IrDa, BT, Search, Error };
         DeviceBox( QWidget* parent );
         ~DeviceBox();
 
         void setSource( const QString& str );
-        void addDevice( const QString& name, int dev,
-                        const QString& status = QString::null );
-        void removeDevice( const QString& name );
-        void setStatus( const QString& name, const QString& );
+        int addDevice( const QString& name, int dev,
+                       const QString& status = QString::null );
+        void removeDevice( int );
+        void setStatus( int, const QString& );
     signals:
-        void selectedDevice( const QString& name, int dev );
+        void selectedDevice( int id, int dev );
     private:
-        QMap<QString, DeviceItem> m_dev;
-        QStringList m_devices;
-
+        /* returns a id for a device from a device range */
+        int idFor (int deviceType );
+        QString allText();
+        QMap<int, DeviceItem> m_dev;
     };
 }
 
 #endif