8 files changed, 56 insertions, 48 deletions

diff --git a/noncore/net/opietooth/lib/device.cc b/noncore/net/opietooth/lib/device.cc
index bae1c47..d913853 100644
--- a/noncore/net/opietooth/lib/device.cc
+++ b/noncore/net/opietooth/lib/device.cc
@@ -1,15 +1,17 @@
 
 #include <signal.h>
 
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 #include "device.h"
 
 using namespace OpieTooth;
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 namespace {
   int parsePid( const QCString& par ){
     int id=0;
     QString string( par );
     QStringList list =  QStringList::split( '\n', string );
     for( QStringList::Iterator it = list.begin(); it != list.end(); ++it ){
@@ -44,17 +46,17 @@ void Device::attach(){
     m_output.resize(0);
     qWarning("new process to create" );
     m_process = new OProcess();
     *m_process << "hciattach";
     *m_process << "-p";
     *m_process << m_device << m_mode << m_speed;
-    connect(m_process, SIGNAL( processExited(OProcess*) ),
+    connect(m_process, SIGNAL( processExited(Opie::Core::OProcess*) ),
             this, SLOT( slotExited(OProcess* ) ) );
-    connect(m_process, SIGNAL( receivedStdout(OProcess*, char*, int) ),
+    connect(m_process, SIGNAL( receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotStdOut(OProcess*,char*,int ) ) );
-    connect(m_process, SIGNAL(receivedStderr(OProcess*, char*, int ) ),
+    connect(m_process, SIGNAL(receivedStderr(Opie::Core::OProcess*, char*, int ) ),
             this, SLOT(slotStdErr(OProcess*,char*,int) ) );
     if(!m_process->start(OProcess::NotifyOnExit, OProcess::AllOutput ) ){
       qWarning("Could not start" );
       delete m_process;
       m_process = 0;
     }
@@ -93,13 +95,13 @@ void Device::slotExited( OProcess* proc)
         // now hciconfig hci0 up ( determine hciX FIXME)
         // and call hciconfig hci0 up
         // FIXME hardcoded to hci0 now :(
         m_hci = new OProcess( );
         *m_hci << "hciconfig";
         *m_hci << "hci0 up";
-        connect(m_hci, SIGNAL( processExited(OProcess*) ),
+        connect(m_hci, SIGNAL( processExited(Opie::Core::OProcess*) ),
                 this, SLOT( slotExited(OProcess* ) ) );
         if(!m_hci->start() ){
           qWarning("could not start" );
           m_attached = false;
           emit device("hci0", false );
         }
diff --git a/noncore/net/opietooth/lib/device.h b/noncore/net/opietooth/lib/device.h
index ce7fccc..f3339fc 100644
--- a/noncore/net/opietooth/lib/device.h
+++ b/noncore/net/opietooth/lib/device.h
@@ -5,13 +5,13 @@
 #include <qobject.h>
 #include <qstring.h>
 #include <qvaluelist.h>
 
 #include <sys/types.h>
 
-class OProcess;
+namespace Opie {namespace Core {class Opie::Core::OProcess;}}
 namespace OpieTooth {
     /**
      *  Device takes care of attaching serial
      *  devices to the blueZ stack.
      *  After attaching it hciconfig ups it
      */
@@ -64,22 +64,22 @@ namespace OpieTooth {
          * Signals devicename and up status
          * @return &device QString, Devicename
          * @return up bool, if the device is up or not.
          */
         void device(const QString& device, bool up );
     private slots:
-        virtual void slotExited( OProcess* );
-        virtual void slotStdOut(OProcess*, char*, int );
-        virtual void slotStdErr(OProcess*, char*, int );
+        virtual void slotExited( Opie::Core::OProcess* );
+        virtual void slotStdOut(Opie::Core::OProcess*, char*, int );
+        virtual void slotStdErr(Opie::Core::OProcess*, char*, int );
     private:
         class Private;
         Private *d;
         QString m_device;
         bool m_attached:1;
-        OProcess* m_hci;
-        OProcess* m_process;
+        Opie::Core::OProcess* m_hci;
+        Opie::Core::OProcess* m_process;
         QString m_devId;
         QString m_mode;
         QString m_speed;
         pid_t pid;
         QCString m_output;
     };
diff --git a/noncore/net/opietooth/lib/manager.cc b/noncore/net/opietooth/lib/manager.cc
index c89d325..56156a8 100644
--- a/noncore/net/opietooth/lib/manager.cc
+++ b/noncore/net/opietooth/lib/manager.cc
@@ -1,16 +1,18 @@
 
 
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 #include "parser.h"
 #include "manager.h"
 
 
 using namespace OpieTooth;
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 Manager::Manager( const QString& dev )
   : QObject()
 {
     qWarning("created");
     m_device = dev;
     m_hcitool = 0;
@@ -39,13 +41,13 @@ void Manager::setDevice( Device* /*dev*/ ){
 
 }
 void Manager::isAvailable( const QString& device ){
     OProcess* l2ping = new OProcess();
     l2ping->setName( device.latin1() );
     *l2ping << "l2ping" << "-c1" << device;
-    connect(l2ping, SIGNAL(processExited(OProcess* ) ),
+    connect(l2ping, SIGNAL(processExited(Opie::Core::OProcess* ) ),
             this, SLOT(slotProcessExited(OProcess*) ) );
     if (!l2ping->start() ) {
         emit available( device,  false );
         delete l2ping;
     }
 
@@ -57,15 +59,15 @@ void Manager::isAvailable( Device* /*dev*/ ){
 }
 void Manager::searchDevices( const QString& device ){
     qWarning("search devices");
     OProcess* hcitool = new OProcess();
     hcitool->setName( device.isEmpty() ? "hci0" : device.latin1() );
     *hcitool << "hcitool" << "scan";
-    connect( hcitool, SIGNAL(processExited(OProcess*) ) ,
+    connect( hcitool, SIGNAL(processExited(Opie::Core::OProcess*) ) ,
              this, SLOT(slotHCIExited(OProcess* ) ) );
-    connect( hcitool, SIGNAL(receivedStdout(OProcess*, char*, int ) ),
+    connect( hcitool, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int ) ),
              this, SLOT(slotHCIOut(OProcess*, char*, int ) ) );
     if (!hcitool->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning("could not start");
         RemoteDevice::ValueList list;
         emit foundDevices( device, list );
         delete hcitool;
@@ -104,15 +106,15 @@ void Manager::removeServices( const QStringList& list){
 }
 void Manager::searchServices( const QString& remDevice ){
     OProcess *m_sdp =new OProcess();
     *m_sdp << "sdptool" << "browse" << remDevice;
     m_sdp->setName( remDevice.latin1() );
     qWarning("search Services for %s", remDevice.latin1() );
-    connect(m_sdp, SIGNAL(processExited(OProcess*) ),
+    connect(m_sdp, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotSDPExited(OProcess* ) ) );
-    connect(m_sdp, SIGNAL(receivedStdout(OProcess*, char*,  int ) ),
+    connect(m_sdp, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*,  int ) ),
             this, SLOT(slotSDPOut(OProcess*, char*, int) ) );
     if (!m_sdp->start(OProcess::NotifyOnExit,  OProcess::AllOutput) ) {
         qWarning("could not start sdptool" );
         delete m_sdp;
         Services::ValueList list;
         emit foundServices( remDevice, list );
@@ -243,15 +245,15 @@ void Manager::connectTo( const QString& mac) {
 
 void Manager::searchConnections() {
     qWarning("searching connections?");
     OProcess* proc = new OProcess();
     m_hcitoolCon = QString::null;
 
-    connect(proc, SIGNAL(processExited(OProcess*) ),
+    connect(proc, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotConnectionExited( OProcess*) ) );
-    connect(proc, SIGNAL(receivedStdout(OProcess*, char*, int) ),
+    connect(proc, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotConnectionOutput(OProcess*, char*, int) ) );
     *proc << "hcitool";
     *proc << "con";
 
     if (!proc->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         ConnectionState::ValueList list;
@@ -302,15 +304,15 @@ ConnectionState::ValueList Manager::parseConnections( const QString& out ) {
 }
 
 void Manager::signalStrength( const QString &mac ) {
 
     OProcess* sig_proc = new OProcess();
 
-    connect(sig_proc, SIGNAL(processExited(OProcess*) ),
+    connect(sig_proc, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotSignalStrengthExited( OProcess*) ) );
-    connect(sig_proc, SIGNAL(receivedStdout(OProcess*, char*, int) ),
+    connect(sig_proc, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotSignalStrengthOutput(OProcess*, char*, int) ) );
     *sig_proc << "hcitool";
     *sig_proc << "lq";
     *sig_proc << mac;
 
     sig_proc->setName( mac.latin1() );
diff --git a/noncore/net/opietooth/lib/manager.h b/noncore/net/opietooth/lib/manager.h
index abc8ba1..9b1c714 100644
--- a/noncore/net/opietooth/lib/manager.h
+++ b/noncore/net/opietooth/lib/manager.h
@@ -8,13 +8,13 @@
 #include <qvaluelist.h>
 
 #include "connection.h"
 #include "remotedevice.h"
 #include "services.h"
 
-class OProcess;
+namespace Opie {namespace Core {class Opie::Core::OProcess;}}
 namespace OpieTooth {
     class Device;
     /** Manager manages a blueZ device (hci0 for example)
      *  without Manager you can control the things you
      *  could do from command line in a OO and asynchronus
      *  way.
@@ -139,35 +139,35 @@ namespace OpieTooth {
         void foundServices( const QString& device, Services::ValueList );
         void foundDevices( const QString& device, RemoteDevice::ValueList );
         void connections( ConnectionState::ValueList );
         void signalStrength( const QString& mac, const QString& strengh );
 
 private slots:
-        void slotProcessExited(OProcess* );
+        void slotProcessExited(Opie::Core::OProcess* );
 
-        void slotSDPExited(OProcess*);
-        void slotSDPOut(OProcess*, char*, int);
+        void slotSDPExited(Opie::Core::OProcess*);
+        void slotSDPOut(Opie::Core::OProcess*, char*, int);
 
-        void slotHCIExited(OProcess* );
-        void slotHCIOut(OProcess*, char*, int );
+        void slotHCIExited(Opie::Core::OProcess* );
+        void slotHCIOut(Opie::Core::OProcess*, char*, int );
 
-        void slotConnectionExited(OProcess* );
-        void slotConnectionOutput(OProcess*, char*, int );
+        void slotConnectionExited(Opie::Core::OProcess* );
+        void slotConnectionOutput(Opie::Core::OProcess*, char*, int );
 
-        void slotSignalStrengthOutput( OProcess*, char*, int );
-        void slotSignalStrengthExited( OProcess* );
+        void slotSignalStrengthOutput( Opie::Core::OProcess*, char*, int );
+        void slotSignalStrengthExited( Opie::Core::OProcess* );
     private:
         Services::ValueList parseSDPOutput( const QString& );
         RemoteDevice::ValueList parseHCIOutput( const QString& );
         ConnectionState::ValueList parseConnections( const QString& );
-        OProcess *m_hcitool;
-        OProcess *m_sdp; // not only one
+        Opie::Core::OProcess *m_hcitool;
+        Opie::Core::OProcess *m_sdp; // not only one
         QString m_device;
         QMap<QString, int> m_signalStrength;
         QMap<QString, QString> m_out;
         QMap<QString, QString> m_devices;
-        QMap<OProcess*, QString> m_signalMac;
+        QMap<Opie::Core::OProcess*, QString> m_signalMac;
         QString m_hcitoolCon;
     };
 };
 
 #endif
diff --git a/noncore/net/opietooth/lib/startdunconnection.cpp b/noncore/net/opietooth/lib/startdunconnection.cpp
index c3850eb..90ef04a 100644
--- a/noncore/net/opietooth/lib/startdunconnection.cpp
+++ b/noncore/net/opietooth/lib/startdunconnection.cpp
@@ -1,12 +1,14 @@
 
 #include "startdunconnection.h"
 
 using namespace OpieTooth;
 
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 StartDunConnection::StartDunConnection() {
     m_dunConnect = 0l;
     setConnectionType();
 }
 
 StartDunConnection::~StartDunConnection() {
@@ -36,15 +38,15 @@ StartConnection::ConnectionType StartDunConnection::type() {
 }
 
 void StartDunConnection::start()  {
     m_dunConnect = new OProcess();
     *m_dunConnect << "dund" << "--listen" << "--connect"  << m_mac;
 
-    connect( m_dunConnect, SIGNAL( processExited(OProcess*) ) ,
+    connect( m_dunConnect, SIGNAL( processExited(Opie::Core::OProcess*) ) ,
              this, SLOT( slotExited(OProcess*) ) );
-    connect( m_dunConnect, SIGNAL( receivedStdout(OProcess*,char*,int) ),
+    connect( m_dunConnect, SIGNAL( receivedStdout(Opie::Core::OProcess*,char*,int) ),
              this, SLOT( slotStdOut(OProcess*,char*,int) ) );
     if (!m_dunConnect->start( OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning( "could not start" );
         delete m_dunConnect;
     }
 }
diff --git a/noncore/net/opietooth/lib/startdunconnection.h b/noncore/net/opietooth/lib/startdunconnection.h
index 43a852a..f6107f6 100644
--- a/noncore/net/opietooth/lib/startdunconnection.h
+++ b/noncore/net/opietooth/lib/startdunconnection.h
@@ -1,12 +1,12 @@
 #ifndef startdunconnection_h
 #define startdunconnection_h
 
 #include <qobject.h>
 #include "connection.h"
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 namespace OpieTooth {
 
     class StartDunConnection : StartConnection {
 
         Q_OBJECT
@@ -24,17 +24,17 @@ namespace OpieTooth {
         void stop();
 
     private:
         QString m_name;
         QString m_mac;
         ConnectionType m_connectionType;
-        OProcess* m_dunConnect;
+        Opie::Core::OProcess* m_dunConnect;
         
     private slots:
-        void slotExited( OProcess* proc );
-                void slotStdOut( OProcess* proc, char* chars, int len );
+        void slotExited( Opie::Core::OProcess* proc );
+                void slotStdOut( Opie::Core::OProcess* proc, char* chars, int len );
     };
 
  
 }
 
 #endif
diff --git a/noncore/net/opietooth/lib/startpanconnection.cpp b/noncore/net/opietooth/lib/startpanconnection.cpp
index a42b407..fef35d9 100644
--- a/noncore/net/opietooth/lib/startpanconnection.cpp
+++ b/noncore/net/opietooth/lib/startpanconnection.cpp
@@ -1,12 +1,14 @@
 
 #include "startpanconnection.h"
 
 using namespace OpieTooth;
 
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 StartPanConnection::StartPanConnection() {
     m_panConnect = 0l;
     setConnectionType();
 }
 
 StartPanConnection::~StartPanConnection() {
@@ -37,15 +39,15 @@ StartConnection::ConnectionType StartPanConnection::type() {
 
 void StartPanConnection::start()  {
     m_panConnect = new OProcess();
     qDebug( "IM START " + m_mac );
     *m_panConnect << "pand" << "--connect" << m_mac;
 
-    connect( m_panConnect, SIGNAL( processExited(OProcess*) ) ,
+    connect( m_panConnect, SIGNAL( processExited(Opie::Core::OProcess*) ) ,
              this, SLOT( slotExited(OProcess*) ) );
-    connect( m_panConnect, SIGNAL( receivedStdout(OProcess*,char*,int) ),
+    connect( m_panConnect, SIGNAL( receivedStdout(Opie::Core::OProcess*,char*,int) ),
              this, SLOT( slotStdOut(OProcess*,char*,int) ) );
     if (!m_panConnect->start( OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning( "could not start" );
         delete m_panConnect;
     }
 }
@@ -67,15 +69,15 @@ void StartPanConnection::stop()  {
     }
     m_panConnect = new OProcess();
     qDebug("IM STOP " + m_mac);
 
     *m_panConnect << "pand" << "--kill" << m_mac;
 
-    connect( m_panConnect, SIGNAL( processExited(OProcess*) ) ,
+    connect( m_panConnect, SIGNAL( processExited(Opie::Core::OProcess*) ) ,
              this, SLOT( slotExited(OProcess*) ) );
-    connect( m_panConnect, SIGNAL( receivedStdout(OProcess*,char*,int) ),
+    connect( m_panConnect, SIGNAL( receivedStdout(Opie::Core::OProcess*,char*,int) ),
              this, SLOT( slotStdOut(OProcess*,char*,int) ) );
     if (!m_panConnect->start( OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning( "could not stop" );
         delete m_panConnect;
     }
 }
diff --git a/noncore/net/opietooth/lib/startpanconnection.h b/noncore/net/opietooth/lib/startpanconnection.h
index 7e5bd95..e12dad0 100644
--- a/noncore/net/opietooth/lib/startpanconnection.h
+++ b/noncore/net/opietooth/lib/startpanconnection.h
@@ -1,12 +1,12 @@
 #ifndef startpanconnection_h
 #define startpanconnection_h
 
 #include <qobject.h>
 #include "connection.h"
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 namespace OpieTooth {
 
     class StartPanConnection : StartConnection {
 
         Q_OBJECT
@@ -24,17 +24,17 @@ namespace OpieTooth {
         void stop();
 
     private:
         QString m_name;
         QString m_mac;
         ConnectionType m_connectionType;
-        OProcess* m_panConnect;
+        Opie::Core::OProcess* m_panConnect;
         
     private slots:
-        void slotExited( OProcess* proc );
-        void slotStdOut( OProcess* proc, char* chars, int len );
+        void slotExited( Opie::Core::OProcess* proc );
+        void slotStdOut( Opie::Core::OProcess* proc, char* chars, int len );
     };
 
  
 }
 
 #endif